C++ static关键字

AoDeLuo

已于 2023-02-08 11:00:05 修改

阅读量100

点赞数

分类专栏： c++ 文章标签： c++

于 2022-12-05 11:36:24 首次发布

本文链接：https://blog.csdn.net/qq_30150579/article/details/128183593

版权

c++ 专栏收录该内容

10 篇文章 0 订阅

订阅专栏

文章目录

static应用场合分类
一. 静态全局变量
- 源代码
二. 静态局部变量
- 源代码
三. 静态函数
四. 静态数据成员
五. 静态成员函数
- 源代码
参考

static应用场合分类

面向过程
1. 静态全局变量
2. 静态局部变量
3. 静态函数
面向对象
1. 静态成员数据
2. 静态成员函数

一. 静态全局变量

在全局变量前，加上static关键字，该变量就被定义为了一个静态全局变量

静态全局变量具有以下特点：

静态全局变量在声明它的整个文件都是可见的，而在文件之外时是不可见的。

正因为上面的特点，静态全局变量与普通全局变量的区别在于：静态全局变量不能被其他文件所使用；其他文件中可以定义相同名字的变量，不会产生冲突（这是因为即便是其他文件使用了已经定义的静态全局变量，只是在自己空间内新开辟了一个新的内存区域，已经不与原来的静态全局变量共享内存，改变其值彼此不受影响），如下面的简单例子：
在这里插入图片描述

static_head.cpp文件的fun()函数直接打印静态全局变量str的值
test1.cpp文件的 fun1()函数调用static_head.cpp文件中的fun()函数，然后修改字符串str的值，然后打印str的值
test2.cpp文件的 fun2()函数直接打印字符串str的值
例子中，主程序main函数调用test1.cpp文件和test2.cpp文件中的fun1()和fun2()函数

可以看到，test1中对str进行重新赋值后，test2输出的str还是123456，这是因为即便是其他文件使用了已经定义的静态全局变量，只是在自己空间内新开辟了一个新的内存区域，已经不与原来的静态全局变量共享内存，改变其值彼此不受影响

源代码

/***********test1.h**********/
#ifndef TEST1_H
#define TEST1_H

#endif // TEST1_H

void fun1();

/***********test1.cpp**********/
#include "test1.h"
#include "static_head.h"

void fun1() {
     fun();

     str = "abcde";
     cout<< "test1中修改str值后输出的str: " << str <<endl;
}

/***********test2.h**********/
#ifndef TEST2_H
#define TEST2_H

#endif // TEST2_H

void fun2();

/***********test2.cpp**********/
#include "test2.h"
#include "static_head.h"

void fun2() {
     cout<< "test2中输出的str的值: " << str <<endl;
}

/***********static_head.h**********/
#ifndef STATIC_HEAD_H
#define STATIC_HEAD_H

#endif // STATIC_HEAD_H

#include<iostream>
#include<string>
using namespace std;
static string str = "12345";

void fun();

/***********static_head.cpp**********/
#include "static_head.h"


void fun() {
     cout<< "static_haed.cpp中的fun()输出str: " << str <<endl;
}

/*main.cpp*/
#include "test1.h"
#include "test2.h"

int main()
{
    fun1();
    fun2();

    return 0;
}

二. 静态局部变量

在局部变量前，加上关键字static，该变量就被定义为了静态局部变量。

静态局部变量具有以下特点：

该变量在全局区分配内存；静态局部变量在程序执行到该对象的声明处首次初始化，即便以后的函数调用也不再进行初始化；它将始终驻留在全局数据区，直到程序运行结束。但其作用域是局部作用域，当定义它的函数或语句块结束时，其作用域随之结束。

另外，static局部变量具有记忆性，与生存周期的全局性，见如下例子：

在这里插入图片描述

例子中，主程序main函数调用static_localVar()函数，该函数内部有一个静态局部变量a的初始化，随后打印a的值并+1
在main函数中，不止一次的调用static_localVal()函数，但是由于静态局部变量只在程序执行到该对象的声明处首次初始化，即便以后的函数调用也不再进行初始化，所以只有第一次调用static_localVar()时，a才等于0

