C++中`const` 和 `static` 关键字详解

C++中const 和 static 关键字详解

1. const 关键字详解

（1）修饰常量

规则：

• const 修饰的变量是不可修改的，即它是一个常量。
• 必须在定义时初始化，否则会报错。

示例代码：

const int x = 10;  // 必须初始化
x = 20;  // 错误，x 不能被修改

例子：

void testConst() {
    const int a = 100;
    // a = 200;  // 错误，a 不能被修改
}

（2）修饰成员变量

规则：

• 只有某个对象的生命周期内是常量，而不同对象之间该成员变量的值可以不同。
• const 成员变量必须在构造函数的初始化列表中进行初始化，不能在类内定义时直接赋值。

示例代码：

class Example {
private:
    const int value;  // 常量成员变量
public:
    // 使用构造函数的初始化列表来初始化 value
    Example(int v) : value(v) {}

    void show() {
        std::cout << "Value: " << value << std::endl;
    }
};

int main() {
    Example obj1(10);
    Example obj2(20);
    obj1.show();  // 输出 Value: 10
    obj2.show();  // 输出 Value: 20
}

（3）修饰成员函数

规则：

• const 修饰成员函数时，表示该函数不能修改类的成员变量。
• const 对象只能调用 const 成员函数，而普通对象可以调用 const 和非 const 成员函数。

示例代码：

class Example {
private:
    int data;
public:
    Example(int d) : data(d) {}

    void setData(int d) {  // 非 const 成员函数，可以修改成员变量
        data = d;
    }

    int getData() const {  // const 成员函数，不能修改成员变量
        return data;
    }
};

int main() {
    Example obj(50);
    std::cout << obj.getData() << std::endl;

    const Example obj2(100);
    std::cout << obj2.getData() << std::endl;
}

2. static 关键字详解

（1）修饰变量

规则：

• static 变量的生命周期是整个程序，即使离开作用域也不会销毁。
• 在类中使用 static 修饰成员变量，表示该变量属于类本身，而不是某个对象，所以所有对象共享同一个 static 变量。

示例代码：

void testStatic() {
    static int count = 0;  // 只会初始化一次
    count++;
    std::cout << "Count: " << count << std::endl;
}

int main() {
    testStatic();  // 输出 Count: 1
    testStatic();  // 输出 Count: 2
}

（2）修饰成员变量

规则：

• static 成员变量属于类，而不是对象，所有对象共享一份内存。
• 必须在类外初始化。

示例代码：

class Example {
public:
    static int count;  // 共享的静态变量
};

int Example::count = 0;

int main() {
    Example e1, e2;
    e1.count = 5;
    std::cout << e2.count << std::endl;
}

（3）修饰成员函数

规则：

• static 成员函数属于类，而不属于某个对象。
• 不能访问非 static 成员变量，因为 static 成员函数没有 this 指针。

示例代码：

class Example {
private:
    static int count;
public:
    static int getCount() {
        return count;
    }
};

int Example::count = 0;

int main() {
    Example e1, e2;
    std::cout << Example::getCount() << std::endl;
}

3. const 和 static 不能同时修饰成员函数

原因：

• static 函数不属于某个对象，因此没有 this 指针。
• const 函数依赖 this 指针（因为它限制修改对象的数据）。
• static 和 const 语义冲突，不能共存。

示例代码：

class Example {
public:
    static void func() const; // 错误，static 和 const 冲突
};

4. 总结

记住核心点：

1. const int* p：指向的值不能变，指针本身可以变。
2. int* const p：指针本身不能变，指向的值可以变。
3. static 变量是全局的，所有对象共享一份。
4. static 成员函数没有 this 指针，只能访问 static 变量。
5. const 和 static 不能同时修饰成员函数。