C++静态成员和静态函数（类）

C++类的静态成员变量是需要初始化的，实际上不是为了初始化而初始化，本质上是要定义，分配内存。需要在类的外部进行定义。

静态成员变量：

静态成员变量和常用的全局变量比较类似。

先看一个头文件animal.h

#ifndef DUOTAIJINGTAI_ANIMAL_H
#define DUOTAIJINGTAI_ANIMAL_H

#include <string>

class animal {
public:
    animal()= default;
    static void print(std::string &a);
    void Gettpye();
    static std::string type;
    int staif;

protected:
    int food;
    int fur;


};

#endif //DUOTAIJINGTAI_ANIMAL_H

这是我的一个类的头文件，这里面申明了一个静态的string变量，当然申明完之后是不能用的，如果直接调用，直接报“未定义的错误”，那在哪里定义呢，下面看

annimal.cpp

#include <iostream>
#include "../include/animal.h"
void animal:: print(std::string &a)
{
    //std::cout<<a<<staif<<std::endl;
    a="changed in print";
    std::cout<<a<<std::endl;
}
void animal:: Gettpye()
{
    std::cout<<type<<std::endl;
    type ="changed in get type";
    std::cout<<type<<std::endl;
}

std:: string animal::type ="hello";

我在cpp定义的，定义方式就是[类型]+[类名]+[变量名]，可以初始化，也可以不初始化，不初始化我试了一下，是空的字符串。

以上是静态变量，静态存在的用处是不管哪个对象进行使用，它的内存只有一块，所有相同类的对象，调用的静态变量都是一个，每一个对象都可以对它进行操作，毕竟它是类成员。

静态函数：

静态函数是为静态变量准备的，在实际外部操作静态变量的时候，可以不申明对象，直接用静态函数操作静态变量，下面看主函数：

main.cpp

#include <iostream>
#include "include/animal.h"
#include <string>
int main() {
    animal::print(animal::type);
    animal::type ="hello delete";
    animal::print(animal::type);
    animal *test = new animal();
    test->Gettpye();
    animal::type ="hello delete change";
    animal test_;
    test_.Gettpye();

    return 0;
}

在外部使用静态函数的方法是[类名]::[静态函数]，这样可以直接对静态变量进行操作，其实类内部函数对静态变量也是一样操作的，就如我定义的Gettype，这个函数也可以直接访问静态变量并修改。那为什么还要有静态函数呢。

我的理解就是静态函数使用的时候不需要创建对象，而且静态函数只能对静态变量进行操作，类内部的非静态变量它是没有权限碰的。

继承相关：

静态变量和静态成员都可以继承和重写

静态变量（函数）如果被重写之后，就会重新生成变量和函数地址，开拓新的内存空间存放；如果没有被重写，那么就会被继承，不会开拓新的内存。也就是说，如果父类的静态成员，没有被重写，那么所有的父类的对象，子类的对象，都享用用一份静态成员的内存， 同时也可以利用子类或者父类直接去访问（类名：：静态变量）

#include <iostream>

using namespace std;

class Single {

};

class stest {
public:
    static int s;
    static void get_s()
    {
        cout << "s value is: " << s << endl;

    }
};
int stest::s = 10;

class schld :public stest {
public:
    // schld():s(12){}

    static int ss;        // 申明和父类同名的静态成员变量
    static void get_s_chld()  //利用子类的静态成员函数访问父类的s成员
    {
        cout << "s value is: " << s << endl;

    }
    static void get_s()   //重写的父类静态成员函数访问父类的s成员
    {
        cout << "s value is child: " << s << endl;

    }

};

//int schld::s = 20;         // 初始化定义子类的静态成员变量
void test() {
    schld sc;
    schld::stest::s++;      //通过类名访问静态成员s
    schld::stest::get_s();  //通过父类的静态成员函数访问父类的静态函数， 可以这么写，但感觉多此一举，直接利用  父类名：：静态函数 即可
    stest::get_s();         //效果和上面一样
    sc.stest::s++;          // 通过子类的对象，访问父类的静态成员变量
    cout << stest::s << endl;
    cout << sc.s << endl;       // 如果子类中声明了两个同名的静态变量，两个静态变量互不干扰，否则，子类使用父类的静态变量
    sc.s++;
    cout << stest::s << endl;
    schld::stest::get_s();
    schld::get_s_chld();
    schld::get_s();
    cout << sc.s << endl;

}

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

总结就两点：

1.静态成员在申明完之后需要像函数一样进行一下定义，本质是给它分配内存；静态变量不通过申明对象，直接写一个类的作用范围，直接用，当然也可以通过对象调用，当然前提是是public的，可以在外部用，否则不行，如果非要访问可以定义一个public的（静态）函数去get。

2.静态函数可以不通过申明对象，直接写一个类的作用范围，直接用，当然也可以通过对象调用；只能对静态变量进行操作，类内部的非静态变量它是没有权限碰的

3. 关于继承，基本上根据上述的特性，能够想到的特性都有，和其他成员继承的特性基本一致，最厉害的就是如果静态成员没有被重写，内存只有一份，比较厉害，可以看看所有的对象以及派生对象一共有多少个，应该是有一些场景是需要用到这个特性的，哈哈哈

应该说的差不多了，有疑问欢迎留言讨论。

引用了这哥们的继承部分的代码，备注一下：

c++中类的静态变量可以被继承_skk1faker的博客-CSDN博客