c++的static关键字用法

c++的static关键字用法
C++中的`static`关键字有多种用法，在不同的场景下都有着不同的含义和作用。

本文将详细介绍C++中`static`关键字的用法及其相关特性，希望能对读者更好地理解和运用这个关键字。

一、`static`关键字概述
`static`是C++中的一个关键字，它常用于指定函数、变量、类成员等的作用域和生命周期。

它的主要作用如下：
1. 限定变量的作用域。

使用`static`关键字声明的变量具有静态的生存期和块作用域，即在整个程序运行期间都存在，并且只能在声明变量的源文件中访问。

2. 限定函数的作用域。

使用`static`关键字声明的函数具有静态的作用域，即只能在声明它的源文件中调用。

3. 限定类成员的作用域。

使用`static`关键字声明的类成员为静态成员，它不属于类的任何一个对象，而是属于整个类，可以通过类名或类对象来访问。

4. 防止符号重定义。

当在多个源文件中定义同名的全局变量或函数时，使用
`static`关键字可以防止它们之间的符号重定义错误。

二、静态变量
1. 全局静态变量
使用`static`关键字声明的全局变量具有静态生存期和文件作用域，即它在程序运行期间一直存在，而且只能在声明它的源文件中访问。

例如：
```cpp
//file1.cpp
#include <iostream>
static int count = 10; //声明全局静态变量count
void func() {
static int i = 5; //局部静态变量i，生命周期为整个程序运行期间
std::cout << "i is " << i ;
std::cout << " and count is " << count << std::endl;
i++;
count++;
}
```
在另一个源文件中引用这个全局静态变量，编译器会报错：
```cpp
//file2.cpp
#include <iostream>
extern int count; //声明全局变量count
void func2() {
std::cout << "count is " << count << std::endl;
}
```
编译器会报错：undefined reference to `count'。

这是因为全局静态变量只能在声明它的源文件中访问，其他文件中的代码无法访问它。

如果把全局变量count声明为`extern`变量，其他源文件就可以引用它了：
```cpp
//file1.cpp
#include <iostream>
static int count = 10; //声明全局静态变量count
void func() {
static int i = 5; //局部静态变量i，生命周期为整个程序运行期间
std::cout << "i is " << i ;
std::cout << " and count is " << count << std::endl;
i++;
count++;
}
```
```cpp
//file2.cpp
#include <iostream>
extern int count; //声明全局变量count
void func2() {
std::cout << "count is " << count << std::endl;
}
```
这时编译器不会报错了。

全局静态变量的作用域和生命周期使得它们通常被用来保存
应用程序的全局状态，例如计数器、标志位等。

2. 局部静态变量
在函数中声明的静态变量被称为局部静态变量，它们的生命周期为整个程序运行期间，但作用域只在声明它们的块中。

例如：
```cpp
#include <iostream>
void func() {
static int i = 5; //局部静态变量i，生命周期为整个程序运行期间
i++;
std::cout << "i is " << i << std::endl;
}
for (int i = 0; i < 5; i++) {
func();
}
return 0;
}
```
输出为：
```
i is 6
i is 7
i is 8
i is 9
i is 10
```
可以看到，局部静态变量的生命周期为整个程序运行期间，每次调用函数都会继续使用上次的值。

通常用局部静态变量来在函数调用之间保存状态。

三、静态函数
使用`static`关键字声明的函数为静态函数，它们具有静态作用域，只能在声明它们的源文件中调用。

例如：
```cpp
//file1.cpp
#include <iostream>
static void func() { //声明静态函数func
std::cout << "This is a static function!" << std::endl;
}
void foo() {
func(); //可以在同一源文件中的其他函数中调用静态函数
}
```
```cpp
//file2.cpp
#include <iostream>
static void func() { //另一个源文件中也可以定义同名的静态函数
std::cout << "Another static function!" << std::endl;
}
void bar() {
func(); //无法在不同源文件中调用静态函数，编译器报错：undefined reference to 'func()'
}
```
上述代码中，在`file1.cpp`文件中定义了一个静态函数`func`，在同一文件中的函
数`foo`中可以调用它，而在`file2.cpp`文件中的函数`bar`中则无法调用它，编译器会
报undefined reference to 'func()'的错误。

静态函数的目的通常是将其作为辅助函数，以便在文件内使用但不暴露给其他文件或类。

四、静态类成员
使用`static`关键字声明的类成员为静态成员，它们不属于类的任何一个对象，而是属于整个类，可以通过类名或类对象来访问。

静态成员不与任何类对象相关联，因此它们可以在没有任何类对象的情况下访问和修改。

例如：
```cpp
#include <iostream>
class MyClass {
public:
static int count; //声明静态成员变量count
MyClass() {
count++;
}
static void printCount() { //声明静态成员函数printCount
std::cout << "count is " << count << std::endl;
}
};
int MyClass::count = 0; //在类外定义静态成员变量count
MyClass obj1, obj2;
MyClass::printCount(); //通过类名调用静态成员函数printCount
obj1.printCount(); //也可以通过类对象调用静态成员函数printCount
std::cout << "obj1.count is " << obj1.count << std::endl; //通过类对象访问静态成员变量count
std::cout << "obj2.count is " << obj2.count << std::endl;
return 0;
}
```
输出为：
```
count is 2
count is 2
obj1.count is 2
obj2.count is 2
```
可以看到，静态成员变量`count`属于整个类而不是类的任何一个对象，因此它的值在每个类对象中都是相同的。

静态成员函数属于类而不属于类的任何一个对象，因此它们不可以访问非静态成员。

静态成员变量和函数通常用于实现通用类成员，例如统计类的对象数目或为类提供默认值。

五、防止符号重定义
当在多个源文件中定义同名的全局变量或函数时，使用`static`关键字可以防止它们之间的符号重定义错误。

例如：
```cpp
//file1.cpp
static int count = 10; //定义静态全局变量count
return 0;
}
```
```cpp
//file2.cpp
static int count = 10; //另一个文件中也定义了同名的静态全局变量count
return 0;
}
```
编译器会在链接时报告重复定义的错误：multiple definition of `count'。

如果不使用`static`关键字，这些全局变量会有共同的名称，从而导致符号冲突和程序错误。

六、总结
本文介绍了C++中`static`关键字的几种用法，包括静态变量、静态函数和静态类成员。

总结一下：
- 静态变量具有静态生存期和块作用域，全局静态变量只能在声明它们的源文件中访问，局部静态变量只能在声明它们的块中访问；
- 静态函数具有静态作用域，只能在声明它们的源文件中调用；
- 静态类成员不属于类的任何一个对象，而是属于整个类，可以通过类名或类对象来访问；
- 使用`static`关键字可以防止符号重定义错误。

掌握`static`关键字的用法，对于理解C++程序的作用域和生命周期有很大帮助，也可以提高程序代码的可维护性和可重用性。