C++ static相关知识

最新推荐文章于 2025-02-14 20:05:33 发布
原创 最新推荐文章于 2025-02-14 20:05:33 发布 · 1.1k 阅读 · 26 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#c++

注意：本文章整理于GPT。

1、 const的含义及实现机制,比如 const int 1,是怎么做到i只可读的

const关键字在C++中用于定义常量，即其值在初始化后不能被修改。它可以应用于变量、成员函数、函数参数、返回值等，来确保数据的只读性。下面详细解释const的含义及其实现机制。

const的基本用法

  1. 常量变量：定义不可修改的变量。

    const int i = 10; // i是一个常量，不能修改
// i = 20; // 错误，无法修改const变量

  2. 指针和常量指针：

    • 指向常量的指针（pointer to const）：指针指向的值是常量，不能通过指针修改该值。

      const int *p = &i; // p指向一个const int，不能通过p修改i
// *p = 20; // 错误，不能通过p修改i
int j = 30;
p = &j; // 正确，可以修改p指向的地址

    • 常量指针（const pointer）：指针本身是常量，不能修改指针指向的地址。

      int k = 40;
int *const q = &k; // q是一个常量指针，不能修改q的地址
*q = 50; // 正确，可以通过q修改k
// q = &i; // 错误，不能修改q指向的地址

    • 指向常量的常量指针（const pointer to const）：指针和指针指向的值都是常量，不能修改指针的地址，也不能通过指针修改指向的值。

      const int *const r = &i; // r是一个指向const int的const指针
// *r = 20; // 错误，不能通过r修改i
// r = &j; // 错误，不能修改r指向的地址

  3. 常量成员函数：声明为const的成员函数不能修改对象的成员变量。

    class MyClass {
private:
    int value;
public:
    MyClass(int val) : value(val) {}
    int getValue() const { // 常量成员函数
        return value;
    }
    void setValue(int val) {
        value = val;
    }
};

int main() {
    const MyClass obj(10);
    int val = obj.getValue(); // 可以调用const成员函数
    // obj.setValue(20); // 错误，不能调用非const成员函数
    return 0;
}

const的实现机制

在C++中，const通过编译器强制执行，以确保变量在声明为常量后不能被修改。编译器在编译时检查对const变量的所有操作，并确保没有代码试图修改它们。

编译时检查

编译器在编译过程中会对const变量进行以下检查：

  1. 初始化：const变量必须在声明时初始化，因为之后无法再修改其值。

    const int i = 10; // 正确，声明时初始化
// const int j; // 错误，const变量必须初始化

  2. 防止修改：编译器会禁止任何试图修改const变量的代码。

    const int i = 10;
// i = 20; // 错误，不能修改const变量

  3. 函数签名：对于接受const参数的函数，编译器会确保函数体内不修改这些参数。

    void func(const int param) {
    // param = 20; // 错误，不能修改const参数
}
const对象的内存布局

在内存中，const变量和普通变量的布局没有区别。const的作用仅在于限制对变量的修改。编译器会在符号表中记录变量的const属性，以确保在代码中遵循只读的约束。

const int i = 10;
int j = 20;

std::cout << &i << std::endl; // 输出i的地址
std::cout << &j << std::endl; // 输出j的地址

在上述代码中，i和j在内存中的存储方式相同，const关键字只是确保在程序运行过程中i的值不会被修改。

const和优化

编译器可以利用const信息进行优化。例如，对于const变量，编译器可以直接在使用该变量的地方替换成它的值，从而减少内存访问，提高运行效率。

const int i = 10;

void func() {
    int a = i; // 编译器可能直接将10赋给a，而不进行内存访问
}

总结

  • const关键字用于定义常量，确保变量在初始化后不能被修改。
  • const可以应用于变量、指针、函数参数和成员函数等，提供只读保护。
  • 编译器在编译时检查对const变量的所有操作，防止对其进行修改。
  • 在内存中，const变量和普通变量的存储方式相同，但编译器利用const信息进行优化。
  • const提高了代码的安全性和可读性，使程序更易于维护。

通过这些机制，const在C++中确保了变量的只读性，并帮助编译器进行更有效的优化。

2、静态变量和全局变量的区别

