相关疑难解决方法(0)

根据其他来源的资料，C++区分了两种静态变量的初始化：

• static - 如果变量是通过将其置于可执行文件中的特殊部分的初始值中来初始化的。

• 动态 - 如果静态变量的初始值也已计算

关于动态初始化构造函数调用的顺序有很多讨论。但是我没有找到有关如何等到可执行文件中所有静态变量的所有动态初始化完成的信息。或者从另一方面如何以间接/通用方式手动调用此初始化。

我使用静态变量初始化来实现插件架构的松散耦合。我有 plugin1.c, plugin2.c ... 和plugin1.c static bool installed = plugin1_install();里面的静态变量

但在主要我需要等到所有插件安装。

这里建议了我使用的相同内容1。作为以下问题的答案

我想为我的程序编写一个共享库。但是，在调用库中的任何其他函数之前，我需要库具有一些自初始化例程...

回答：

C++ 本身支持事物的全局初始化。您可以执行以下操作：

int global_variable=some_global_function();

这在 C 中是非法的，但在 C++ 中是合法的。

我可以在 的帮助下实现我需要的功能__CTOR_LIST__吗？

假设我有以下文件:

LIB /阿

#ifndef A_H
#define A_H

#include <vector>

class A {
        public:
                static int add( int x );
                static int size();
        private:
                static std::vector<int> vec;
};

#endif

LIB/A.cpp

#include "A.h"

std::vector<int> A::vec;

int A::add( int x ) {
        vec.push_back( x );
        return vec.size();
}

int A::size() { 
        return vec.size();
}

LIB/BH1

#ifndef B_H
#define B_H

class B {
        public:
                static const int val = 42;
};

#endif

LIB/B.cpp

#include "B.h"
#include "A.h"

int tempvar = A::add( B::val );

最后:主要:cpp …

我想避免为需要的Id所有类分配一个Id,所以我写了一个小的模板化id生成器.

BaseIdGenerator::makeUniqueId只需返回一个新的Id,每次调用它:

class BaseIdGenerator {
protected:
    static inline Id makeUniqueId() {
        static Id nextId = 0;
        return nextId++;
    }
};

为了分配Id给各个类,该类只是作为模板参数传递给IdGenerator:

template <typename T>
Id getId();

template <typename T>
class IdGenerator final : public BaseIdGenerator {
    static Id id;

    template <typename Type>
    friend Id getId();
};

template <typename T>
inline Id getId() {
    return IdGenerator<T>::id;
}

template <typename T>
Id IdGenerator<T>::id = IdGenerator<T>::makeUniqueId();

这将makeUniqueId()每个类调用一次(即使在C++ 11以来的多线程应用程序中,由于线程安全的本地静态变量)

在行动中,这看起来像这样:

int …

在C++中,单例中的所有成员都可以是静态的,还是尽可能的？我的想法是,无论如何全球只有一个例子.

在搜索时我确实在C#中找到了很多关于静态类的讨论,但对此并不熟悉.想了解它.

无论你有什么想法,请评论.

以下案例怎么样？如果存在依赖关系,编译器是否可以正确处理静态变量的初始化顺序？

啊

template<class T>
struct A { static double a; };

template<class T>
double A<T>::a = 1;

BH

struct B { static double b; };

b.cpp

#include "b.h"
#include "a.h"

double B::b = A<int>::a;

在这样的代码中：

#include <iostream>

template<int I>
struct A {
    static constexpr int I1 = I + 1;
    static constexpr int I2 = I1 + 1;
};

int main() {
    std::cout << A<1>::I1 << " " << A<1>::I2 << std::endl;
}

是否可以安全地假设I2将正确初始化，即I1之前已初始化I2？

在这里说明了

C++保证编译单元(.cpp文件)中的变量按声明顺序初始化

这对C来说是一样的吗？

你能引用C和C++的相关标准段落吗？

我读了这个,我想不出X::_x在文件初始化之前将使用的场景X.cpp(假设编译器对待X.h并且X.cpp一个接一个)

有人可以向我解释这种情况会怎样吗？