C++静态成员变量初始化顺序详解与解决方案

原创 于 2025-11-29 06:30:00 发布 · 929 阅读 · 10 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#c++ #开发语言

该文章已生成可运行项目，

C++静态成员变量初始化顺序详解与解决方案

静态成员变量的初始化顺序问题是C++中一个经典且容易出错的领域，特别是在涉及多个编译单元时。

1. 问题本质与根本原因

1.1 静态变量的分类和生命周期

class MyClass {
public:
    static int simple_static;           // 声明
    static constexpr int CONSTEXPR = 42; // 编译时常量
    static const int CONST_INT = 100;   // 整型常量（可在类内初始化）
    
    static std::string complex_static;  // 需要动态初始化的静态变量
};

// 定义必须在类外（除了const整型static成员）
int MyClass::simple_static = 0;
std::string MyClass::complex_static = "hello";

1.2 跨编译单元的初始化顺序问题

// File: logger.h
class Logger {
public:
    static Logger& getInstance() {
        static Logger instance;  // 局部静态变量
        return instance;
    }
    
    void log(const std::string& message) {
        std::cout << message << std::endl;
    }
    
private:
    Logger() = default;
};

// File: config.h  
class Config {
public:
    static Config& getInstance() {
        static Config instance;
        return instance;
    }
    
    void initialize() {
        Logger::getInstance().log("Config initialized");  // 问题：Logger可能还未初始化
    }
    
private:
    Config() {
        initialize();
    }
};

// File: main.cpp
Config& config = Config::getInstance();  // 静态变量，初始化顺序不确定

2. 具体问题表现

2.1 静态初始化顺序fiasco

// File: database.h
class Database {
public:
    static Database& getInstance() {
        static Database instance;
        return instance;
    }
    
    int getDefaultPort() const { return default_port; }
    
private:
    Database() {
        std::cout << "Database constructor" << std::endl;
    }
    
    int default_port = 3306;
};

// File: connection_pool.h
class ConnectionPool {
public:
    static ConnectionPool& getInstance() {
        static ConnectionPool instance;
        return instance;
    }
    
    ConnectionPool() {
        // 在Database初始化前调用getDefaultPort()会导致未定义行为
        port = Database::getInstance().getDefaultPort();
        std::cout << "ConnectionPool using port: " << port << std::endl;
    }
    
private:
    int port;
};

// 在不同编译单元中的全局变量，初始化顺序不确定
Database& db = Database::getInstance();
ConnectionPool& pool = ConnectionPool::getInstance();  // 可能先于Database初始化

2.2 静态析构顺序问题

class ResourceManager {
public:
    static ResourceManager& getInstance() {
        static ResourceManager instance;
        return instance;
    }
    
    ~ResourceManager() {
        std::cout << "ResourceManager destroyed" << std::endl;
    }
    
    void releaseResources() {
        std::cout << "Releasing resources" << std::endl;
    }
};

class Service {
public:
    static Service& getInstance() {
        static Service instance;
        return instance;
    }
    
    ~Service() {
        // 可能在ResourceManager之后析构，导致使用已销毁的对象
        ResourceManager::getInstance().releaseResources();  // 危险！
    }
};

// 析构顺序与构造顺序相反，但跨编译单元的顺序不确定

3. 解决方案

3.1 使用局部静态变量（Meyer’s Singleton）

// ✅ 最安全的单例模式
class SafeSingleton {
public:
    static SafeSingleton& getInstance() {
        static SafeSingleton instance;  // C++11保证线程安全
        return instance;
    }
    
    void doSomething() {
        std::cout << "Doing something safely" << std::endl;
    }
    
private:
    SafeSingleton() = default;
    ~SafeSingleton() = default;
    
    // 防止拷贝
    SafeSingleton(const SafeSingleton&) = delete;
    SafeSingleton& operator=(const SafeSingleton&) = delete;
};

// 使用示例
void usage() {
    SafeSingleton::getInstance().doSomething();  // 按需初始化
}

3.2 惰性初始化模式

class LazyInitialized {
private:
    static std::unique_ptr<LazyInitialized> instance;
    static std::mutex init_mutex;
    
    std::string data;
    
    LazyInitialized() : data("initialized") {
        std::cout << "LazyInitialized constructed" << std::endl;
    }
    
public:
    static LazyInitialized& getInstance() {
        if (!instance) {  // 双重检查锁定
            std::lock_guard<std::mutex> lock(init_mutex);
            if (!instance) {
                instance = std::make_unique<LazyInitialized>();
            }
        }
        return *instance;
    }
    
