C++中类的const与static关键字修饰函数与变量辨析

文章目录

• const修饰类的成员函数
• const修饰类的成员变量
• static修饰类的成员函数
• • public
  • private
• static修饰类的成员变量
• • public
  • private
• const与static共同修饰类的成员函数
• const与static共同修饰类的成员变量

const修饰类的成员函数

承诺该函数不会修改类的任何非 mutable 成员变量

void func() const;

1、常对象只能调用 const 成员函数

2、非常对象可以调用所有成员函数（包括 const 和非 const）

3、函数内部不能调用非 const 成员函数。

const修饰类的成员变量

该成员变量在对象生命周期内不可修改。

const int data;

1、必须在初始化列表中初始化

static修饰类的成员函数

属于类本身，而非类的某个对象。

static void func();

1、没有 this 指针，因此不能访问非静态成员（变量或函数）。

public

可通过类名直接调用：类名::函数名()。

class MyClass {
public:
    static void publicStaticFunc() {
         cout<<"可通过类名直接调用：类名::函数名()。"<<endl;
    }
    
};

int main() {
    MyClass::publicStaticFunc();  
}

private

外部无法直接访问私有静态函数

1、通过public静态函数间接访问（public静态函数内部可以调用private静态函数）

2、通过public成员函数间接访问（public成员函数也可以调用private静态函数）

3、友元访问

4、通过公有指针暴露私有函数

class MyClass {
private:
    static void privateStaticFunc() {
        std::cout << "Private static function called" << std::endl;
    }
    
public:
    static void publicStaticFunc() {
        privateStaticFunc();  // 类内部可以调用私有静态函数
    }
    
    void publicMemberFunc() {
        privateStaticFunc();  // 成员函数也可以调用
    }
};

int main() {
    MyClass::publicStaticFunc();  // 通过公有静态函数间接访问
    MyClass obj;
    obj.publicMemberFunc();       // 通过公有成员函数间接访问
    // MyClass::privateStaticFunc(); // 错误：外部无法直接访问私有静态函数
}

static修饰类的成员变量

类的所有对象共享同一个静态成员。

static int count;

1、必须在类外单独定义（分配存储空间）（类外定义不受访问权限限制）

class Student {
private:
    static int count;           // 静态成员变量声明

    
public:
    ...
};

// 静态成员变量必须在类外定义和初始化
int Student::count = 0;

2、不占用对象的内存空间，属于类级别。

public

直接访问类名:: 函数名();

Student::count++；

private

类外不能直接访问

int main() {
    // ❌ 无法直接访问
    // std::cout << Student::count;  // 错误：私有成员   
    return 0;
}

1、通过public静态成员函数访问

class Student {
private:
    static int count;           // 私有静态成员
    
public:
    Student() { count++; }
    ~Student() { count--; }
    
    // 公有静态成员函数作为接口
    static int getCount() {
        return count;
    }
};

// 类外定义
int Student::count = 0;

int main() {
    Student::resetCount();
    return 0;
}

2、通过public成员函数访问

class Counter {
private:
    static int value;
    
public:
    Counter() { value++; }
    
    // 公有成员函数也可以访问私有静态变量
    int getValue() const {
        return value;
    }
};
//类外初始化
int Counter::value = 0;

int main() {
    Counter c1, c2;
    
    // 通过对象调用公有成员函数
    std::cout << c1.getValue() << std::endl;  // 2
    std::cout << c2.getValue() << std::endl;  // 2（同一个值）
    
    c1.increment();
    std::cout << c2.getValue() << std::endl;  // 3（c1修改影响c2）
    
    return 0;
}

3、通过友元函数访问

4、通过引用或指针返回（公有指针暴露）

const与static共同修饰类的成员函数

禁止

static 函数没有 this 指针，而 const 后缀是用来修饰 this 的，两者冲突，因此 不能同时使用。

const与static共同修饰类的成员变量

属于类的常量，所有对象共享且不可修改。

static const int value; 
const static int value;//（顺序无关）