在C++中，静态变量和全局变量都是存储在静态存储区的，它们在程序的生命周期内都存在。但是，它们在作用域、生命周期以及使用场景上有显著的区别。下面详细解释静态变量和全局变量的区别。

全局变量

定义：
全局变量是在所有函数外部声明的变量，作用域是整个文件，甚至可以在多个文件中共享（如果使用extern关键字）。

特性：

  1. 作用域：全局变量的作用域是整个程序文件，在定义它的文件中任何地方都可以访问它。如果使用extern声明，它可以在其他文件中访问。
  2. 生命周期：全局变量在程序开始时分配内存，在程序结束时释放内存。
  3. 初始值：如果没有显式初始化，全局变量会被默认初始化为零。

示例：

#include <iostream>

int globalVar = 10; // 全局变量

void foo() {
    std::cout << "globalVar in foo: " << globalVar << std::endl;
}

int main() {
    std::cout << "globalVar in main: " << globalVar << std::endl;
    foo();
    return 0;
}

静态变量

静态变量有两种主要形式：静态局部变量和静态全局变量。它们都有不同的作用域和使用场景。

静态局部变量

定义：
静态局部变量是在函数内部使用static关键字声明的变量。它们的作用域局限于声明它们的函数，但其生命周期贯穿整个程序运行过程。

特性：

  1. 作用域：静态局部变量的作用域仅限于声明它的函数内部。
  2. 生命周期：静态局部变量在程序开始时分配内存，在程序结束时释放内存。即使函数多次调用，静态局部变量也只初始化一次，并保持其值。
  3. 初始值：如果没有显式初始化，静态局部变量会被默认初始化为零。

示例：

#include <iostream>

void foo() {
    static int staticVar = 0; // 静态局部变量
    staticVar++;
    std::cout << "staticVar in foo: " << staticVar << std::endl;
}

int main() {
    foo(); // 输出：1
    foo(); // 输出：2
    foo(); // 输出：3
    return 0;
}
静态全局变量

定义：
静态全局变量是在所有函数外部使用static关键字声明的变量。它们的作用域局限于声明它们的文件，不能在其他文件中访问。

特性：

  1. 作用域：静态全局变量的作用域仅限于声明它的文件，其他文件不能直接访问它。
  2. 生命周期：静态全局变量在程序开始时分配内存，在程序结束时释放内存。
  3. 初始值：如果没有显式初始化，静态全局变量会被默认初始化为零。

示例：

#include <iostream>

static int staticGlobalVar = 20; // 静态全局变量

void bar() {
    std::cout << "staticGlobalVar in bar: " << staticGlobalVar << std::endl;
}

int main() {
    std::cout << "staticGlobalVar in main: " << staticGlobalVar << std::endl;
    bar();
    return 0;
}

总结

特性全局变量静态局部变量静态全局变量
作用域整个文件，使用extern可以跨文件声明它的函数内部声明它的文件内部
生命周期程序开始到程序结束程序开始到程序结束程序开始到程序结束
初始值默认初始化为零默认初始化为零默认初始化为零
使用场景需要在多个函数或文件中共享数据保留函数内的数据在多次调用之间的状态需要限制全局变量的访问范围在单个文件内

通过以上解释，可以看出全局变量和静态变量各有不同的应用场景。全局变量适用于需要在多个文件中共享数据的情况，而静态局部变量适用于需要在函数内部保持状态的情况，静态全局变量则适用于需要在文件内部共享数据但不希望被其他文件访问的情况。

3、static存放在哪个区？

在C++中，static变量存放在静态存储区，也称为全局数据区或静态数据区。这个存储区在程序执行期间是固定的，它包含了以下几类变量：

  1. 全局变量（Global Variables）：无论是否加static关键字，全局变量都存储在静态存储区。
  2. 静态变量（Static Variables）：包括静态局部变量和静态全局变量，它们都存储在静态存储区。
  3. 常量（Constants）：一些编译器也会将常量存储在静态存储区中。

静态存储区的特点

  1. 固定内存地址：静态存储区中的变量在程序执行期间有固定的内存地址。
  2. 程序生命周期：静态存储区中的变量在程序开始执行时分配内存，并在程序结束时释放内存。因此，它们的生命周期贯穿整个程序运行过程。
  3. 默认初始化：静态存储区中的变量如果没有显式初始化，会被自动初始化为零（零值初始化）。

