C++ -- 学习系列 static 关键字的使用

已于 2023-09-14 17:13:47 修改
阅读量310 收藏
点赞数
文章标签： c++ 学习 开发语言
于 2023-09-10 15:37:18 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33775774/article/details/132789878
版权

static 是 C++ 中常用的关键字，被 static 修饰的变量只会在 静态存储区（常量数据也存放在这里） 被分配一次内存，生命周期与整个程序一样，随着程序的消亡而消亡。

一  static 有以下几种用法：

1. 在文件中定义的 静态全局变量

2. 在函数中定义的静态变量

3. 类的静态成员变量

4. 静态类对象

5. 类的静态方法

1. 在文件中定义的 静态全局变量

// main.cpp
#include<iostream>

int  xxx = 66; 

static int yyy = 888;

int main()
{
   std::cout << xxx << std::endl;
   std::cout << xxx << std::endl;
   
   return ;
}
  • 全局变量特点：

全局变量默认是有外部链接性的，作用域是整个工程，在一个文件内定义的全局变量，在另一个文件中，通过 extern 全局变量名的声明，就可以使用全局变量。

  • 静态全局变量特点：

全局静态变量是显式用 static 修饰的全局变量，作用域是声明此变量所在的文件，其他的文件即使用 extern 声明也不能使用。

2. 在函数中定义的静态局部变量

在函数中定义的静态变量仅仅初始化一次，且变量会存储到静态存储区，因此即便离开函数作用域也不会消失。

// c.h
#include<iostream>
#include<string>

class C
{
public:
    C(std::string n):name(n)
    {
        std::cout << "constructor C " << std::endl;
    }
    ~C(){
        std::cout << "destructor C " << std::endl;
    }

    std::string  getName()
    {
        return this->name;
    }

private:
    std::string name;
};


// main.cpp

#include<iostream>
#include"c.h"

void  testStatic()
{
   static  int  count = 0;  // 只会被初始化一次
   cout << "count: " << count++ << endl; // 每次调用该函数都会将上次存储的值打印出来
}

C& getTestStaticC()
{
    static C c("I'm static object."); // 只初始化一次，生命周期与程序等长

    return c;
}


int main()
{

    testStatic();
    testStatic();
    testStatic();

    C& cc1 = getTestStaticC(); // 因为定义的静态变量存储在静态存储区，不是在栈上，因此离开函数作用域以后，对静态的引用仍然是可以访问的
    C& cc2 = getTestStaticC(); // 因为定义的静态变量存储在静态存储区，不是在栈上，因此离开函数作用域以后，对静态的引用仍然是可以访问的

    std::cout << "cc1: " << cc1.getName() << std::endl;
    std::cout << "cc2: " << cc2.getName() << std::endl;
    C  cc3("666888");

    return 0;
}

输出：

3. 类的静态成员变量

类的静态成员变量属于类的所有对象，其存储在静态存储区，只有一个存储空间；而其他的非静态变量属于每个对象，在每个对象中都有其副本。

静态成员变量不在构造函数中初始化，因此静态成员变量不依赖于对象。

静态成员变量必须显示的初始化，一般情况下，我们都在类的外部对静态成员变量初始化，若是静态成员变量未被初始化，编译链接时，会报错。

// c.h
#include<iostream>
#include<string>

class C
{
public:
    C(std::string n):name(n)
    {
        std::cout << "constructor C name: " << this->name << std::endl;
    }
    ~C(){
        std::cout << "destructor C name: " << this->name << std::endl;
    }

    std::string  getName()
    {
        return this->name;
    }


private:
public:
    std::string name;
    static int height;
};


// c.cpp
#include "c.h"

int C::height = 66; // 静态成员变量需要显示的定义在类的外部


// main.cpp
#include"c.h"
#include<iostream>

int& testStatic21()
{
    C c("static21 test");
    std::cout << "name: " << c.getName() << " , height: " << c.height << std::endl;

    return c.height;
}
std::string& testStatic22()
{
    C c("static22 test");
    std::cout << "name: " << c.getName() << " , height: " << c.height << std::endl;

    return c.name;
}

int main()
{
    int& abc = testStatic21();

    std::cout << "abc: " << abc << std::endl; // 因为存储在静态存储区，所以离开函数作用域后，变量仍然存在

    std::string& name = testStatic22();
    std::cout << "name: " << name << std::endl; // 非静态成员变量实际存储位置是函数的栈空间中，因此离开函数作用域后，就会被释放掉，所以获取结果未可知

  return 0;
}

输出：

4. 静态类对象

static 关键字对类对象的工作方式也相同。声明为 static 的对象将分配到静态存储区中，并且一直作用到程序结束。

注：使用 static 关键字分配为零仅适用于原始数据类型，不适用于用户定义的数据类型。

// c.h
#include<iostream>
#include<string>

class C
{
public:
    C(std::string n):name(n)
    {
        std::cout << "constructor C name: " << this->name << std::endl;
    }
    ~C(){
        std::cout << "destructor C name: " << this->name << std::endl;
    }

    std::string  getName()
    {
        return this->name;
    }


private:
public:
    std::string name;
};


