一.静态函数

静态函数（Static Function）是指在C++中使用static关键字声明的函数。它们与普通成员函数和全局函数不同，具有以下特点：

作用域限制：静态函数在类的作用域内，但它们不依赖于类的实例，因此可以被类的名称直接调用，而不需要创建类的对象。
无法访问非静态成员：静态函数不能访问类的非静态成员变量或非静态成员函数，因为它们不与类的任何特定实例相关联。只能访问类的静态成员变量和其他静态函数。
与类相关：静态函数通常与类的实现相关，而不是与类的实例状态相关。它们可以用于执行与类的数据或功能相关的操作，而不需要访问特定的对象。
不需要实例化：与普通成员函数不同，静态函数可以直接通过类的名称来调用，而无需创建类的对象实例。
用途：静态函数通常用于实现与类相关的全局功能或工具函数，而不需要类的实例。它们也可以用于管理类的静态成员变量。

下面是一个简单示例，演示了如何声明和使用静态函数：

class MyClass {
public:
    static int staticFunction(int x, int y) {
        return x + y;
    }

    static int staticVariable;
};

int MyClass::staticVariable = 42; // 静态成员变量的定义和初始化

int main() {
    int result = MyClass::staticFunction(10, 20); // 直接通过类名调用静态函数
    std::cout << "Result: " << result << std::endl;

    std::cout << "Static Variable: " << MyClass::staticVariable << std::endl;

    return 0;
}

在上面的示例中，staticFunction是一个静态函数，可以通过MyClass::staticFunction的方式调用。同时，MyClass::staticVariable是一个静态成员变量，可以通过类名访问。这两者都不需要创建MyClass的对象实例。

二.static 关键字

在C++中，关键字 static 有多种用法，它可以用于不同的上下文中，具体取决于它所修饰的对象或变量。以下是一些常见的用法：

1.静态变量 (Static Variables): 在函数内部或全局作用域中声明的静态变量在程序的整个生命周期内保持其值。与普通局部变量不同，静态变量只会在首次进入其作用域时初始化一次。例如：

#include <iostream>

void foo() {
    static int count = 0; // 静态局部变量
    count++;
    std::cout << "Count: " << count << std::endl;
}

int main() {
    foo();
    foo();
    return 0;
}

2. 静态函数 (Static Functions): 静态函数是与类相关联而不是与类的实例相关联的成员函数。它们可以通过类名直接调用，而不需要创建类的对象。通常用于实用函数或不需要访问实例数据的函数。（实例对象也可以访问）

class MyClass {
public:
    static void staticFunction() {
        std::cout << "This is a static function." << std::endl;
    }
};

int main() {
    MyClass::staticFunction(); // 直接调用静态函数
    return 0;
}

3.静态类成员 (Static Class Members): 类中的静态成员是类的所有实例共享的成员，而不是每个实例拥有自己的副本。它们可以用于在多个实例之间共享数据或功能。

class MyClass {
public:
    static int staticVar; // 静态成员变量
};

int MyClass::staticVar = 42; // 初始化静态成员变量

int main() {
    MyClass obj1;
    MyClass obj2;

    obj1.staticVar = 10;
    std::cout << "obj1.staticVar: " << obj1.staticVar << std::endl;
    std::cout << "obj2.staticVar: " << obj2.staticVar << std::endl;

    return 0;
}

4.静态类 (Static Classes): 在C++中，可以将类声明为静态类，这意味着无法创建该类的实例，通常用于包含静态成员和静态函数的类。

class StaticClass {
public:
    static void staticFunction() {
        std::cout << "This is a static function in a static class." << std::endl;
    }
};

int main() {
    // 无法创建StaticClass的实例
    // StaticClass myObj; // 这将导致编译错误

    StaticClass::staticFunction(); // 直接调用静态函数
    return 0;
}

三.const 关键字