静态变量的示例和分析

静态局部变量

静态局部变量在函数内部声明，但在静态存储区中分配内存。它们在程序开始时初始化，并保持其值直到程序结束。

#include <iostream>

void foo() {
    static int staticVar = 0; // 静态局部变量
    staticVar++;
    std::cout << "staticVar in foo: " << staticVar << std::endl;
}

int main() {
    foo(); // 输出：staticVar in foo: 1
    foo(); // 输出：staticVar in foo: 2
    foo(); // 输出：staticVar in foo: 3
    return 0;
}

在这个例子中，staticVar的内存只在静态存储区分配一次，即使foo函数被多次调用，staticVar的值也会保留上一次调用后的状态。

静态全局变量

静态全局变量在文件的全局作用域中声明，但使用static关键字限制其作用域仅限于声明它的文件。

#include <iostream>

static int staticGlobalVar = 20; // 静态全局变量

void bar() {
    std::cout << "staticGlobalVar in bar: " << staticGlobalVar << std::endl;
}

int main() {
    std::cout << "staticGlobalVar in main: " << staticGlobalVar << std::endl;
    bar();
    return 0;
}

在这个例子中，staticGlobalVar在静态存储区中分配内存，并且其作用域仅限于声明它的文件。其他文件无法访问这个变量。

总结

  • 静态存储区：static变量和全局变量都存放在静态存储区，该存储区在程序执行期间是固定的，内存地址不变。
  • 生命周期：静态存储区中的变量在程序开始时分配内存，并在程序结束时释放内存。
  • 默认初始化：静态存储区中的变量如果没有显式初始化，会被自动初始化为零。

理解静态存储区和静态变量的存储位置，有助于编写更高效、更可靠的代码，特别是在处理全局状态和跨函数共享数据时。

4、cpp static的作用

在C++中，static关键字有多种用途，分别应用于不同的场景：局部变量、全局变量、类成员变量和类成员函数。每种使用方式都有不同的作用和效果。以下是static关键字在不同上下文中的作用及其示例。

1. 静态局部变量

作用：静态局部变量在函数内声明，但它们的生命周期贯穿整个程序的运行周期。即使函数多次调用，静态局部变量也只初始化一次，并且保留上一次函数调用后留下的值。

示例：

#include <iostream>

void foo() {
    static int count = 0; // 静态局部变量
    count++;
    std::cout << "count: " << count << std::endl;
}

int main() {
    foo(); // 输出: count: 1
    foo(); // 输出: count: 2
    foo(); // 输出: count: 3
    return 0;
}

2. 静态全局变量

作用：静态全局变量在文件作用域内声明，但它们只能在声明它们的文件中访问。static关键字限制了变量的作用域，防止在其他文件中被访问。

示例：

// file1.cpp
#include <iostream>

static int globalVar = 10; // 静态全局变量

void foo() {
    std::cout << "globalVar in foo: " << globalVar << std::endl;
}

int main() {
    foo();
    return 0;
}

// file2.cpp
extern void foo();

int main() {
    // std::cout << "globalVar in main: " << globalVar << std::endl; // 错误：不能在其他文件中访问静态全局变量
    foo();
    return 0;
}

3. 静态类成员变量

作用：静态类成员变量是类的所有实例共享的变量。它们在类的所有对象之间共享，并且独立于任何对象存在。必须在类外部定义和初始化静态成员变量。

示例：

#include <iostream>

class MyClass {
public:
    static int staticVar; // 静态类成员变量

    static void printStaticVar() { // 静态成员函数
        std::cout << "staticVar: " << staticVar << std::endl;
    }
};

int MyClass::staticVar = 0; // 定义和初始化静态成员变量

int main() {
    MyClass obj1, obj2;
    obj1.staticVar = 5;
    obj2.printStaticVar(); // 输出: staticVar: 5
    return 0;
}

4. 静态类成员函数

作用：静态成员函数是类的所有实例共享的函数。它们不能访问非静态成员变量和非静态成员函数，但可以访问静态成员变量和静态成员函数。

示例：

#include <iostream>

class MyClass {
public:
    static int staticVar; // 静态类成员变量

