静态数据 成员和静态函数

  一:

静态数据成员的出现是为了解决这样一类的问题的:让所有的对象共享一个对象。

比如,现在定义一个银行卡的类,有两个数据成员,money的总数num 和 利率rate。因为rate对于所有的对象是一样的,如果所有的对象

都有一个rate数据成员(如下面的类),就会使效率降低:

1 class card{
2 public:
3 int num;//总数
4 int rate;//利率
5 card (int num,int rate):num(num),rate(rate){}
6 };

二:静态数据成员的声明,定义,和访问:

     要在类内部声明,在外部定义和初始化(就像全局对象那样,即使是private的也是这样的),访问的话可以通过对象访问,也可以通过对象的

     指针访问,还可以通过类来访问(因为静态数据成员和静态函数式不属于任何对象的,他是属于类的)

     

#include<iostream>
#include<string>
using namespace std;
class boy{
    public:
boy(string name):name(name){cout<<this->name<<endl;}
        ~boy(){}
        static int getnumber()
        {
            num++;

            return num;
        }
        string name;
        static int num;

};
int boy::num=0;//在外面定义和初始化,必须加类型
int main()
{
    boy a("abc");
    cout<<boy::getnumber()<<endl;
    boy b("def");
    cout<<b.num<<endl;//静态数据成员的访问时有两种方式
                      //1 通过类来访问 boy::getnumber()
                      //2 通过对象来访问
    cout<<boy::getnumber()<<endl;

    //system("pause");
    return 0;
}

三:静态函数,非静态函数,的访问问题:

    静态函数只能访问静态数据成员,同时他不能调用非静态函数

   但是非静态函数可以访问静态数据成员和非静态数据成员,同时可以调用静态函数,

   静态函数的访问和静态数据成员的访问差不多。

   

#include<iostream>
#include<stdio.h>
using namespace std;
class boy{
    public:
		boy(int a=0):i(a){}//函数后面不要加;
		int i;
		static int j;
	    void mm()
		{
			i++;
			j++;
cout<<"非静态的"<<i<<endl<<"静态的"<<j<<endl;//非静态函数可以访问静态数据成员和非静态数据成员
			gg();//非静态函数可以访问静态函数
		}
		static void gg()
		{
		//	i++; 静态函数不能访问非静态数据成员
		     ++j;
			// mm(); 静态函数不能访问非静态函数
			cout<<"静态的"<<j<<endl;

		}

};
int boy::j=0;// 外面定义时 不加static 而且要有类型说明
int main()
{
	boy k;
    k.mm();//通过对象访问
    k.gg();
	boy * p;
	p=&k;
	p->gg();//通过指针访问
	p->mm();
	boy::gg();//通过类访问
	system("pause");
	return 0;
}

  

     四:一些细节:

     静态数据成员可以是本类的类型,非静态数据成员不行

     静态数据成员可以作为函数的参数,但是非静态的不可以。

     静态数据成员和静态函数即使没有对象也可以访问。

     

#include<iostream>
#include<stdio.h>
using namespace std;
class boy{
	 static int age;
	 int num;
    public:
		 boy(int num):num(num){}//构造函数不能加返回值得类型,包括void
	void	 get(int i=age){cout<<i<<endl;}//静态数据成员可以作为函数的参数
	//void     get2(int i=num){cout<<i<<endl;}//普通数据成员不能作为函数的参数
};
int boy::age=0;
class girl{
	static girl a;//静态数据成员可以使本类的类型
//	girl b;  但是普通数据成员不可以是本类的类型
	int age;
    public:
		girl(int age):age(age){}
		int get(){return age;}
		int get2(){return a.age;}
	
};
girl girl::a(2);// 虽然是priveat的,但还是在外面定义,并初始化,注意初始化
class mm{
      public :
		static  mm a;
		mm(int age):age(age){}
	    int age;
};
mm  mm::a(2);
int main()
{
	boy a(2);
	a.get();
	girl b(3);
//	cout<<b.age<<endl;//private的不能访问
	cout<<b.get()<<endl;
cout<<b.get2()<<endl;//同理 static 也有private  protect     public之分只有public类型的可以访问
	//cout<<girl::a.get()<<endl;  private不能访问
	cout<<mm::a.age<<endl;//静态成员 即使还没有对象也可以访问 
	system("pause");
	return 0;
}

  

    

原文地址:https://www.cnblogs.com/cs1003/p/2810354.html