【static】关键字静态成员：在类级别上共享数据和方法的机制

古城微笑少年丶 2024-02-18 09:45 19阅读 0赞

#### 这里写目录标题 ####

*  static
 *  类的大小
 *  四种作用域

## static ##

static成员独立于类对象存在，也就是说它不属于对象的成员，它能被全体对象所共享。  
统计·类类型对象创建的个数，用static成员来实现。  
非static成员属于类对象，每个对象都有一份拷贝。  
static成员函数没有this指针，他不能访问非static成员，也不能调用非static成员函数。

> 静态成员变量在定义性说明时不用再加static关键字。

#include<iostream>
    using namespace std;
    class CBOOK
    {
        
        public:
            CBOOK(int price , int nums)
            {
        
                this->price = price;
                this->nums = nums;
            }
          int nums;
          int price;
          static int x ; //静态成员的引用性说明
    };
     static int CBOOK::x =100; //静态成员的定义性说明，error，static关键字
    int main()
    {
        
    cout<<CBOOK::x<<endl;
        return 0;
    }

错误如下：

staticnumbers.cpp:28:19: error: ‘static’ may not be used when defining (as opposed to declaring) a static data member [-fpermissive]
     static int CBOOK::x =100;
                       ^

> 静态成员变量不能多次初始化

#include<iostream>
    using namespace std;
    class CBOOK
    {
        
        public:
            CBOOK(int price , int nums)
            {
        
                this->price = price;
                this->nums = nums;
            }
          int nums;
          int price;
          static int x = 102;
    };
     int CBOOK::x =100;  //error，多次初始化
    int main()
    {
        
    cout<<CBOOK::x<<endl;
        return 0;
    }

错误如下：

[bsk@localhost classobject]$ g++ staticnumbers.cpp 
    staticnumbers.cpp:25:22: error: ISO C++ forbids in-class initialization of non-const static member ‘CBOOK::x’
           static int x = 102;
                          ^
    staticnumbers.cpp:27:13: error: duplicate initialization of ‘CBOOK::x’
      int CBOOK::x =100;
                 ^
    staticnumbers.cpp:27:16: error: ISO C++ forbids in-class initialization of non-const static member ‘CBOOK::x’
      int CBOOK::x =100;

可以使用类初始化的对象来调用静态成员，但是一般不会这样做，因为会容易理解错误，静态成员是属于整体的而不是类对象。

#include<iostream>
    using namespace std;
    class CBOOK
    {
        
        public:
        CBOOK(){
        }//重载一下空实现，因为当构造函数有参函数出现后，会自动覆盖编译器提供的空实现，从而再想去调用空实现，就会报错。
            CBOOK(int price , int nums)
            {
        
                this->price = price;
                this->nums = nums;
            }
          int nums;
          int price;
          static int x = 102;
    };
     int CBOOK::x =100;  //error，多次初始化
    int main()
    {
        
    CBOOK c;
    cout<<CBOOK::x<<endl;
        cout<<c.x<<endl;
        return 0;
    }

> 静态成员函数

#include<iostream>
    using namespace std;
    class CBOOK
    {
        
        public:
        CBOOK(){
        }//重载一下空实现，因为当构造函数有参函数出现后，会自动覆盖编译器提供的空实现，从而再想去调用空实现，就会报错。
            CBOOK(int price , int nums)
            {
        
                this->price = price;
                this->nums = nums;
            }
    
               void function() //普通·成员函数
            {
        
                cout<<"funcyion"<<endl;
                cbookfunction();
            }
            static void  cbookfunction() //静态成员函数
            {
        
                cout<<"static cbookfuncyion"<<endl;
            }
    
          int nums;
          int price;
          static int x;
    };
     int CBOOK::x =100;  //error，多次初始化
    int main()
    {
        
    CBOOK c;
        cout<<CBOOK::x<<endl;
        cout<<c.x<<endl;
        c.function();
        return 0;
    }

> 在普通·成员函数中可以调用静态成员函数，但是在静态成员函数中不可以·调用普通成员函数，

会出现下面的错误·：

[bsk@localhost classobject]$ g++ staticnumbers.cpp 
    staticnumbers.cpp: In static member function ‘static void CBOOK::cbookfunction()’:
    staticnumbers.cpp:31:22: error: cannot call member function ‘void CBOOK::function()’ without object
                 function();

> 静态成员变量在静态成员函数或者非静态成员函数都可以访问

#include<iostream>
    using namespace std;
    class CBOOK
    {
        
        public:
            CBOOK(){
        }
            CBOOK(int price , int nums)
            {
        
                this->price = price;
                this->nums = nums;
            }
    
       
            void function()
            {
        
                cout<<"funcyion"<<endl;
                cbookfunction();
        		cout<<x<<endl;
     
            }
            static void  cbookfunction()
            {
        
      //          function();
                cout<<"static cbookfuncyion"<<endl;
                cout<< x<<endl;
                
            }
          int nums;
          int price;
          static int x ;
    };
     int CBOOK::x =100;
    //int Cbook::price = 410;
    int main()
    {
        
       CBOOK book(12,123);
    
        CBOOK c;
    book.function();    
    return 0;
    }

> 在静态成员函数中不可以访问·非静态成员变量·

#include<iostream>
    using namespace std;
    class CBOOK
    {
        
        public:
            CBOOK(){
        }
            CBOOK(int price , int nums)
            {
        
                this->price = price;
                this->nums = nums;
            }
    
       
            void function()
            {
        
                cout<<"funcyion"<<endl;
                cbookfunction();
        		cout<<x<<endl;
     			cout<<nums<<endl;
            }
            static void  cbookfunction()
            {
        
      //          function();
                cout<<"static cbookfuncyion"<<endl;
                cout<< x<<endl;
                cout<<nums<<endl;//error 不可访问
            }
          int nums;
          int price;
          static int x ;
    };
     int CBOOK::x =100;
    //int Cbook::price = 410;
    int main()
    {
        
       CBOOK book(12,123);
    
        CBOOK c;
    book.function();    
    return 0;
    }

> static用法总结

01.用于函数内部修饰变量，即函数内的静态变最。这种变量的生存期长于该函数，使得函数具有一定的“状态”。使用静态变量的函数一般是不可重入的，也不是线程安全的，比如strtok(3).  
02.用在文件级别(函数体之外)，修饰变量或函数，表示该变量或函数只在本文件可见，其他文件看不到也访问不到该变量或函数。专业的说法叫“具有internal inkage”(简言之:不暴露给别的translation unit)  
03.C语言的这两种用法很明确，一般也不容易混淆

## 类的大小 ##

1.  类的大小遵循结构体对齐原则
2.  类的大小与数据成员有关，与成员函数无关
3.  类的大小与静态成员函数无关
4.  虚函数对类的大小有影响（多虚表指针）
5.  虚继承对类的大小有影响

## 四种作用域 ##

> 栈对象

隐含用构造函数(程序中没有显示调用)

> 堆对象

隐含调用构造函数(程序中没有显示调用)

> 全局对象、静态全局对象

全局对象的构造 先于main函数  
已初始化的全局变量或静态全局对象存储于.data段中。  
未初始化的全局变量或静态全局对象存储于:bss段中

> 静态局部对象

已初始化的静态局部变量存储于.data段中，  
未初始化的静态局部变量存储于.bss段中