c++静态成员

目录

静态成员

静态成员变量

静态成员函数

const 静态成员属性

静态成员实现单例模式

---

静态成员

在类定义中，它的成员（包括成员变量和成员函数），这些成员可以用关键字 static 声明为静态的，称为静态成员。 不管这个类创建了多少个对象，静态成员只有一个拷贝，这个拷贝被所有属于这个类的对象共享

静态成员变量

静态成员变量在内存中只有一份，多个成员共享一个静态变量

静态成员变量必须类内声明，类外定义

静态成员变量可以通过类的作用域访问

静态成员变量可以通过类的对象访问

class Person{
    public:
        //类的静态成员属性
        static int sNum;
    private:
        static int sOther;
};
//类外初始化，初始化时不加 static
int Person::sNum = 0;
int Person::sOther = 0;
int main(){
    //1. 通过类名直接访问
    Person::sNum = 100;
    cout << "Person::sNum:" << Person::sNum << endl;
    //2. 通过对象访问
    Person p1, p2;
    p1.sNum = 200;
    cout << "p1.sNum:" << p1.sNum << endl;
    cout << "p2.sNum:" << p2.sNum << endl;
    //3. 静态成员也有访问权限，类外不能访问私有成员
    //cout << "Person::sOther:" << Person::sOther << endl;
    Person p3;
    //cout << "p3.sOther:" << p3.sOther << endl;
    system("pause");
    return 0;
}

静态成员函数

静态成员函数只能访问静态变量，不能访问普通成员变量

静态成员函数的使用和静态成员变量一样

静态成员函数也有访问权限

普通成员函数可访问静态成员变量、也可以访问非经常成员变量

class Person{
    public:
        //普通成员函数可以访问 static 和 non-static 成员属性
        void changeParam1(int param){
            mParam = param;
            sNum = param;
        }
        //静态成员函数只能访问 static 成员属性
        static void changeParam2(int param){
            //mParam = param; //无法访问
            sNum = param;
        }
    private:
        static void changeParam3(int param){
            //mParam = param; //无法访问
            sNum = param; 
        }
    public:
        int mParam;
        static int sNum;
};
//静态成员属性类外初始化
int Person::sNum = 0;
int main(){
    //1. 类名直接调用
    Person::changeParam2(100);
    //2. 通过对象调用
    Person p;
    p.changeParam2(200);
    //3. 静态成员函数也有访问权限
    //Person::changeParam3(100); //类外无法访问私有静态成员函数
    //Person p1;
    //p1.changeParam3(200);
    return 0;
}

const 静态成员属性

const修饰的静态成员变量保存在常量区 只读权限 在内存中只有一份

const修饰的静态成员变量可以在类内定义且初始化

const修饰的静态成员变量可以通过类的定义域访问

const修饰的静态成员变量可以通过对象访问

静态成员函数可以访问const修饰的静态成员变量

#include 
#include 
using namespace std;

class Person
{
    public:
        int a;
        //静态成员变量不能再类内初始化 类内只能声明 定义在全局 声明的作用只是限制静态变
量作用域
        static int b;//静态成员变量 在编译阶段就被分配内存 存在静态全局区
        const static int c = 1000;//const 修饰的静态全局变量 时保存在常量区 不可修改(只
读) 在内存中只有一份
};


void test01()
{
    cout << Person::c << endl;
    Person p1;
    cout << p1.c << endl;
}
int main()
{
    test01();
    return 0;
}

静态成员实现单例模式

单例模式：一个类只能创建出一个对象

单例模式实现的步骤：

        1.将无参构造私有化

        2.将拷贝构造私有化

        3.定义一个静态的成员指针变量

        4.将静态的成员指针变量私有化提供获得唯一对象的地址接口

#include 
#include 

using namespace std;

class Person
{
	public:
		int age;
		int studenid;
		static Person* instance()
		{
			return single;
		}
	private:
		Person()//无参构造私有化
		{
		}
		Person(const Person &p)//拷贝对象私有化
		{
		}	
		static Person *single;
};

Person *Person::single = new Person;

void test03()
{   
	Person* p = Person::instance();
	p->age = 10;
	p->studenid = 20;

	Person* p1 = Person::instance();
	cout << p1->age<<""<studenid<age = 100;
	//Person::single->studenid = 100;

	//Person p1(*Person::single);调用拷贝构造实例化出一个对象
}

int main()
{
    test03();
    return 0;
}