    static void staticFunc() { // 静态成员函数
        std::cout << "staticVar: " << staticVar << std::endl;
        // std::cout << "nonStaticVar: " << nonStaticVar << std::endl; // 错误：静态成员函数不能访问非静态成员变量
    }

    void nonStaticFunc() {
        std::cout << "staticVar: " << staticVar << std::endl;
    }
};

int MyClass::staticVar = 10; // 定义和初始化静态成员变量

int main() {
    MyClass::staticFunc(); // 调用静态成员函数
    MyClass obj;
    obj.nonStaticFunc(); // 调用非静态成员函数
    return 0;
}

总结

  • 静态局部变量：在函数内声明，生命周期贯穿整个程序执行期，函数多次调用只初始化一次。
  • 静态全局变量：在文件作用域内声明，只能在声明它的文件中访问，其他文件不可见。
  • 静态类成员变量：属于类的所有实例共享，独立于任何对象存在，必须在类外部定义和初始化。
  • 静态类成员函数：属于类的所有实例共享，不能访问非静态成员变量和非静态成员函数。

通过合理使用static关键字，可以控制变量和函数的作用域、生命周期以及共享方式，从而提高代码的可维护性和效率。

5、Static分配内存空间的时机

在C++中，static变量的内存空间分配时机是一个关键的概念，理解这一点对于掌握变量的生命周期和作用域非常重要。下面详细解释static变量内存空间的分配时机以及其生命周期。

静态变量的内存分配时机

static变量包括静态局部变量、静态全局变量、静态类成员变量。这些变量在程序启动时分配内存，并在程序结束时释放内存。

1. 静态局部变量

定义：静态局部变量是在函数内部使用static关键字声明的变量。

内存分配时机：静态局部变量的内存在程序启动时分配，即使函数从未被调用。它们在程序的整个生命周期内存在。

生命周期：从程序开始到程序结束，即使函数多次调用，静态局部变量也只初始化一次。

示例：

#include <iostream>

void foo() {
    static int count = 0; // 静态局部变量
    count++;
    std::cout << "count: " << count << std::endl;
}

int main() {
    foo(); // 输出: count: 1
    foo(); // 输出: count: 2
    foo(); // 输出: count: 3
    return 0;
}

在这个示例中，count变量的内存在程序启动时分配，即使foo函数从未被调用过。

2. 静态全局变量

定义：静态全局变量是在文件的全局作用域中使用static关键字声明的变量。

内存分配时机：静态全局变量的内存在程序启动时分配。

生命周期：从程序开始到程序结束，整个程序的生命周期。

示例：

#include <iostream>

static int globalVar = 10; // 静态全局变量

void foo() {
    std::cout << "globalVar: " << globalVar << std::endl;
}

int main() {
    foo(); // 输出: globalVar: 10
    return 0;
}

在这个示例中，globalVar变量的内存在程序启动时分配，并在程序结束时释放。

3. 静态类成员变量

定义：静态类成员变量是类的所有实例共享的变量。

内存分配时机：静态类成员变量的内存在程序启动时分配。它们的内存空间独立于任何对象的实例化。

生命周期：从程序开始到程序结束。

示例：

#include <iostream>

class MyClass {
public:
    static int staticVar; // 静态类成员变量

    static void printStaticVar() { // 静态成员函数
        std::cout << "staticVar: " << staticVar << std::endl;
    }
};

int MyClass::staticVar = 0; // 定义和初始化静态成员变量

int main() {
    MyClass::staticVar = 5;
    MyClass::printStaticVar(); // 输出: staticVar: 5
    return 0;
}

在这个示例中，staticVar变量的内存在程序启动时分配，并且它在程序结束时释放。

总结

  • 静态局部变量：在程序启动时分配内存，生命周期从程序开始到程序结束，函数多次调用只初始化一次。
  • 静态全局变量：在程序启动时分配内存，生命周期从程序开始到程序结束，作用域仅限于声明它的文件。
  • 静态类成员变量：在程序启动时分配内存，生命周期从程序开始到程序结束，所有类实例共享。

这些静态变量在程序启动时就已经分配好了内存空间，因此它们在程序的任何时候都可以访问，并且其值在整个程序运行期间保持不变。理解静态变量的内存分配时机和生命周期对于有效管理内存和控制变量的作用域至关重要。