源代码

#include<iostream>
using namespace std;

int* static_localVar()
{
    static int a = 0; //运行到此时初始化，下次运行是不需要再初始化，因为一直保存在全局区
    cout << "a=" << a << endl;
    ++a;
    return &a;
}

int main()
{
    static_localVar();
    static_localVar();
    static_localVar();
    //cout << a << endl;  //error,因为已经离开a的作用域
    int *a = static_localVar();
    cout << *a << endl;  //虽然已经离开a的作用域，但是把a的指针赋值给另外的对象，通过这个对象依然可以使用a

    return 0;
}

三. 静态函数

在函数的返回类型上加上static关键字，函数就成为了静态函数。静态函数与普通函数不同，它只能在声明它的文件中可见，不能被其他文件所使用。

定义静态函数的好处在于：静态函数不能被其他文件使用；其他文件中可以定义相同名字的函数，不会发生冲突。

四. 静态数据成员

在类内数据成员的声明前加上关键字static，该数据成员就是类内的静态数据成员。

静态数据成员具有以下特点：

1、相对于非静态数据成员（每个实例都会有一个数据成员的拷贝），静态数据成员在程序中有且仅有一个拷贝，由该类型的实例对象所共享。也就是说，静态数据成员是该类的所有对象共有的。

2、因为静态数据成员在全局区，属于类所有对象共享，所以，它不属于特定的实例，在没有产生类实例的作用域也可见，即，在没有产生类实例时，我们就可以操作它。

3、与全局变量相比，静态数据成员具有两个优势：

第一，静态数据成员没有进入程序的全局命名空间，所以不存在与其他名字冲突的可能性
另外一点，静态数据成员可以是private成员，而全局变量不行，从这一方面说，静态数据成员维护了类的封装性。

4、静态数据成员主要用于各个对象具有相同的某项属性的时候，比如说一个存款类，每个实例的利息都是相同的。将其定义为静态数据成员有两个好处：第一内存中只有一份拷贝，节省空间；第二，一旦利息改变，只需要改变静态数据成员即可。

五. 静态成员函数

1、与静态数据成员一样，我们可以为类创建静态成员函数，它为类的全部实例服务。

2、静态成员函数的this指针是缺省的，这很好理解，因为其并不属于某一个对象；而普通成员函数一般都隐藏了一个指向自身的this指针。

3、因为静态成员函数的this指针是缺省的，所以其没办法访问类的非静态成员函数（联系this指针的作用），只能访问类的静态数据成员和静态成员函数。

4、因为静态成员函数的this指针是缺省的，所以不能将其定义为虚函数，因为虚函数表需要通过this指针访问。同理静态成员变量也无法使用虚函数。

关于静态成员函数与静态数据成员的理解，可以参见C++中一个经典的单例模式实现代码：

源代码

/* lazy Singleton */

class Singleton
{
public:
    /* 提供static的Instance()方法，作为全局访问点；
     * 如果有现成的实例，则直接返回；
     *如果没有，则将新生成的实例保存到私有的static属性中
    */
     /* Instance()返回的是实例的引用而不是指针，如果是指针有被外部调用者delete的风险。
      * 直到Instance()方法被访问，才会生成实例，这种特性被称为延迟初始化（Lazy Singleton）
     */
    /* 但是这种方式不是线程安全的，比如有线程A和B
     * 都通过了instance==nullptr判断，则两个线程会分配创建新实例，这样单例模式就被打破了。
    */
    static Singleton& Instance() {
        if (instance == nullptr)
            instance = new Singleton;
        return *instance;
    }

private:
    //构造函数与拷贝构造函数，拷贝赋值运算符都声明为私有方法，这样杜绝从外部生成新的实例
    Singleton();
    ~Singleton();
    Singleton(const Singleton&);
    Singleton& operator=(const Singleton&);

private:
    static Singleton* instance;
};