// main.cpp
int main()
{
   C& cc = testStatic3();

   std::cout << "cc: " << cc.getName() << std::endl; // 静态对象存储在静态存储区, 所以离开函数作用域后，仍然存在

  return 0.
}

输出：

5. 类的静态方法

与类的静态成员变量类似，类的静态方法也属于类，任何类的对象都可以调用此类方法。

既可以通过 对象名. 静态方法 调用，也可以通过类名::静态方法，后一种方法更常用。

// c.h
#include<iostream>
#include<string>

class C
{
public:
    C(std::string n):name(n)
    {
        std::cout << "constructor C name: " << this->name << std::endl;
    }
    ~C(){
        std::cout << "destructor C name: " << this->name << std::endl;
    }

    std::string  getName()
    {
        return this->name;
    }

    static void print()
    {
        std::cout << "print height: " << height << std::endl;
    }



private:
public:
    std::string name;

    static int height;
};

// c.cpp
#include "c.h"


int C::height = 66;


// main.cpp
#include"c.h"
#include<iostream>

void testStatic4()
{
    C::print();
    C c("888");
    c.print();
}

int main()
{
  testStatic4();

  return 0;
}

二    static 变量几种初始化方式

C++中static变量的初始化_c++ static 重新初始化_LikeMarch的博客-CSDN博客

三种初始化：

1. 编译时初始化

2. 程序加载时初始化

3. 运行时初始化

1. 编译时初始化

若 静态全局变量 是 基本数据类型（POD） ，且初始化值为常量，那么该变量会在编译期初始化。

/ main.cpp

static int xx = 666;

int main()
{

   return 0;
}

2. 程序加载时初始化

程序被加载时立即初始化，该过程发生在main 函数执行前。即使程序任何地方都没访问过该变量，仍然会进行初始化，因此形象地称之为"饿汉式初始化"。

2.1  静态全局变量初始化（初始值不是常量时），此时变量初始化是在程序加载时初始化的。

// main.cpp

int x = 6;
int y = 8;
static int z = x + y;

int main()
{

  return 0;
}

2.2  静态全局变量不是基本类型，此时变量初始化是在程序加载时初始化的。

// d.h
#include<iostream>
#include<string>

class D
{
public:
    D(std::string n):name(n)
    {
        std::cout << "constructor D name: " << this->name << std::endl;
    }
    ~D()
    {
        std::cout << "destructor D name: " << this->name << std::endl;
    }

private:
    std::string name;
};

// c.h
class C
{
public:
    C(std::string n):name(n)
    {
        std::cout << "constructor C name: " << this->name << std::endl;
    }
    ~C(){
        std::cout << "destructor C name: " << this->name << std::endl;
    }

    std::string  getName()
    {
        return this->name;
    }

    static void print()
    {
        std::cout << "print height: " << height << std::endl;
    }



private:
public:
    std::string name;

    static int height;
    static D d;
};

// c.cpp
int C::height = 66;

D C::d = D("CD static");

// main.cpp
#include<string>
#include<iostream>
#include"c.h"

void testStatic5()
{
    C c("testStatic5 -- ");
    std::cout << "testStatic5 c name: " << c.getName() << std::endl;
}

static D d("before main inialiaze!");

int main()
{

  std::cout << "enter int main func!!" << std::endl;
  testStatic5();

  return 0;
}

3. 运行时初始化

程序执行到静态变量的定义引用时，才会初始化，因此也被称为“懒汉式初始化”。

比如静态局部变量就是典型的 运行时初始化。

// d.h
class D
{
public:
    D(std::string n):name(n)
    {
        std::cout << "constructor D name: " << this->name << std::endl;
    }
    ~D()
    {
        std::cout << "destructor D name: " << this->name << std::endl;
    }

public:
    std::string name;
};


// main.cpp

#include<iostream>
#include"d.h"


void testStaticInitialize(){
    static D d("testStaticInitialize --- ");
}

int main()
{
  std::cout << "enter int main func!!" << std::endl;
  static D dd("dd --- ");
  testStaticInitialize();

  return 0;
}

输出：