6、静态变量在哪儿初始化的？以及编译的过程

静态变量的初始化是一个关键的概念，在C++中，静态变量包括静态局部变量、静态全局变量和静态类成员变量。静态变量的初始化通常在程序启动时进行，即在main函数执行之前。下面详细解释静态变量初始化的时机、初始化过程以及编译的过程。

静态变量的初始化

静态局部变量

静态局部变量在第一次调用其所在的函数时初始化，但其内存空间是在程序启动时分配的。

示例：

#include <iostream>

void foo() {
    static int count = 0; // 静态局部变量
    count++;
    std::cout << "count: " << count << std::endl;
}

int main() {
    foo(); // 输出: count: 1
    foo(); // 输出: count: 2
    foo(); // 输出: count: 3
    return 0;
}

在这个示例中，count变量在第一次调用foo函数时初始化为0。

静态全局变量

静态全局变量在程序开始执行之前初始化。

示例：

#include <iostream>

static int globalVar = 10; // 静态全局变量

void foo() {
    std::cout << "globalVar: " << globalVar << std::endl;
}

int main() {
    foo(); // 输出: globalVar: 10
    return 0;
}

在这个示例中，globalVar在程序启动时初始化为10。

静态类成员变量

静态类成员变量在程序开始执行之前初始化，但需要在类外部定义和初始化。

示例：

#include <iostream>

class MyClass {
public:
    static int staticVar; // 静态类成员变量
};

int MyClass::staticVar = 0; // 定义和初始化静态成员变量

int main() {
    MyClass::staticVar = 5;
    std::cout << "staticVar: " << MyClass::staticVar << std::endl; // 输出: staticVar: 5
    return 0;
}

在这个示例中，staticVar在程序启动时初始化为0。

编译和初始化过程

编译过程

  1. 预处理（Preprocessing）：

    • 处理预处理指令（如#include、#define等）。
    • 生成一个纯C++源文件。

  2. 编译（Compilation）：

    • 将C++源文件编译成目标代码（机器代码），生成目标文件（.obj或.o文件）。
    • 检查语法和语义错误。

  3. 汇编（Assembly）：

    • 将目标代码转换为机器指令，生成二进制文件。

  4. 链接（Linking）：

    • 将所有目标文件和库文件链接在一起，生成可执行文件。
    • 解决外部符号引用（如函数调用和全局变量）。
初始化过程

  1. 静态存储区初始化：

    • 静态存储区包括全局变量、静态变量和常量。
    • 在程序启动时分配内存空间并进行初始化。
    • 全局和静态变量初始化顺序：从定义的顺序开始，按声明的顺序初始化。

  2. 静态构造函数（Static Constructors）：

    • 在C++中，可以定义静态对象（如全局对象或静态成员对象）的构造函数。
    • 这些构造函数在main函数之前执行，用于初始化静态对象。

示例：

#include <iostream>

class MyClass {
public:
    MyClass() {
        std::cout << "MyClass Constructor" << std::endl;
    }
    ~MyClass() {
        std::cout << "MyClass Destructor" << std::endl;
    }
};

static MyClass myObject; // 静态全局对象

int main() {
    std::cout << "main function" << std::endl;
    return 0;
}

在这个示例中，MyClass的构造函数在main函数之前执行，输出"MyClass Constructor"。

静态变量的默认初始化

  • 基本类型：如果静态变量没有显式初始化，它们会被自动初始化为零。
    • 整型（int、short、long等）初始化为0。
    • 浮点型（float、double等）初始化为0.0。
    • 指针型初始化为nullptr。

示例：

#include <iostream>

static int globalInt; // 未显式初始化，默认初始化为0
static double globalDouble; // 未显式初始化，默认初始化为0.0

int main() {
    std::cout << "globalInt: " << globalInt << std::endl; // 输出: globalInt: 0
    std::cout << "globalDouble: " << globalDouble << std::endl; // 输出: globalDouble: 0.0
    return 0;
}

总结

  • 静态变量：包括静态局部变量、静态全局变量和静态类成员变量，它们的内存在程序启动时分配。
  • 初始化时机：静态局部变量在第一次调用时初始化，静态全局变量和静态类成员变量在程序开始执行之前初始化。
  • 编译过程：包括预处理、编译、汇编和链接。
  • 静态变量的默认初始化：未显式初始化的静态变量会被默认初始化为零。