    const std::string& getData() const { return data; }
    
    ~LazyInitialized() {
        std::cout << "LazyInitialized destroyed" << std::endl;
    }
};

// 定义静态成员
std::unique_ptr<LazyInitialized> LazyInitialized::instance = nullptr;
std::mutex LazyInitialized::init_mutex;

3.3 显式初始化和清理

class ManagedStatic {
private:
    static ManagedStatic* instance;
    static bool initialized;
    static bool destroyed;
    
    std::vector<std::string> data;
    
    ManagedStatic() {
        data.push_back("item1");
        data.push_back("item2");
        initialized = true;
    }
    
public:
    static void initialize() {
        if (!initialized && !destroyed) {
            instance = new ManagedStatic();
        }
    }
    
    static ManagedStatic& getInstance() {
        if (!instance) {
            initialize();
        }
        return *instance;
    }
    
    static void cleanup() {
        if (instance) {
            delete instance;
            instance = nullptr;
            destroyed = true;
        }
    }
    
    const std::vector<std::string>& getData() const { return data; }
    
    ~ManagedStatic() {
        std::cout << "ManagedStatic destroyed" << std::endl;
    }
};

// 定义静态成员
ManagedStatic* ManagedStatic::instance = nullptr;
bool ManagedStatic::initialized = false;
bool ManagedStatic::destroyed = false;

// 在main开始和结束时调用
void application_main() {
    ManagedStatic::initialize();  // 显式初始化
    
    // 使用单例
    auto& instance = ManagedStatic::getInstance();
    
    ManagedStatic::cleanup();  // 显式清理
}

3.4 使用依赖注入容器

#include <memory>
#include <unordered_map>
#include <functional>
#include <typeindex>

class DIContainer {
private:
    static DIContainer* instance;
    std::unordered_map<std::type_index, std::function<std::shared_ptr<void>()>> factories;
    std::unordered_map<std::type_index, std::shared_ptr<void>> instances;
    
public:
    static DIContainer& getInstance() {
        static DIContainer container;
        return container;
    }
    
    template<typename T, typename... Args>
    void registerFactory(Args&&... args) {
        factories[std::type_index(typeid(T))] = [args...]() {
            return std::static_pointer_cast<void>(
                std::make_shared<T>(args...)
            );
        };
    }
    
    template<typename T>
    std::shared_ptr<T> resolve() {
        auto it = instances.find(std::type_index(typeid(T)));
        if (it != instances.end()) {
            return std::static_pointer_cast<T>(it->second);
        }
        
        auto factory_it = factories.find(std::type_index(typeid(T)));
        if (factory_it != factories.end()) {
            auto instance = factory_it->second();
            instances[std::type_index(typeid(T))] = instance;
            return std::static_pointer_cast<T>(instance);
        }
        
        throw std::runtime_error("Type not registered");
    }
    
    void clear() {
        instances.clear();
    }
};

// 使用示例
class ServiceA {
public:
    ServiceA() { std::cout << "ServiceA created" << std::endl; }
    void operation() { std::cout << "ServiceA operation" << std::endl; }
};

class ServiceB {
private:
    std::shared_ptr<ServiceA> serviceA;
    
public:
    ServiceB(std::shared_ptr<ServiceA> a) : serviceA(a) {
        std::cout << "ServiceB created" << std::endl;
    }
    
    void operation() {
        serviceA->operation();
        std::cout << "ServiceB operation" << std::endl;
    }
};

void use_di_container() {
    auto& container = DIContainer::getInstance();
    
    // 注册依赖（控制初始化顺序）
    container.registerFactory<ServiceA>();
    container.registerFactory<ServiceB>(container.resolve<ServiceA>());
    
    // 解析依赖（按需初始化）
    auto serviceB = container.resolve<ServiceB>();
    serviceB->operation();
}

4. 特定场景的解决方案

4.1 静态常量成员的优化处理

class Constants {
public:
    // 编译时常量，没有初始化顺序问题
    static constexpr int MAX_SIZE = 1024;
    static constexpr double PI = 3.141592653589793;
    static constexpr const char* NAME = "MyApplication";
    
    // 对于需要复杂初始化的静态成员，使用函数封装
    static const std::string& getConfigPath() {
        static const std::string path = initializeConfigPath();
        return path;
    }
    
