static那些事

当与不同类型一起使用时，Static关键字具有不同的含义。我们可以使用static关键字：

静态变量： 函数中的变量，类中的变量

静态类的成员： 类对象和类中的函数

现在让我们详细看一下静态的这些用法：

静态变量

  • 函数中的静态变量

当变量声明为static时，空间将在程序的生命周期内分配。即使多次调用该函数，静态变量的空间也只分配一次，前一次调用中的变量值通过下一次函数调用传递。这对于在C / C ++或需要存储先前函数状态的任何其他应用程序非常有用。

  1. #include <iostream> 
  2. #include <string> 
  3. using namespace std; 
  5. void demo() 
  6. { 
  7.     // static variable 
  8.     static int count = 0; 
  9.     cout << count << " "; 
  11.     // value is updated and 
  12.     // will be carried to next 
  13.     // function calls 
  14.     count++; 
  15. } 
  17. int main() 
  18. { 
  19.     for (int i=0; i<5; i++)  
  20.         demo(); 
  21.     return 0; 
  22. }

输出：

  1. 0 1 2 3 4

您可以在上面的程序中看到变量count被声明为static。因此，它的值通过函数调用来传递。每次调用函数时，都不会对变量计数进行初始化。

  • 类中的静态变量

由于声明为static的变量只被初始化一次，因为它们在单独的静态存储中分配了空间，因此类中的静态变量由对象共享。对于不同的对象，不能有相同静态变量的多个副本。也是因为这个原因，静态变量不能使用构造函数初始化。

  1. #include<iostream> 
  2. using namespace std; 
  4. class Apple 
  5. { 
  6. public: 
  7.     static int i; 
  9.     Apple() 
  10.     { 
  11.         // Do nothing 
  12.     }; 
  13. }; 
  15. int main() 
  16. { 
  17. Apple obj1; 
  18. Apple obj2; 
  19. obj1.i =2; 
  20. obj2.i = 3; 
  22. // prints value of i 
  23. cout << obj1.i<<" "<<obj2.i; 
  24. }

您可以在上面的程序中看到我们已经尝试为多个对象创建静态变量i的多个副本。但这并没有发生。因此，类中的静态变量应由用户使用类外的类名和范围解析运算符显式初始化，如下所示：

  1. #include<iostream> 
  2. using namespace std; 
  4. class Apple 
  5. { 
  6. public: 
  7.     static int i; 
  9.     Apple() 
  10.     { 
  11.         // Do nothing 
  12.     }; 
  13. }; 
  15. int Apple::i = 1; 
  17. int main() 
  18. { 
  19.     Apple obj; 
  20.     // prints value of i 
  21.     cout << obj.i; 
  22. }

输出：

  1. 1

静态成员

  • 类对象为静态

就像变量一样，对象也在声明为static时具有范围，直到程序的生命周期。

考虑以下程序，其中对象是非静态的。

  1. #include<iostream> 
  2. using namespace std; 
  4. class Apple 
  5. { 
  6.     int i; 
  7.     public: 
  8.         Apple() 
  9.         { 
  10.             i = 0; 
  11.             cout << "Inside Constructor\n"; 
  12.         } 
  13.         ~Apple() 
  14.         { 
  15.             cout << "Inside Destructor\n"; 
  16.         } 
  17. }; 
  19. int main() 
  20. { 
  21.     int x = 0; 
  22.     if (x==0) 
  23.     { 
  24.         Apple obj; 
  25.     } 
  26.     cout << "End of main\n"; 
  27. }

输出：

  1. Inside Constructor
  2. Inside Destructor
  3. End of main

在上面的程序中，对象在if块内声明为非静态。因此，变量的范围仅在if块内。因此，当创建对象时，将调用构造函数，并且在if块的控制权越过析构函数的同时调用，因为对象的范围仅在声明它的if块内。如果我们将对象声明为静态，现在让我们看看输出的变化。

  1. #include<iostream> 
  2. using namespace std; 
  4. class Apple 
  5. { 
  6.     int i; 
  7.     public: 
  8.         Apple() 
  9.         { 
  10.             i = 0; 
  11.             cout << "Inside Constructor\n"; 
  12.         } 
  13.         ~Apple() 
  14.         { 
  15.             cout << "Inside Destructor\n"; 
  16.         } 
  17. }; 
  19. int main() 
  20. { 
  21.     int x = 0; 
  22.     if (x==0) 
  23.     { 
  24.         static Apple obj; 
  25.     } 
  26.     cout << "End of main\n"; 
  27. }

输出：

  1. Inside Constructor
  2. End of main
  3. Inside Destructor

您可以清楚地看到输出的变化。现在，在main结束后调用析构函数。这是因为静态对象的范围是贯穿程序的生命周期。

  • 类中的静态函数

就像类中的静态数据成员或静态变量一样，静态成员函数也不依赖于类的对象。我们被允许使用对象和'.'来调用静态成员函数。但建议使用类名和范围解析运算符调用静态成员。

允许静态成员函数仅访问静态数据成员或其他静态成员函数，它们无法访问类的非静态数据成员或成员函数。

  1. #include<iostream> 
  2. using namespace std; 
  4. class Apple 
  5. { 
  6.     public: 
  7.         // static member function 
  8.         static void printMsg() 
  9.         {
  10.             cout<<"Welcome to Apple!"; 
  11.         }
  12. }; 
  14. // main function 
  15. int main() 
  16. { 
  17.     // invoking a static member function 
  18.     Apple::printMsg(); 
  19. }

输出：

  1. Welcome to Apple!