c++基础知识：静态成员

C++之静态成员

C++的静态成员是一种特殊类型的成员，可以与一个类的任意对象无关，而是与整个类相关。在本篇博客中，我将为您介绍静态成员的定义、用法、区别以及一些使用注意事项。（初学者可以直接看案列2！！！）

定义和用法

静态成员可以是类的数据成员或函数成员，声明时必须使用static关键字，并且只能在类体外进行初始化。在使用静态成员时无需创建对象，直接使用类名和作用域解析运算符即可访问。

静态数据成员可以用于存储与类相关的数据，通常用于记录类创建的数量或者与类相关的常量。静态函数成员可以用于执行与类相关的操作，通常用于访问静态数据成员或执行与类相关的计算。

示例代码：

class MyClass {
  public:
    static int count;
    static void printCount() {
      cout << "The count is: " << count << endl;
    }
};
int MyClass::count = 0; // 在类外初始化静态数据成员

int main() {
  MyClass::printCount(); // 调用静态函数成员
  MyClass obj1, obj2;
  cout << "Before any object creation, the count is: " << MyClass::count << endl;
  obj1.count++;
  cout << "After obj1 creation, the count is: " << MyClass::count << endl;
  obj2.count++;
  cout << "After obj2 creation, the count is: " << MyClass::count << endl;
  obj1.printCount();
  return 0;
}

区别

静态成员与普通成员之间的区别主要有以下几点：

1. 静态成员是类的成员，而不是对象的成员，因此无需创建对象即可访问。

2. 静态成员只有一份，即使创建多个对象，也只有一份静态成员。

3. 在访问静态成员时，需要使用作用域解析运算符(::)来区分不同的作用域，如MyClass::count。非静态成员必须实例化才能调用。

案例1

下面的示例代码演示了如何使用静态成员来记录创建的类的数量：

class Employee {
  public:
    Employee(char* name) : name(name) {
      count++;
    }
    ~Employee() {
      count--;
    }
    static int getCount() {
      return count;
    }
  private:
    char* name;
    static int count; 
};
int Employee::count = 0; // 一定要在类外初始化静态数据成员

int main() {
  cout << "Initially, there are " << Employee::getCount() << " employees." << endl;
  Employee emp1("Alice");
  Employee emp2("Bob");
  Employee emp3("Charlie");
  cout << "After creating 3 employees, there are " << Employee::getCount() << " employees." << endl;
  return 0;
}

注意一下析构函数

#include <iostream>

using namespace std;

class Myclass{

public:

    static int objNum;

    Myclass(){
        objNum++;
    }

    ~Myclass(){
        objNum--;
    }

    static int getNumofObj(){
        return objNum;
    }

};

int Myclass::objNum = 0;

int main()
{
    Myclass m1;
    cout << Myclass::objNum<< endl;
    Myclass m2;
    cout << m2.objNum<< endl;
    Myclass m3;
    cout << Myclass::getNumofObj()<< endl;

    Myclass *m4 = new Myclass;
    cout << Myclass::getNumofObj()<< endl;

    delete m4;
    cout << Myclass::getNumofObj()<< endl;
    return 0;
}
//结果：1 2 3 4 3
//================================================

#include <iostream>

using namespace std;

class Myclass{

public:

    static int objNum;

    Myclass(){
        objNum++;
    }

    static int getNumofObj(){
        return objNum;
    }

};

int Myclass::objNum = 0;

int main()
{
    Myclass m1;
    cout << Myclass::objNum<< endl;
    Myclass m2;
    cout << m2.objNum<< endl;
    Myclass m3;
    cout << Myclass::getNumofObj()<< endl;

    Myclass *m4 = new Myclass;
    cout << Myclass::getNumofObj()<< endl;

    delete m4;
    cout << Myclass::getNumofObj()<< endl;
    return 0;
}
//没有析构函数，结果：1 2 3 4 4 

案列2

初学者看过来！！！
这个案列中的代码以及注释讲述了静态变量和静态函数的用法，简单易懂！初学者可以直接看这个案列。

#include <iostream>
#include <string>
using namespace std;

/*=============静态成员变量==============*/
/*
1.所有对象共享同一份数据，只要有一个去改写原始的数据，另一个去再访问的数据就会跟着变
2.编译阶段分配内存
3.类内声明，类外初始化操作
*/

/*=============静态成员函数==============*/
/*
1.所有对象共享同一函数
2.静态成员函数只能访问静态成员变量
*/
class Person
{
public:

    static void func()
    {
        m_a = 5;  //静态成员函数访问静态成员变量
        //m_d = 4; 访问不了非静态成员变量，因为不知道m_d是哪一个对象的，而m_a是公用的
        cout <<"静态成员函数访问！"<< endl;
    }

    static int m_a;
    int m_d;

private:
    static int m_b;
}; 
//在访问静态成员时，需要使用作用域解析运算符(::)来区分不同的作用域
int Person::m_a = 99; //类外初始化
int Person::m_b = 22;

void test1()
{
    Person p1;
    cout << p1.m_a << endl;
    //所有对象共享同一份数据，只要有一个去改写原始的数据，另一个去再访问的数据就会跟着变
    Person p2;
    p2.m_a = 10;
    cout << p1.m_a << endl;  //变成10

}

void test2()
{
    /*静态成员变量不属于任何一个对象，所有对象共享一份数据
     因此两种访问的方式*/

    //1.通过创建对象进行访问
    Person p;
    cout <<p.m_a<< endl;
    //2.通过类名直接访问
    cout<<Person::m_a<< endl;
    //cout<<Person::m_b<< endl; 静态成员变量也有访问权限
}

void test3()
{
    //1.通过创建对象进行访问呢
    Person p;
    p.func();
    //2.通过类名直接访问,因为不属于任何一个对象
    Person::func();

    //静态函数也有访问权限，类外访问不到私有静态成员变量
}

int main()
{
    //test1();
    //test2();
    test3();

    return 0;
}

使用注意事项

在使用静态成员时，需要注意以下几点：

1. 静态成员必须在类外进行初始化，在定义时不能赋初始值。

2. 静态成员只能直接访问类的静态成员和静态函数成员，不能访问普通成员。

3. 静态成员函数只能访问静态成员，不能访问普通成员。

4. 如果一个静态成员函数想要被继承，则需要在函数声明中使用关键字virtual。

总结

静态成员是C++语言中非常有用的特性，可以用于存储与类相关的常量或变量，或者执行与类相关的操作。在使用时，需要遵守一些使用注意事项，以保证程序的正确性和可靠性。