C++ 存储类及示例¶

// C++ 程序演示 auto 存储类
#include <iostream>
using namespace std;

void autoStorageClass()
{
    cout << "Demonstrating auto class\n";

    // 声明一个 auto 变量
    int a = 32;
    float b = 3.2;
    char* c = "GeeksforGeeks";
    char d = 'G';

    // 打印 auto 变量
    cout << a << " \n";
    cout << b << " \n";
    cout << c << " \n";
    cout << d << " \n";
}

int main()
{
    // 演示 auto 存储类
    autoStorageClass();

    return 0;
}

// C++ 程序演示 extern 存储类
#include <iostream>
using namespace std;

// 声明一个变量，使其成为 extern，初始值可以
// 也可以初始化为 x
int x;

void externStorageClass()
{
    cout << "Demonstrating extern class\n";

    // 告诉编译器变量 x 是一个 extern 变量
    // 并且已在其他地方定义（main 函数之前）
    extern int x;

    // 打印 extern 变量 'x'
    cout << "Value of the variable 'x'"
         << " declared as extern: " << x << "\n";

    // 修改 extern 变量 x 的值
    x = 2;

    // 打印修改后的 extern 变量 'x'
    cout << "Modified value of the variable 'x'"
         << " declared as extern: \n"
         << x;
}

int main()
{
    // 演示 extern 存储类
    externStorageClass();

    return 0;
}

// C++ 程序演示 static 存储类
#include <iostream>
using namespace std;

// 包含静态变量的函数
// 在执行期间内存被保留
int staticFun()
{
    cout << "For static variables: ";
    static int count = 0;
    count++;
    return count;
}

// 包含非静态变量的函数
// 内存被销毁
int nonStaticFun()
{
    cout << "For Non-Static variables: ";

    int count = 0;
    count++;
    return count;
}

int main()
{
    // 调用静态部分
    cout << staticFun() << "\n";
    cout << staticFun() << "\n";

    // 调用非静态部分
    cout << nonStaticFun() << "\n";
    cout << nonStaticFun() << "\n";

    return 0;
}

// C++ 程序演示寄存器变量的使用
#include <iostream>
using namespace std;

void registerStorageClass()
{
    cout << "Demonstrating register class\n";

    // 声明一个寄存器变量
    register char b = 'G';

    // 打印寄存器变量 'b'
    cout << "Value of the variable 'b'"
         << " declared as register: " << b;
}

int main()
{
    // 演示 register 存储类
    registerStorageClass();
    return 0;
}

// C++ 程序演示 mutable 存储类说明符的使用
#include <iostream>
using std::cout;

class Test {
public:
    int x;

    // 定义 mutable 变量 y
    // 现在它可以被修改
    mutable int y;

    Test()
    {
        x = 4;
        y = 10;
    }
};

int main()
{
    // t1 被设置为常量
    const Test t1;

    // 尝试改变值
    t1.y = 20;
    cout << t1.y;

    // 取消注释以下行
    // 将会报错
    // t1.x = 8;
    // cout << t1.x;
    return 0;
}

// C++ 程序演示使用 thread_local 存储说明符
#include <iostream>
#include <mutex>
#include <thread>

using namespace std;

// 定义线程本地变量
thread_local int value = 10;
// 用于同步的互斥锁
mutex mtx;

int main()
{
    // 创建 3 个线程
    // 在线程 1 中修改值
    thread th1([]() {
        value += 18;
        lock_guard<mutex> lock(mtx);
        cout << "Thread 1 value: " << value << '\n';
    });

    thread th2([]() {
        // 在线程 2 中修改值
        value += 7;
        lock_guard<mutex> lock(mtx);
        cout << "Thread 2 value: " << value << '\n';
    });

    thread th3([]() {
        // 在线程 3 中修改值
        value += 13;
        lock_guard<mutex> lock(mtx);
        cout << "Thread 3 value: " << value << '\n';
    });

    // 等待所有线程完成
    th1.join();
    th2.join();
    th3.join();

    // 打印主线程中的 value 值
    cout << "Main thread value: " << value << '\n';

    return 0;
}