C++中static和const的作用和用法

• static：
  • 静态变量（static variable）：在函数内部声明的静态变量在程序执行期间保持其值，而不会在函数调用结束后销毁。静态变量只初始化一次，然后可以在后续函数调用中使用其最新值。

void foo() {
    static int counter = 0;
    counter++;
    cout << "Counter: " << counter << endl;
}
int main() {
    foo(); // 输出：Counter: 1
    foo(); // 输出：Counter: 2
    return 0;
}

• 上述代码中，静态变量counter在每次调用foo()时保持其值，并在每次调用后递增。
  • 静态函数（static function）：在类中声明的静态函数与类的对象实例无关，可以直接通过类名访问。静态函数不能访问非静态成员变量，因为它们没有this指针。

class MathUtils {
public:
    static int add(int a, int b) {
        return a + b;
    }
};
int main() {
    int result = MathUtils::add(3, 5);
    cout << "Result: " << result << endl; // 输出：Result: 8
    return 0;
}

• 在上述代码中，add()函数是一个静态函数，我们可以直接使用MathUtils::add()进行调用。

• const：

  • 常量变量（const variable）：用const修饰的变量表示其值在程序执行期间是不可修改的。
    常量必须在声明时进行初始化，并且不能在后续代码中修改其值。

int main() {
    const int MAX_VALUE = 100;
    // MAX_VALUE = 200;  // 错误，不能修改常量的值
    cout << "Max value: " << MAX_VALUE << endl; // 输出：Max value: 100
    return 0;
}

• 在上述代码中，MAX_VALUE被声明为常量，一旦初始化后，其值将保持不变。
  • 常量引用（const reference）：用const修饰的引用参数表示函数不会修改传入的参数值。

void printMessage(const string& message) {
    cout << "Message: " << message << endl;
}
int main() {
    string greeting = "Hello!";
    printMessage(greeting); // 输出：Message: Hello!
    return 0;
}

在上述代码中，printMessage()函数接受一个常量引用参数message，保证函数内部不会修改greeting的值。

总结：

• static用于创建静态变量和静态函数，静态变量在程序执行期间保持其值，静态函数与类的对象实例无关。
• const用于创建常量变量和常量引用，常量变量的值在初始化后不可修改，常量引用表示函数不会修改传入的参数值。

static和const在类中的应用：

const:

在C++中，const成员变量的初始化需要在类的构造函数初始化列表（constructor initialization list）中进行，而不能在构造函数的函数体内进行赋值操作。

以下是一个示例代码，演示了如何初始化const成员变量：

class MyClass {
private:
    const int myConstant;
public:
    // 构造函数
    MyClass(int value) : myConstant(value) {
        // 在构造函数的初始化列表中对const成员变量进行初始化
        // 可以使用参数或者其他表达式来赋值给const成员变量
        // 构造函数的函数体内不能对const成员变量赋值
    }
    void printConstant() {
        cout << "Constant value: " << myConstant << endl;
    }
};
int main() {
    MyClass obj(42);
    obj.printConstant(); // 输出：Constant value: 42
    return 0;
}

在上述代码中，MyClass类有一个私有的const成员变量myConstant。构造函数MyClass(int value)中，在构造函数的初始化列表中使用参数value来初始化myConstant。

注意，在构造函数的函数体内不能对const成员变量进行赋值操作，因此必须使用构造函数的初始化列表来进行初始化。

通过这种方式，可以在创建对象时将值传递给const成员变量，并在对象的生命周期内保持其不变性。

static：

在C++中，静态成员变量（static member variables）需要在类外进行初始化。初始化可以在类定义的外部进行，通常在类的实现文件（.cpp）中进行。这样做是因为静态成员变量属于整个类而不是特定的对象实例，因此需要在类的定义之外进行初始化。

以下是一个示例代码，演示了如何初始化静态成员变量：

class MyClass {
public:
    static int staticVariable;
};
// 静态成员变量的初始化
int MyClass::staticVariable = 10;
int main() {
    cout << "Static variable: " << MyClass::staticVariable << endl; // 输出：Static variable: 10
    return 0;
}

在上述代码中，MyClass类有一个公有的静态成员变量staticVariable。在类的定义外部，通过MyClass::staticVariable = 10;的方式进行初始化。这样，所有属于MyClass类的对象实例都共享同一个静态成员变量。

可以通过类名和作用域解析运算符::来访问静态成员变量，如MyClass::staticVariable。

需要注意的是，静态成员变量的初始化只能在类外进行一次。如果在类的多个源文件中都包含了该静态成员变量的初始化语句，将导致重复定义错误。通常，将静态成员变量的初始化放在类的实现文件中，并在头文件中声明静态成员变量的存在。

静态局部变量：

在 C++ 中，静态局部变量（static local variables）是在函数内部声明的静态变量。与函数内的普通局部变量不同，静态局部变量在函数的多次调用之间保持其值，并且仅在第一次进入声明该变量的代码行时进行初始化。

静态局部变量的初始化只发生一次，以后每次进入声明该变量的作用域时，都不会重新初始化，而是保留上一次的值。

下面是一个示例代码，演示了静态局部变量的用法：

#include <iostream>
void foo() {
    static int counter = 0;
    counter++;
    std::cout << "Counter: " << counter << std::endl;
}
int main() {
    foo(); // 输出：Counter: 1
    foo(); // 输出：Counter: 2
    foo(); // 输出：Counter: 3
    return 0;
}

在上述代码中，foo()函数内部声明了一个静态局部变量counter。在每次调用foo()时，counter的值都会递增，并在每次调用之间保留其值。这是因为静态局部变量在函数的多次调用之间保持其状态。

静态局部变量的初始化只在第一次进入声明它的代码行时进行，之后的函数调用不会再次初始化它。这就是为什么在示例代码中的后续调用中，counter的值在前一次调用的基础上递增。

请注意，静态局部变量的生命周期与程序运行期间一致，但其作用域仅限于声明它的函数内部。这意味着其他函数无法直接访问该静态局部变量。