    static const std::vector<int>& getPrimes() {
        static const std::vector<int> primes = initializePrimes();
        return primes;
    }
    
private:
    static std::string initializeConfigPath() {
        // 复杂的初始化逻辑
        return "/etc/myapp/config.json";
    }
    
    static std::vector<int> initializePrimes() {
        return {2, 3, 5, 7, 11, 13, 17, 19, 23, 29};
    }
};

4.2 解决循环依赖问题

class ServiceA;  // 前向声明

class ServiceB {
private:
    static std::shared_ptr<ServiceA> getServiceA() {
        static auto instance = std::make_shared<ServiceA>();
        return instance;
    }
    
public:
    static ServiceB& getInstance() {
        static ServiceB instance;
        return instance;
    }
    
    void operation() {
        getServiceA()->doSomething();
        std::cout << "ServiceB operation" << std::endl;
    }
    
private:
    ServiceB() = default;
};

class ServiceA {
public:
    static ServiceA& getInstance() {
        static ServiceA instance;
        return instance;
    }
    
    void doSomething() {
        ServiceB::getInstance().operation();
        std::cout << "ServiceA doSomething" << std::endl;
    }
    
private:
    ServiceA() = default;
};

// 使用延迟解析打破循环依赖
void use_services() {
    ServiceA::getInstance().doSomething();  // 安全，无循环初始化
}

4.3 线程安全的静态初始化

#include <atomic>
#include <mutex>

class ThreadSafeStatic {
private:
    static std::atomic<ThreadSafeStatic*> instance;
    static std::mutex init_mutex;
    
    std::string data;
    
    ThreadSafeStatic() : data("thread_safe_data") {
        std::cout << "ThreadSafeStatic initialized" << std::endl;
    }
    
public:
    static ThreadSafeStatic& getInstance() {
        ThreadSafeStatic* temp = instance.load(std::memory_order_acquire);
        if (temp == nullptr) {
            std::lock_guard<std::mutex> lock(init_mutex);
            temp = instance.load(std::memory_order_relaxed);
            if (temp == nullptr) {
                temp = new ThreadSafeStatic();
                instance.store(temp, std::memory_order_release);
            }
        }
        return *temp;
    }
    
    // 防止内存泄漏的清理方法
    static void cleanup() {
        ThreadSafeStatic* temp = instance.load(std::memory_order_acquire);
        if (temp != nullptr) {
            delete temp;
            instance.store(nullptr, std::memory_order_release);
        }
    }
    
    const std::string& getData() const { return data; }
    
    ~ThreadSafeStatic() {
        std::cout << "ThreadSafeStatic destroyed" << std::endl;
    }
};

// 定义静态成员
std::atomic<ThreadSafeStatic*> ThreadSafeStatic::instance = nullptr;
std::mutex ThreadSafeStatic::init_mutex;

5. 现代C++改进方案

5.1 使用std::call_once

#include <mutex>

class CallOnceExample {
private:
    static std::once_flag init_flag;
    static std::unique_ptr<CallOnceExample> instance;
    
    std::string data;
    
    CallOnceExample() : data("call_once_example") {
        std::cout << "CallOnceExample constructed" << std::endl;
    }
    
    static void initializeInstance() {
        instance = std::make_unique<CallOnceExample>();
    }
    
public:
    static CallOnceExample& getInstance() {
        std::call_once(init_flag, initializeInstance);
        return *instance;
    }
    
    const std::string& getData() const { return data; }
    
    ~CallOnceExample() {
        std::cout << "CallOnceExample destroyed" << std::endl;
    }
};

// 定义静态成员
std::once_flag CallOnceExample::init_flag;
std::unique_ptr<CallOnceExample> CallOnceExample::instance;

5.2 使用inline静态成员（C++17）

class InlineStatic {
public:
    // C++17允许inline静态成员定义
    inline static std::string name = "InlineStatic";
    inline static int counter = 0;
    inline static std::vector<int> data = {1, 2, 3, 4, 5};
    
    // 对于需要复杂初始化的场景，仍然建议使用函数
    static const std::string& getComplexData() {
        static const std::string complex_data = initializeComplexData();
        return complex_data;
    }
    
private:
    static std::string initializeComplexData() {
        return "Complex initialization result";
    }
};

// 不需要在类外定义！
void use_inline_static() {
    std::cout << InlineStatic::name << std::endl;
    std::cout << InlineStatic::getComplexData() << std::endl;
}

6. 测试和验证策略

