C++静态成员

静态成员使用static修饰的成员，

可以修饰属性，函数

被static所修饰的成员可以被类任何的对象使用且共享

先看一下怎么用static修饰成员

值得注意的是，被static修饰的成员要先初始化一下，否则会报错哦

#include <iostream>
using namespace std;

class teach{
    private:
        static int counter;
        int id;

    public:
        teach();
        void show();

        static void setcounter(int);

};

//十分十分的重要重要重要重要重要重要重要重要重要重要重要
int teach::counter = 1;

teach::teach()
{
    id = counter++;
}
void teach::show()
{
    cout<<id<<endl;
}

void teach::setcounter(int new_counter)
{
    counter = new_counter;
}



int main()
{
    cout<<"下面是学号"<<endl;
    teach s1;
    s1.show();
    teach s2;
    s2.show();
    teach s3;
    s3.show();
    s1.setcounter(10);
    teach s4;
    s4.show();
    teach s5;
    s5.show();
    return 0;
}

现在看一下怎么用static修饰函数，也在上面

总结一些，static修饰的成员，用的时候只有声明的时候和重载的时候要写，

比如

        static int counter;

        static void setcounter(int);

int teach::counter = 1;
void teach::setcounter(int new_counter)

共享

#include <iostream>
using namespace std;


class student
{
    //类的属性：
    //学生有id，年龄，姓名等等
    //不能用auto、extern、regist修饰
    //可以static修饰，静态属性可以进行显性的初始化
    int id;
    int age;
    char* name;
    static char* thing;


    //被private说明为私有
    //访问方式只有：
    //该类的成员函数
    //友元函数
    private:
        char* height;
        static char* country;

    public:
        void show(student stu)
        {
            cout<<stu.age<<endl;
            cout<<stu.name<<endl;
            cout<<stu.id<<endl;
            cout<<stu.height<<endl;
        }
        void show()
        {
            cout<<thing<<endl;
        }

        static inline void setthing(char* str);

        //要想在类外面写函数的函数体，要先声明一下，放在类外面写
        inline void sayhello(student stu);
        //对于使用频繁的可以在前面加上inline，
        //使他成为内联函数，这样会提高他的运行效率
        //所以上面的也可以写成inline void sayhello(student stu);

        student();//构造函数

        student(int mid,int mage,char* mname,char* mheight);//构造函数重载了

        //析构函数一般不内联
        
        inline ~student();//析构函数

        // static void setthing(char* str);
        

};

char* student::thing = (char*)"0";


//在类体外定义的成员函数，必须要用::指出该方法所属于的类
//这个函数必须在类里面声明过
inline void student::sayhello(student stu)
{
    cout<<stu.name<<"：我是"<<stu.name<<"你好"<<endl;
    return ;
}

//编写构造函数
//构造函数的函数名必须与类名相同
//否则视为一般函数
//构造函数没有返回值
//不用说明类型
//只能对属性进行初始化，且一般为私有成员（可以类属性）
//只是一般用来初始化私有属性
//不能被显式调用
student::student(int mid,int mage,char* mname,char* mheight)
{
    id = mid;
    age = mage;
    name = {mname};
    height = {mheight};
}

//重载构造函数
student::student()
{
    id = 0;
    age = 0;
    name = 0;
    height = 0;
}

student::~student()
{
    cout<<"执行析构函数"<<endl;
}

inline void student::setthing(char* str)
{
    thing = str;
}

#include <iostream>
#include "student.h"
using namespace std;


int main()
{
    student stu;//当使用构造函数没有参数时，不要加括号，否则实例化对象失败，用不了类的函数
    // stu1.thing = "456";不可以这样赋值
    stu.setthing((char*)"789987789");
    student stu2;
    stu2.show();
    return 0;
}