在C++中，const 是一个关键字，用于声明常量或表明某些东西是不可修改的。const 可以应用于不同的上下文，包括变量、函数参数和成员函数。以下是关于C++中的 const 的一些常见用法：

1.常量变量 (Constant Variables): 使用 const 关键字声明的变量是常量，它们的值在初始化后不能被修改。

const int myConstVar = 10;
// myConstVar = 20; // 这将导致编译错误，常量不能被修改

2.指向常量的指针 (Pointers to Constants): 使用 const 修饰指针，可以创建指向常量的指针，这意味着通过该指针不能修改指向的值。

const int myConstVar = 10;
const int* ptr = &myConstVar;
// *ptr = 20; // 这将导致编译错误，通过 ptr 不能修改 myConstVar 的值

3.常量指针 (Constant Pointers): 使用 const 修饰指针变量本身，可以创建一个常量指针，这意味着该指针不能指向其他变量，但可以用来修改指向的值。

int myVar = 10;
int* const ptr = &myVar;
*ptr = 20; // 有效，可以修改 myVar 的值
// ptr = nullptr; // 这将导致编译错误，不能修改 ptr 指向其他地址

4.常量成员函数 (Constant Member Functions): 在类中的成员函数前面加上 const 关键字，表示该函数不会修改对象的状态。它可以被用于常量对象上。

class MyClass {
public:
    void normalFunction() {
        // 可以修改对象的成员变量
    }

    void constFunction() const {
        // 不能修改对象的成员变量
    }
};

const MyClass constObj;
constObj.normalFunction(); // 这将导致编译错误
constObj.constFunction();  // 可以调用 const 成员函数

5.常引用 (Constant References): 使用 const 修饰引用，可以创建常量引用，这意味着通过该引用不能修改引用的值。

int myVar = 10;
const int& myConstRef = myVar;
// myConstRef = 20; // 这将导致编译错误，不能通过 myConstRef 修改 myVar 的值

6.常量函数参数 (Constant Function Parameters): 在函数参数中使用 const 关键字，表示该参数是常量，函数内部不能修改它的值。

void myFunction(const int x) {
    // x = 20; // 这将导致编译错误，x 是常量
}

四.static 和 const 的区别

在C++中，static 和 const 都是关键字，但它们用于不同的目的，具有不同的作用。以下是它们之间的主要区别：

作用领域：
- static 通常用于控制存储持续性（存储期）和作用域。它可以用于变量、函数、类成员、类本身等，用于控制它们的生命周期和可见性。
- const 用于声明常量或表示某些东西是不可修改的。它可以应用于变量、函数参数、成员函数等，用于指定不可更改的值或状态。
存储期：
- static 与存储期相关，它可以使变量成为静态存储期（在程序生命周期内存在）或限制变量的作用域（在某个范围内可见）。
- const 与存储期无关，它只是指示一个值是常量，无论其存储期如何。
可修改性：
- static 关键字本身不表示可修改性。它主要用于控制变量的生命周期和作用域，而不是变量本身的可修改性。
- const 关键字用于表示值是不可修改的。如果你将其应用于变量，那么该变量的值不能被更改。如果你将其应用于函数参数，那么函数不能修改参数的值。
示例：

使用 static 的示例：

static int counter = 0; // 静态变量，存储期在整个程序生命周期内
void foo() {
    static int localVar = 0; // 静态局部变量，作用域在函数内，但存储期在整个程序生命周期内
}

使用 const 的示例：
```
const int myConstVar = 10; // 常量变量，值不能被修改
void myFunction(const int x) { // 常量函数参数，参数值不能被修改
    // x = 20; // 这将导致编译错误，x 是常量
}
```
总结来说，static 用于控制存储期和作用域，而 const 用于表示不可修改的值或状态。它们在C++中有不同的用途，但可以一起使用，例如声明静态常量或静态成员函数，以实现各种编程需求。

静态函数（static）-＞ static 与 const

一.静态函数

二.static 关键字

三.const 关键字

四.static 和 const 的区别

猜你喜欢