在河之洲木水
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C++ static关键字的原理及用法详解
04-07
本文详细介绍了static关键字在C++中的作用和原理，并通过充分的代码示例进行了说明，帮助读者深入理解并正确使用static关键字。 `static`关键字在C++中的使用确实涉及到多个方面，包括局部变量的存储期、全局变量和...
详解c++中的 static 关键字及作用
12-20
　1、用 static关键字 修饰； 　2、可以用 类名::成员名 访问 静态成员； 　3、静态成员 属于 整个类； 　4、静态成员 是所属类的成员，其它类不能访问； 　5、静态成员的内存分配 是 唯一的； 　1) 静态成员变
return机制
avrdpy的专栏
01-14 1213
return机制
第十四届蓝桥杯集训——自定义函数+static+return
红目香薰
01-11 794
第十四届蓝桥杯集训——自定义函数+static+return 前言 方法的优点 自定义函数 方法的命名规则 自定义函数的结构 自定义函数示例 函数重载 对象 类 内部类 创建自己类的对象 修饰符 自定义函数调用 static修饰符 static的特点 retuen特点 另外两个循环控制语句
C++ static关键字用法
qq_35064674的博客
05-18 968
C++ static关键字的用法
【C++】static关键字用法
Catdeo的博客
10-12 206
static关键字 1.全局静态变量 在全局变量前加上关键字static，全局变量就被定义成为全局静态变量，存放在静态存储区，在整个程序的运行期间一直存在 初始化:未初始化的全局静态变量会被自动初始化为0（自动对象的值是任意的，除非他被显示初始化） 作用域：作用域发生改变，仅在当前文件中有效。 2.局部静态变量 在局部变量之前加上static关键字，局部变量就成为局部静态变量，存放在静态存储区。 ...
C++ static静态成员静态函数，语法+示例，超详细！！
最新发布
ken2232的博客
05-31 1万+
C++ static静态成员静态函数，语法+示例，超详细！！
细说C++（十六）：static用法-全解析
GeniusIOTboy的博客
01-24 557
static static修饰局部变量时，使得被修饰的变量成为静态变量，存储在静态区。存储在静态区的数据生命周期与程序相同，在main函数之前初始化，在程序退出时销毁。（无论是局部静态还是全局静态） 局部静态变量使得该变量在退出函数后，不会被销毁，因此再次调用该函数时，该变量的值与上次退出函数时值相同。值得注意的是，生命周期并不代表其可以一直被访问，因为变量的访问还受到其作用域的限制。 s...
C/C++中static关键字用法汇总
网络资源是无限的
07-01 3846
        1. 函数内static局部变量：变量在程序初始化时被分配，直到程序退出前才被释放，也就是static是按照程序的生命周期来分配释放变量的，而不是变量自己的生命周期。多次调用，仅需一次初始化。        2. cpp内的static全局变量：只在cpp内有效。在不同的cpp文件中定义同名变量，不必担心命名冲突。保持变量内容的持久。        3. 头文件内的static全局...
c++中static的用法详解
qq_51533157的博客
10-11 1026
C 语言的 static 关键字有三种（具体来说是两种）用途： 1. 静态局部变量：用于函数体内部修饰变量，这种变量的生存期长于该函数。 int foo(){ static int i = 1; // note:1 //int i = 1; // note:2 i += 1; return i; } 要明白这个用法，我们首先要了解c/c++的内存分布，以及static所在的区间。 对于一个完整的程序，在内存中的分布情况如下图：　1.栈区： 由编译器自动分配释放，...
C++总结
zhongjie的专栏
12-06 2510
经验：1、一个函数只实现相应的一个单功能2、用extern声明外部变量   (1)在同一个文件内，若定义在文件中间，要在文件前面使用，可以在前面用extern声明   (2)在相关联的不同的文件内，若文件A定义了变量a，文件B要使用变量a，若都定义变量a会出现重复定义错误，在文件B中只要加上extern a(不用加类型如int，但建议加上，否则可能出现不可预期的错误，实际操作中的经验)，就可以使用
c++ 中return返回值与内存的分配释放详解
u011555996的博客
01-11 3744
c++
C++ static关键字详细应用指南
07-21
在这里我们就为大家详细介绍一下C++ static关键字的使用方法，让大家进一步对这一语言有一个深入的解读。
一文读懂c++之static关键字
08-19
主要介绍了c++之static关键字的的相关资料，文中示例代码非常详细，供大家参考和学习，感兴趣的朋友可以了解下
C++面试基础之static关键字详解
08-26
主要给大家介绍了关于C++面试基础之static关键字的相关资料，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面来一起学习学习吧
C++中static关键字作用总结
qq_31130535的博客
04-03 99
1.先来介绍它的第一条也是最重要的一条：隐藏。（static函数，static变量均可） 当同时编译多个文件时，所有未加static前缀的全局变量和函数都具有全局可见性。 2.static的第二个作用是保持变量内容的持久。（static变量中的记忆功能和全局生存期） 存储在静态数据区的变量会在程序刚开始运行时就完成初始化，也是唯一的一次初始化。共有两种变量存储在静态存储区：全局变量和static变...
C++ static关键字的用法
weixin_45622395的博客
10-07 124
静态全局变量 静态全局变量 静态成员变量 静态成员函数
static静态关键字详解(工具类、代码块、单例模式)
weixin_53622554的博客
02-10 2824
静态成员变量(类变量)静态方法（类方法）。可以被类的所有对象共享（访问、修改）
C++ static用法总结
kupePoem的专栏
11-13 2487
要理解static关键字在C++中的所有作用，首先要明白程序所使用的不同内存区域的作用。C++程序运行时使用三种内存，一种是static内存，还有一种是stack内存，以及heap内存(动态内存池)。
C++中，static对象和static关键字的区别
05-17
对于变量，使用static关键字可以将其作用域限制在当前文件中，即使在不同的函数中定义相同名称的static变量，它们也互不影响。 对于函数，使用static关键字可以将其作用域限制在当前文件中，使其不能被其他文件调用...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值