通过理解静态变量的初始化和编译过程，可以更好地管理程序的内存和生命周期。

实例详解C/C++中static与extern关键字的使用
dvlinker的技术专栏
07-10 1万+
通过一次项目实践来详细讲述static与extern两关键字的使用。
C/C++知识教程：static的用法
C语言C++学习俱乐部：765860056
01-20 1032
static 的用法 static关键字是C, C++中都存在的关键字, 它主要有三种使用方式, 其中前两种只指在C语言中使用, 第三种在C++中使用(C,C++中具体细微操作不尽相同, 本文以C++为准). (1)局部静态变量 (2)外部静态变量/函数 (3)静态数据成员/成员函数 下面就这三种使用方式及注意事项分别说明 （1）局部静态变量 定义在代码块中，只做用于代码块内 #include<iostream> using namespace std; int...
C++ static详解
热门推荐
芒种、的博客
11-02 1万+
一、c/c++共有： 修饰全局变量时，表明一个全局变量只对定义在同一文件中的函数可见。 修饰局部变量时，表明该变量的值不会因为函数终止而丢失。 修饰函数时，表明该函数只在同一文件中调用。 1、全局静态变量： 用法：在全局变量前加上关键字static，全局变量就定义成一个全局静态变量。 static int temp； 内存中的位置：静态存储区，在整个程序运行期间一直存在。 初始化：未经初始化的全局静态变量会被自动初始化为0（自动对象的值是任意的，除非他被显式初始化）； 作用域：全局静态变量在声明他的文件
static在 C++ 中的四种用法
CFY1226的博客
06-13 3333
但是注意，静态成员函数无法访问类的非静态成员变量，因为这些变量是与类的实例关联的，而静态成员函数不属于任何具体的类的实例。在这种情况下，我们不能直接传递一个非静态成员函数，因为非静态成员函数需要一个隐含的 this 指针，而我们在创建线程的时候不能提供这个 this 指针。上述代码不能正确运行，因为bar是一个非静态成员函数，而在startThread函数中，我们无法给出这样一个上下文。因为非静态成员函数需要一个对象的上下文（也就是this指针），而在这个例子中，我们并没有提供这样的上下文。
C++中的静态static
qq_20416633的博客
06-07 2201
C++中static关键字常用的用法。
4、CPP 面向对象之 ——多态、多继承、static 成员、const 成员
vincent3678的博客
05-28 992
多态、多继承、static 成员、const 成员多态1、重写2、虚函数3、总结多态4、虚函数表5、虚表的汇编6、虚表的细节7、调用父类的成员函数实现8、虚析构函数9、纯虚函数、抽象类多继承1、多继承体系下的构造函数调用2、多继承的虚表3、同名函数、成员变量的调用4、菱形继承5、虚继承6、多继承的应用static 静态成员1、静态成员变量2、静态成员函数3、静态成员汇编分析4、静态成员的继承5、static 的应用6、静态成员经典应用 – 单例模式const 成员1、const 成员变量2、const 成员
C++ static关键字详解
qq_43262059的博客
06-14 1633
本文内容会结合三个部分，分别通过代码说明static的特点，以及它们的使用场景，最后拿出几个问题进行讨论。
C++ static关键字详细应用指南
07-21
在C++编程语言中，static关键字是一个...这些知识点对于编写可维护、高效的C++代码至关重要。通过理解并正确使用static关键字，程序员可以在C++项目中更好地管理变量的作用域和生命周期，以及组织模块化的代码结构。
C++ 中的 `static` 关键字：作用与使用场景分析
最新发布
m0_62599305的博客
02-14 788
与普通的局部变量不同，静态局部变量的生命周期是整个程序的运行期，而不仅仅是函数的调用期间。静态成员变量是类的成员，但它不是某个特定对象的成员，而是属于整个类。静态成员函数是属于类的函数，而不是某个对象的函数。静态成员函数只能访问类的静态成员变量和静态成员函数，不能访问类的非静态成员。时，其作用域被限定在定义它的文件内部，不能被其他文件访问。是一个非常常用的关键字，它有多种不同的作用，广泛应用于变量、函数、类成员等多种场景中。静态全局变量和函数常用于模块化编程中，确保某个文件中的全局变量或函数不被外部访问。
cpp的static的实现
ptgood的博客
08-11 890
前言 学习自用,有错麻烦提一下 正文 static成员变量 static修饰的值会在静态区分配空间,是在编译时期就分配了空间,(那么在没运行时就占用了可执行文件的大小吧), 可以把static与全局变量作比较,实际上的实现也是像全局变量一样额外放一个地方,全局变量放在全局区,静态变量放在静态区局区,不同之处就在于static的类成员是指定只能类来访问的,相当于static成员变量做了访问限制的全局变量 static成员函数 不同于static的成员变量,static修饰的成员函数在代码区分配内
C/C++的static有什么用
tunmang5421的博客
10-08 1496
本文全介绍C/C++的static关键字，并记录自己的问题。
const的实现原理
u010276189的专栏
03-21 5707
const 用于修饰常量时，分两种情况 1. 被修饰的常量是基本类型 此时，程序在编译时，就将变量用常量来替换了。 实现机制：这些在编译期间完成，对于内置类型，如int，编译器可能使用常数直接替换掉对此变量的引用。而对于结构体不一定。 看下面的例子： const int j=100;    int *p=const_cast(&j);    *p=20
小议C++中const的实现机制
关注 Linux c/c++ 数据存储 网络 算法......
12-02 6231
问题 C语言以及C++语言中的const究竟表示什么？其具体的实现机制又是如何实现的呢？ 本文将对这两个问题进行一些分析，简单解释const的含义以及实现机制。 问题分析 简单的说const在C语言中表示只读的变量，而在C++语言中表示常量。关于const在C与C++语言中的使用以及更多的区别，以后有时间另开一贴说明。 那么const究竟是如何实现的呢？ 对
Cpp关键字破解（二）【static】篇
日月既往，不可复追
12-03 409
关键字总结-static 文章目录关键字总结-static概念static使用场景静态成员的使用类外初始化静态成员 概念 在一个类中，有时候并不希望所有的成员都能与类的对象相关联，而只希望有些成员能够被类的所有对象共享，此时就需要用到static关键字。静态成员可以是public也可以是private，静态成员包括：静态数据成员、静态成员函数。 定义一个类表示银行账户，其中每个类对象都拥有相同的静态成员：利率。一旦更新静态成员后，该类的所有对象都会使用新的静态成员，这是因为静态成员与类直接绑定。 class
C/C++中static关键字用法汇总
网络资源是无限的
07-01 3957
        1. 函数内static局部变量：变量在程序初始化时被分配，直到程序退出前才被释放，也就是static是按照程序的生命周期来分配释放变量的，而不是变量自己的生命周期。多次调用，仅需一次初始化。        2. cpp内的static全局变量：只在cpp内有效。在不同的cpp文件中定义同名变量，不必担心命名冲突。保持变量内容的持久。        3. 头文件内的static全局...
static变量定义在cpp文件的理由和文件作用域
流风逐云的博客
07-17 3576
为什么static变量要在cpp文件中定义？ 这两天做项目发现如果在类的头文件中定义static 变量，多个包含头文件的cpp文件会链接错误，提示重定义。 static如果定义在文件中，它的作用域是当前文件 在其他文件中是不可见的，也就是说如果头文件A.h中定义了一个变量static int a = 100，然后cpp文件A01.cpp和A02.cpp都包含了A.h.那么两个cpp中的a的地...
Cpp--static关键字作用
Cutepingping的博客
10-03 2661
1，static修饰局部变量的时候 生命周期与整个程序的生命周期一致，作用域与自动变量相同。退出函数的时候，尽管该变量存在，但是不能使用。 静态局部变量若在未声明的时候未赋予初值，则系统自动赋值为0. #include &lt;iostream&gt; #include "extern.h" using namespace std; int main() { static int ...
C++中Static绘图操作的深入探讨
为了深入理解如何在C++中使用static进行绘图操作，首先需要了解static关键字的基本概念以及C++绘图的基础知识。 静态变量（static variables）在C++中用于在函数或类中保持变量的值直到下一次程序执行到该位置时。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值