6.1 静态初始化顺序测试

#include <cassert>

class TestDependency {
public:
    static TestDependency& getInstance() {
        static TestDependency instance;
        return instance;
    }
    
    int getValue() const { return 42; }
    
private:
    TestDependency() {
        std::cout << "TestDependency initialized" << std::endl;
    }
};

class TestUser {
public:
    static TestUser& getInstance() {
        static TestUser instance;
        return instance;
    }
    
    bool isInitializedCorrectly() const {
        return dependency_value == 42;
    }
    
private:
    int dependency_value;
    
    TestUser() : dependency_value(TestDependency::getInstance().getValue()) {
        std::cout << "TestUser initialized with value: " << dependency_value << std::endl;
    }
};

void test_static_initialization() {
    auto& user = TestUser::getInstance();
    assert(user.isInitializedCorrectly());
    std::cout << "Static initialization test passed!" << std::endl;
}

6.2 生命周期管理测试

class LifecycleTracker {
private:
    static std::vector<std::string> lifecycle_events;
    
public:
    LifecycleTracker(const std::string& name) {
        lifecycle_events.push_back(name + " constructed");
        std::cout << name << " constructed" << std::endl;
    }
    
    ~LifecycleTracker() {
        lifecycle_events.push_back("destroyed");
        std::cout << "Destroyed" << std::endl;
    }
    
    static void printLifecycle() {
        std::cout << "Lifecycle events:" << std::endl;
        for (const auto& event : lifecycle_events) {
            std::cout << "  " << event << std::endl;
        }
    }
};

std::vector<std::string> LifecycleTracker::lifecycle_events;

class TrackedService {
public:
    static TrackedService& getInstance() {
        static TrackedService instance;
        return instance;
    }
    
private:
    TrackedService() : tracker("TrackedService") {}
    
    LifecycleTracker tracker;
};

void test_lifecycle() {
    auto& service = TrackedService::getInstance();
    // 在程序结束时，LifecycleTracker::printLifecycle()会显示构造和析构顺序
}

7. 最佳实践总结

7.1 静态成员初始化指导原则

// ✅ 推荐的做法
class BestPractices {
public:
    // 1. 对于简单常量，使用constexpr
    static constexpr int BUFFER_SIZE = 1024;
    
    // 2. 对于复杂静态成员，使用局部静态变量
    static const std::string& getConfig() {
        static const std::string config = loadConfig();
        return config;
    }
    
    // 3. 对于单例，使用Meyer's Singleton
    static BestPractices& getInstance() {
        static BestPractices instance;
        return instance;
    }
    
    // 4. 对于需要线程安全复杂初始化的场景，使用call_once
    static std::shared_ptr<SomeResource> getResource() {
        static std::once_flag flag;
        static std::shared_ptr<SomeResource> resource;
        
        std::call_once(flag, []() {
            resource = std::make_shared<SomeResource>();
        });
        
        return resource;
    }
    
private:
    static std::string loadConfig() {
        return "complex configuration data";
    }
    
    BestPractices() = default;
};

// ❌ 避免的做法
class BadPractices {
public:
    static std::string dangerous_static;  // 跨编译单元初始化顺序问题
    
    static BadPractices* instance;  // 需要手动管理生命周期
};

7.2 架构设计建议

场景推荐方案优点
简单常量static constexpr编译期确定，无运行时开销
复杂初始化局部静态变量 + 函数惰性初始化，线程安全
单例模式Meyer’s Singleton简单，安全，自动清理
性能敏感双重检查锁定减少锁开销
现代C++inline static (C++17)简化代码

通过采用这些模式和实践，可以完全避免静态成员变量初始化顺序问题，写出更加健壮和可维护的C++代码。关键是要理解不同初始化方法的生命周期和适用场景，并根据具体需求选择最合适的方案。

