C++:10---类静态成员(static)、类常量成员(const)

一、类静态成员(static)

先介绍一下什么是静态变量、静态函数

• 静态局部变量：存在域（全局数据区），作用域（块作用域）
• 静态全局变量：存在域（全局数据区），作用域（整个文件）
• 静态函数：存在域（全局数据区），作用域（整个文件）

static int a=10;//全局静态变量
static void add();//静态函数
int main()
{
    {
        static int b=10;//局部静态变量
    }
}

• 特点：
  • 静态static修饰的变量、函数，只需要初始化一次，下次再执行到static修饰的相同代码时，自动跳过。
  • 静态static修饰的变量、函数，从程序开始执行时生效，且只在当前文件(.c/cpp)有效，其他文件不可用

静态数据成员

• 静态成员不属于某一个对象，而是属于整个类（定义在数据段）
• 静态成员供所有对象共享，每个对象可以调用且修改。一个对象修改，其他对象也跟着变化
• static成员变量可以在类型声明并初始化。但是建议在类内定义、类外初始化
• 可以直接通过类名直接访问

class Cperson
{
private:
    static int age;
    static int getAge();
}
//类外初始化
int Cperson::age = 18;

int Cperson::getAge()
{
    return age;
}

int main()
{
    Cperson person1;
    person.age = 20;//调用并改变静态成员
    
    //直接通过类名就可调用
    cout << Cperson::age; //20
    Cperson::getAge();
}

• 下面也是一个非常重要的演示案例，其动态的改变了静态成员的值

#include <iostream>

using namespace std;

class widget
{
public:
    widget()
    {
        count++;
    }
    ~widget()
    {
        count--;
    }
    static int num()
    {
        return count;
    }
private:
    static int count;
};

int widget::count = 0;

int main()
{
    widget x, y;
    cout << "The Num.is " << widget::num() << endl;
    if(widget::num() > 1)
    {
        widget x, y, z;
        cout << "The Num.is " << widget::num() << endl;
    }
    widget z;
    cout << "The Num.is " << widget::num() << endl;

    return 0;        
}

类静态函数

• 因为静态函数不属于某一对象，所以函数内不存在this指针
• 静态成员函数不能被声明为const类型（“静态成员函数是属于类的,而不是某个具体对象,在没有具体对象的时候静态成员就已经存在,静态成员函数不会访问到非静态成员,也不存在this指针。而成员函数的const就是修饰this指针的,既然静态成员函数不会被传递this指针,那const自然就没有必要了”）
• 静态函数内部只能访问静态成员(变量、函数)，不能访问普通成员。原因：静态函数在类定义时就已经开辟内存空间，而普通成员只有当定义对象时开会开辟内存空间，所以调用普通成员会出错
• 普通函数内部可以调用静态成员，也可以调用普通成员。原因：同上，普通函数调用时开辟内存空间，所有都可调用

class Cperson
{
private:
    float height;
    static int age;
    static void setPerson();
}
int Cperson::age=18;
void Cperson::setPerson()
{
    age=20;//正确，可调用静态成员
    height=178;//错误，不可调用普通成员
}

二、类常量成员(const)

const数据成员

• 特点：
  • const数据成员只能在构造函数的初始化列表进行初始化
  • const数据成员在初始化之后，不允许再次修改值

class Cperson
{
private:
    const int age;//常量数据成员
    float height;
public:
    Cperson(int age,float height);
};

Cperson::Cperson(int age,float height):age(age)
{
    this->height=height;
}

const函数成员

• 特点
  • const函数成员的目的：函数内不准对类的成员数据进行更改
  • 可以改变函数的非const参数、以及函数内部的局部变量
  • const成员函数不可调用非const函数成员(本质：防止修改非const函数内的值)
• 优点
  • 能通过const语法防止我们对自身类的数据进行误操作
  • 当对象为常量对象时，只允许访问类的常量函数成员

class Cperson
{
private:
    const int age;//常量数据成员
    float height;
public:
    int getAge()const;
    void setHeight(float height);
};
int Cperson::getAge()const
{
    //age++;//错误做法，不准对成员变量进行修改
    return age;
}
void Cperson::setHeight(float height)
{
    this->height=height;
}

int main()
{
    Cperson person1;
    person1.getAge();//正确
    person1.setHeight(175.5);//正确

    const Cperson person1;
    //person1.setHeight(175.5);错误，const对象不能调用非const函数
    person1.getAge();//正确
}

基于const函数的重载

• const函数的重载，调用的时候，系统根据定义的类对象类型来调用对应的函数

calss Person
{
    int age;
public:
    Person& setAge(int age);//一
    const Person& setAge(int age)const;//二
};
int main()
{
    Person p1;
    const Person p2;
    p1.setAge(18);//调用第一个
    p2.setAge(20);//调用第二个
}