c/c++中static的用法

转载于https://blog.csdn.net/chenyijun/article/details/81938287

---

在C语言中

static作用：“改变生命周期” 或者 “改变作用域”。 有以下特性：

1.静态局部变量

• 用于函数体内部修饰变量，这种变量的生存期一直到程序关闭。
• 作用域：函数体内部
• 生存期：整个程序运行期间

int foo()
{
    static int si = 1; 
    int ci = 1; 
    si += 1;
    printf("foo  :&si = %p\t si = %d\t\t &ci = %p\t ci = %d\n", &si, si, &ci, ci);
    return si;
}

- 静态局部变量的特点：

（1）该变量在全局数据区分配内存(局部变量在栈区分配内存);
（2）静态局部变量在程序执行到该对象的声明处时被首次初始化，即以后的函数调用不再进行初始化(局部变量每次函数调用都会被初始化);
（3）静态局部变量一般在声明处初始化，如果没有显式初始化，会被程序自动初始化为0(局部变量不会被初始化);
（4）它始终驻留在全局数据区，直到程序运行结束。但其作用域为局部作用域，也就是不能在函数体外面使用它(局部变量在栈区，在函数结束后立即释放内存);

2.静态全局变量

• 定义在函数体外，用于修饰全局变量，表示该变量只在本文件可见。
• 作用域：该文件内部
• 生存期：整个程序运行期间

static int gsi = 1;
int gi = 1; 

int gfoo()
{
    gsi += 1;
    gi += 1;
    printf("gfoo :&gsi= %p\t gsi = %d\t &gi= %p\t gi = %d\n", &gsi, gsi, &gi, gi);
    return gsi;
}

- 静态全局变量的特点：

（1）静态全局变量不能被其它文件所用(全局变量可以);
（2）其它文件中可以定义相同名字的变量，不会发生冲突(自然了，因为static隔离了文件，其它文件使用相同的名字的变量，也跟它没关系了);

3.静态函数

• 准确的说，静态函数跟静态全局变量的作用类似，即静态函数不能被其它文件所用。其它文件中的可以定义相同的名字的函数，不会发生冲突
• 作用域：该文件内部
• 生存期：整个程序运行期间

- 静态全局变量的特点：

（1）静态函数不能被其它文件所用;
（2）其它文件中可以定义相同名字的函数，不会发生冲突;

在C++中

在C++中的 static 关键字有二种用途：当然以上的几种，也可以用在c++中。还有额外的两种用法：

1、静态数据成员

• 用于修饰 class 的数据成员，即所谓“静态成员”。这种数据成员的生存期大于 class 的对象（实体 instance）。静态数据成员是每个 class 有一份，普通数据成员是每个 instance 有一份，因此静态数据成员也叫做类变量，而普通数据成员也叫做实例变量。

2、静态成员函数

• 在这里插入代码片用于修饰 class 的成员函数。静态函数属于类的，不属于某一个具体的对象。访问方式，可以通过对像调用，也可以用类名::函数名进行访问。

#include <iostream>
 
using namespace std;
 
class CRectangle{
public:
    CRectangle(int w, int h)
    {
        this->m_nWidth = w;
        this->m_nHeght = h;
        m_sSum += (this->m_nWidth * this->m_nHeght);
        m_nSum += (this->m_nWidth * this->m_nHeght);
    }
 
    void GetSum()
    {
        cout << "m_sSum = " << m_sSum << endl;
        cout << "m_nSum = " << m_nSum << endl;
    }
 
    static void StaticGetSum()
    {
        cout << "m_sSum = " << m_sSum << endl;
        //cout << "m_nSum = " << m_nSum << endl;
		//error: invalid use of member 'm_nSum' in static member function
    }
 
private:
    int m_nWidth;
    int m_nHeght;
    int m_nSum;
    static int m_sSum;
};
 
int CRectangle::m_sSum = 0;//初始化
 
int main()
{
    cout << "sizeof(CRectangle) = " << sizeof(CRectangle) << endl;
    CRectangle *rect1 = new CRectangle(3, 4);
    rect1->GetSum();
    rect1->StaticGetSum();
    cout << "sizeof(rect1) = " << sizeof(*rect1) << endl;
 
    CRectangle *rect2 = new CRectangle(6, 9);
    rect2->GetSum();
    rect2->StaticGetSum();//通过对像访问
    cout << "sizeof(rect2) = " << sizeof(*rect2) << endl;
 
    //CRectangle::GetSum();
	//error: call to non-static member function without an object argument
    CRectangle::StaticGetSum();//通过类名访问
 
    return 0;
}

• 由结果可知：sizeof(CRectangle) = 12 bytes，就是说 static 并不占用CRectangle的内存空间。Static分配再全局数据区(静态区)
• 再看看GetSum()，第一次m_sSum 12=34，第二次m_sSum 66=12+96。由此可得，static只会被初始化一次，于实例无关。

结论

• 对于非静态数据成员，每个类对象(实例)都有自己的拷贝。而静态数据成员被当作是类的成员，由该类型的所有对象共享访问,对该类的多个对象来说，静态数据成员只分配一次内存。
• 静态数据成员存储在全局数据区。静态数据成员定义时要分配空间，所以不能在类声明中定义。
• 也就是说，你每new一个CRectangle，并不会为static int s_sSum的构建一份内存拷贝，它是不管你new了多少CRectangle的实例，因为它只与类CRectangle挂钩，而跟你每一个CRectangle的对象没关系。

那么静态成员函数有特点呢？

• 1.静态成员之间可以相互访问，包括静态成员函数访问静态数据成员和访问静态成员函数;
• 2.非静态成员函数可以任意地访问静态成员函数和静态数据成员;
• 3.静态成员函数不能访问非静态成员函数和非静态数据成员;
• 4.调用静态成员函数，可以用成员访问操作符(.)和(->)为一个类的对象或指向类对象的指针调用静态成员函数,也可以用类名::函数名调用(因为他本来就是属于类的，用类名调用很正常)

• 前三点其实是一点：静态成员函数不能访问非静态(包括成员函数和数据成员)，但是非静态可以访问静态

• 因为静态是属于类的，它是不知道你创建了10个还是100个对象，所以它对你对象的函数或者数据是一无所知的，所以它没办法调用，而反过来，你创建的对象是对类一清二楚的(不然你怎么从它那里实例化呢)，所以你是可以调用类函数和类成员的，就像不管GetSum是不是static，都可以调用static的s_Ssum一样。