本文章已经生成可运行项目
【028】深入理解C++ 类和对象：构造、析构、拷贝构造、初始化列表 详解（最全讲解）
Lion_Long的博客
06-15 1224
C++构造函数是一种特殊的成员函数，用于初始化类的对象。它们具有与类名称相同的名称，并且不返回任何值（包括void）。它们可以带有参数或不带参数，根据需要进行重载。当创建一个类对象时，构造函数会被自动调用。如果没有定义构造函数，则编译器会提供一个默认的构造函数。默认构造函数不执行任何操作，但确保对象被正确初始化。在构造函数中，可以对数据成员进行初始化、分配内存空间和执行其他必要的操作类实例化对象的时候，系统自动调用构造函数，完成对象的初始化。
C++类与对象（四）：再谈构造函数（详解初始化列表）、Static成员
qq_74415153的博客
01-20 1639
1.再谈构造函数 1.1构造函数体赋值 1.2初始化列表 1.2.1格式和概念 1.2.2由来 情况1 情况2 1.2.3特性 1.24特殊情况 1.3explicit关键字 2.static成员 2.1概念与引入 2.2特性
16、C++变量声明与初始化详解
t8u9v0的博客
04-29 68
本文详细介绍了C++中变量声明与初始化的基础概念，包括内置类型和用户自定义类型的声明、变量的多种初始化方式（直接初始化、拷贝初始化、值初始化等）、作用域与生命周期、复合类型初始化以及类对象的初始化等内容。同时，文章还探讨了初始化顺序对程序的影响及最佳实践，帮助开发者编写更高效、可靠的C++代码。
C++静态类型成员变量的初始化顺序（单例模式）
weixin_43862733的博客
04-12 2842
对编译器来说，静态成员变量的初始化顺序和析构顺序是一个未定义的行为 #include <string> #include <iostream> using namespace std; class Base{ public: static int b; static int a; }; int Base::b = 2; int Base::a = b + 1; int main() { Base base; cout <&l
c++笔记 类 static、初始化顺序
tranquilllll的博客
12-13 1376
一.声明为static的类成员称为类的静态成员，用static修饰的成员变量，称之为静态成员变量；用static修饰的 成员函数，称之为静态成员函数。静态的成员变量一定要在类外进行初始化 class Test { private: int m_data; static int m_value; }; int Test:: m_value = 0; 特性 1. 静态成员为所有类对象所共享，不属于某个具体的实例 2. 静态成员变量必须在类外定义，定义时不添加static关键字 3....
C++ 变量初始化顺序
lin的博客
04-12 3409
1.全局变量初始化顺序 什么时候初始化 根据 C++ 标准，全局变量的初始化要在 main 函数执行前完成，常识无疑，但是这个说法有点含糊，main 函数执行前到底具体是什么时候呢？是编译时还是运行时？答案是既有编译时，也可能会有运行时(seriously), 从语言的层面来说，全局变量的初始化可以划分为以下两个阶段（c++11 N3690 3.6.2)： static initialization: 静态初始化指的是用常量来对变量进行初始化,主要包括 zero initialization 和 con
变量初始化顺序（静态变量、成员变量）
mac的博客
04-13 1379
静态局部变量 静态局部变量在程序执行到该对象的声明处时被首次初始化，即以后的函数调用不再进行初始化； 静态局部变量一般在声明处初始化，如果没有显式初始化，会被程序自动初始化为0； 它始终驻留在全局数据区，直到程序运行结束。但其作用域为局部作用域，当定义它的函数或语句块结束时，其作用域随之结束； 静态成员变量 C++中static成员变量的初始化顺序和声明的顺序不一致，和初始化语句的先后顺序...
C++之变量初始化顺序
tormi21c的博客
04-27 786
C++中变量的初始化顺序如下： 1.基类的静态变量或全局变量； 2.派生类的静态变量或全局变量； 3.基类的成员变量； 4.派生类的成员变量； 类成员变量初始化时注意事项： 类成员在定义时不能初始化； 类中const成员常量必须在构造函数初始化列表中初始化； 类中static成员变量，必须在类外初始化； 成员变量在使用初始化列表初始化时，与构造函数中初始化成员列表的顺序无关，只与定义成员变量的顺序有关； 成员变量在构造函数中初始化时，成员变量在构造函数中的顺序有关。 ...
C++中的成员初始化、复制与移动操作详解
# C++ 中的成员初始化、复制与移动操作详解 ## 1. 成员与基类初始化 ### 1.1 成员初始化 在 C++ 里，构造函数能够确立不变量并获取资源，通常借助初始化类成员和基类来达成这一目的。以下是一个用于存储小型组织...
29、类的静态成员详解
metaverse5vr的博客
05-08 373
本文详细介绍了C++中类的静态成员变量和静态成员函数的概念、声明与使用方法，以及它们在实际编程中的应用场景和注意事项。通过实例代码演示了静态成员在实例计数、工具函数、资源共享等方面的应用，并探讨了静态成员的内存模型、生命周期、线程安全性等问题。
构造方法、成员变量初始化以及静态成员变量三者的初始化顺序
qq_65924224的博客
07-18 966
Java类的初始化,八股文。
学习笔记-C# 静态构造函数，静态变量执行顺序
qq_25744257的博客
08-13 2327
一、成员初始化整体顺序 1.成员赋值初始化先于构造函数； 2.成员赋值初始先从子类再到基类； 3.构造函数初始化先从基类再到子类； 4.静态成员初始化优先于实例成员初始化； 二、对类型静态成员构造的大致过程 1.分配静态成员的内存空间，此时空间存储数据为0； 2.执行类的静态成员的初始化语句； 3.执行类的静态构造函数。 三、对类型实例成员构造的大致过程 1.分配实例成员的内存...
类的初始化加载顺序
未见山的博客
02-23 1461
java类及实例初始化顺序 1、静态变量、静态代码块初始化顺序级别一致，谁在前，就先初始化谁。从上而下初始化（只在类加载时，初始化一次） 2、非静态变量、非静态代码块初始化顺序级别一致，谁在前，就先初始化谁。从上而下初始化(只要对象实例化一次，就初始化一次) 3、构造方法在非静态变量、非静态代码块之后执行。 4、子类静态变量、静态代码块在父类的静态变量、静态代码块之后执行。 5、子类非静态变量、非静态代码块在父类构造方法之后执行。 5、子类构造方法在父类构造方法之后执行。 6、静态方法不会被子类重写。 父类
C++静态初始化的顺序
anonymalias的专栏
08-10 8355
这两天项目代码中遇到一个很疑惑的问题，问题可以描述为：一个静态成员初始化的时候直接core掉，该静态成员初始化时通过另外一个文件中静态成员来完成。该问题同样发生在全局对象上。该问题可以描述为今天要讨论的：变量的静态初始化顺序。 具体可以用代码简述如下： //test1.cpp #include  std：：string a = "test";   //test2.cpp #inclu
41. C++static线程安全与初始化顺序
谢谢大家的关注
02-11 1334
但是对于不同的编译单元中的静态变量的初始化顺序，标准没有做规定，也就是说假如两个全局静态变量A和B分别存在与两个.cc文件中，那么编译器对于这俩的初始化顺序是不确定的。
【C++】对象初始化顺序（基类、成员变量等初始化顺序）
最新发布
weixin_43510208的博客
06-21 682
在C++中，对象的初始化顺序遵循严格规则，理解这些规则对避免未定义行为至关重要。
类的初始化以及实例化
qq_45382625的博客
03-22 3993
在类的初始化阶段，虚拟机对类进行初始化,主要对类变量进行初始化。在java中对类变量进行初始化有两种方式： ①声明类变量时指定初始值 ②使用静态初始化块为类变量指定初始化值 声明变量时指定初始值，静态初始化代码块**都被当成类的初始化语句**，他们无先后关系，谁写在前面就先初始化谁。 如果没有在这种方式中对类变量进行显式初始化，他将采用默认初始值（类准备阶段实现）。如下面a=5,b=6,c=0. (这里可以先了解类的声明周期https://zhuanlan.zhihu.com/p/67991761) p
Java静态方法,静态变量,初始化顺序
热门推荐
leeyu35的专栏
07-17 4万+
1. 静态方法：         成员变量分为实例变量和静态变量。其中实例变量属于某一个具体的实例，必须在类实例化后才真正存在，不同的对象拥有不同的实例变量。而静态变量被该类所有的对象公有（相当于全局变量），不需要实例化就已经存在。 方法也可分为实例方法和静态方法。其中，实例方法必须在类实例化之后通过对象来调用，而静态方法可以在类实例化之前就使用。与成员变量不同的是：无论哪种方法，在内存中只有
静态变量初始化：静态变量和静态代码块初始顺序
linhtVV的博客
03-16 5314
在工具类中，通常会初始化一些单例变量，这些变量由于只会初始一次，并不适合放在构造函数中，因此通常选择在静态代码块中执行，那么在一个类中，就会涉及到静态变量和静态代码块的初始化执行顺序问题。 public class Test { private static Test t = new Test(); private static String a = "1"; static {
C++中写一段初始化列表
05-06
**类成员变量初始化顺序仅取决于声明顺序**，与初始化列表顺序无关： ```cpp class Demo { public: // 警告：实际初始化顺序为m_b→m_a（按声明顺序） Demo(int val) : m_a(val), m_b(m_a + 1) {} void print...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值