第三章 类和对象进阶之——类的静态成员

1、静态变量

可以使用static说明自动变量，分为静态全局变量和静态局部变量

(1) 全局变量

全局变量：在所有花括号之外声明的变量，在整个项目文件内都有效。使用static修饰的全局变量是静态全局变量，仅在该文件内有效。

(2) 局部变量

局部变量：块内定义的变量，static修饰的静态局部变量，在整个运行期间都存在，仅在定义的块中有效。静态局部变量具有局部作用域，但却具有全局生存期

(3)静态变量

静态变量只执行一次初次化，如果未显示初始化，相当于初始化为0

【示例】自动变量和静态变量的定义和使用

#include <iostream>
using namespace std;
static int glos = 100;

void f()
{
	int a=1;
	static int fs =1;
	cout <<"在f中： a(自动)="  a << " fs(静态)=" << fs  " glos(静态)=" <<glos << endl;
	a += 2:
	fs += 2;
	glos + 10;
	cout <<"在: a(自动)" << a <<" fs(静态)=" << fs << " glos(静态)=" <<glos << endl;

int main()
{
	static int ms=10;
	for (int i = 1: i <= I; i++)
	f();
	cout<< "ms="<< ms << endl:
	cout << "glos=" << glos << endl:
	return 0;
}

【运行结果】

在f中：a(自动)=1  fs(静态)=1 glos(静态)=100
在f中：a(自动)=3  fs(静态)=3 glos(静态)=110
在f中：a(自动)=1  fs(静态)=3 glos(静态)=110
在f中：a(自动)=3  fs(静态)=5 glos(静态)=120
在f中：a(自动)=1  fs(静态)=5 glos(静态)=120
在f中：a(自动)=3  fs(静态)=7 glos(静态)=130
ms=10
glos=130

2、类的静态成员

类的静态成员:静态成员变量、静态成员函数

在类体内定义类的成员时，在前面添加static关键字

类的静态成员被类的所有对象共享，不论有多少对象，静态成员都只有一份保存在公用内存中

在类定义中声明静态成员变量，必须在类体外定义静态成员变量的初值，不能在类体内赋初值。格式为:

类型 类名::静态成员变量 = 初值;

注意:
在类体外给静态成员赋初值不能加static
访问静态成员时，成员前面可以使用类名、对象名或指针名作前缀
类的静态成员函数没有this指针
不能在静态成员函数中访问非静态成员

【示例】

#include<iostream>
using namespace std;

class classA
{
	public:
	double x,y;
	static int//公有静态成员变量- - 供所有对象”共掌”num
	//用于记英通过构造两数已生成的对象个数
	classA()
	{
		X=0;
		y=0;
		num++; //每生成一个对象，num加1
	}
	classA(double x0,double y0)
	{
		X=X0;
		y=y0;
		num++;
	}
	//静态成员两数，输出成员交量num的当前们
	static void staticFun
	{
	cout<<"current num="<<num<<endl;
	//cout<<"x="<<x<<end1; //销误，在静态两数中不能访问
	}
};

int classA::num = 0; //必须在类体外(使用美名限定)初始化静态成员变量

int main()
{
	classA obj(1.2,3.4),*p; // 调用1次构造函数
	cout<<"classA::num="<<classA::num<<end1;//使用类名做限定符
	classA::staticFun ();
	cout<<end1;
	classA A[3]; //调用3次构造函数
	cout<<"classA::num="<<classA::num<<endl;
	classA::staticFun();
	cout<<end1;
	p = new classA(5.6,7.8); //调用1次构造函数
	cout<<"classA::num="<<classA::num<<endl;
	classA::staticFun ();
	cout<<"p->num="<<p->num<<endl;
	p->staticFun();
	return 0;
}

【运行结果】

classA::num=1
current_num=1

classA::num=4
current_num=4

classA::num=5
current_num=5
p->num=5
current_num=5

3、例题

例题1:[单选题]已知类A中的两个成员函数f1( )和f2( )，如果在f1( )中不能直接调用f2( )，则下列选择中正确的是 ( )
A.f1( ) 和f2( )都是静态函数
B.f1( ) 不是静态函数，f2( ) 是静态函数
c.f1( )是静态函数，f2( ) 不是静态函数
D.f1 ( ) 和f2( ) 都不是静态函数
【正确答案】：C
【答案解析】：不能在静态成员函数中访问非静态成员

例题2:[单选题]下列关于静态成员函数的描述正确的是 ( )
A.静态成员变量是类的所有对象所共有的
B.静态成员变量要在构造函数内初始化
C.类的每个对象有自己的静态成员变量
D.静态成员变量不能通过类的对象访问

【正确答案】：A
【答案解析】：类的静态成员被类的所有对象共享，在类定义中声明静态成员变量，必须在类体外定义静态成员变量的初值，不能在类体内赋初值。访问静态成员时，成员前面可以使用类名对象名或指针名作前缀

例题3:[程序填空题] 将下面的程序补充完整，使程序输出的结果为100。

#include<iostream>
using namespace std;
class Test{
	public:
		——————(1)——————————————;
	Test (int i=10) {x=ix;}
	int Getnum() {return Text::x+7;}
};

————————————(2)————————————;
int main(){
	Test test; 
	cout<<test.Getnum() <<endl;
}

【正确答案】：

（1）static int x
（2）int Test :: x=83

例题4:[程序改错题]

#include<iostream.h>
using namespace std;
class Point
{
	public:
		void init(){}
		static void output(){}
};

void main()
{
	Point P;
	Point::init();
	P.output () ;
}

【正确答案】：

方法一:  void init(){}   改为  static void init(){}
方法二:  Point::init();  改为  Pinit( );

例题5:[程序填空题]完成程序，使其结果为
x=11,y=10
x=6,y=10

#include<iosteam.h>
using namespace std;
class Sample
{
	private:
		int x:
		_______(1)_________;
	public:
		Sample(int a);
		void print();
};
		
Sample:: Sample(____(2)_____)
{
	x=a;
	y=x++;
}

void Sample::print()
{
	cout<<"x="<<x<<"y="<<y<<endl;
}

int Sample::y=25;

void main () 
{
	Sample s1 (5);
	Sample s2(10);
	s1. print ();
	s2. print ();
}

【正确答案】：

(1)	static int y
(2)	int a

例题6:[程序改错题]以下程序有一处错误

#include<iostream>
using namespace std;
class Count
{
	static int count;
	public:
		Count() {cout<<count++;}
		static int Getc(){return count;}
	    ~Count(){count--;}
};

int Count::count=5, obj;
int main()
{
	cout<<obj.Getc()<<endl;
	return 0;
}

【正确答案】：

将 cout<<obj.Getc()<<endl; 	改为	cout< <Count :: Getc( )< <endl;

【答案解析】：静态成员函数不能访问非静态的函数，非静态成员函数可以访问静态成员函数