2

第 1 部分：我有一个非常奇怪的情况，在这种情况下，我必须在 main() 之前或在它进入 main() 时立即调用几个类的构造函数。还有另一个子系统需要该数据尽快启动这个子系统的 main() 和更多的东西，这使得这个概念看起来更有用。

我在这里有两种方法：

  1. 在 main() 之前使用全局对象。

  2. 在 main() 的第一行中使用静态类定义。

另一个想法是（因为我使用 gcc）是使用attribute __constructor__gcc 保留功能。

你有什么建议？

第 2 部分：为了进一步解决这个问题，我需要解耦这些类的开发。（这更像是一个代码库设计问题。）

也就是说，如果有人正在编写classA而其他人正在编写classB，那么我们将拥有两个单独的文件，分别是classA和classB，在他们的 files/modules 中定义并调用他们自己的构造函数。

这是一个示例代码，说明了我的想法：

class Init_myclass
{
public:
  Init_myclass(): myvar(10)
  {
    std::cout << __PRETTY_FUNCTION__ << ":" << myvar << std::endl;
  };
private:
  int myvar;
};

static Init_myclass TestInit; //Initializing object prior to main
int main ()
{
  std::cout << __PRETTY_FUNCTION__ << std::endl;
  //Use the data populated by the Init_myclass constructor
  return 0;
}

在上面的代码中，将Init_myclass替换为 100 个类定义，如classA、classB等。

另一种方法是使用文件中的单个构造函数从内部调用其他文件中定义的多个类构造函数。

这是可以帮助您理解我的想法的示例代码：

class InitializeOne
{
public:
  InitializeOne(): myvar(10)
  {
    std::cout << __PRETTY_FUNCTION__ << ":" << myvar << std::endl;
    A bunch of constructors of other classes here();
    classA();
    classB();
    ....
  };
private:
  int myvar;
};

int main()
{
static InitializeOne TestInit;//Object after main
... //functions depending on data populated by Initialize constructor 
}

类的初始化顺序无关紧要，但它们必须在 main 之前或进入 main 时立即初始化。

哪种设计更可取，为什么？

我希望，我让我的问题可以理解。如果没有，请告诉我，我遗漏了哪些信息或过于简单/复杂等。

感谢您的回复和时间。

4

1 回答 1

1

如果可能，您应该选择方法 2。

创建一个单例类：

class InitializeOnce {

public:
    static InitializeOnce& getInstance()
    {
        static InitializeOnce theInstance;
        return theInstance;
    }

    virtual ~InitializeOnce() {}

    classA& getClassA() { return classA_; }
    classB& getClassB() { return classB_; }

private:
    classA classA_;
    classB classB_;

    InitializeOnce()
    : classA_()
    , classB_()
    {
    }

    InitializeOnce(const InitializeOnce& rhs); // Prohibit copying!
    InitializeOnce& operator=(const InitializeOnce& rhs); // Prohibit assigning!
};

...并从 main 访问它一次：

int main()
{
    static InitializeOnce& theInstance = InitializeOnce::getInstance();

    // ... functions depending on data populated by Initialize constructor 
}

在方法 1 的情况下，这将是：

static InitializeOnce& theInstance = InitializeOnce::getInstance();

int main()
{

   // ... functions depending on data populated by Initialize constructor 
}

注意
您提出的方法将导致不同的行为，因为函数局部静态变量保证在至少第一次访问它们之前被实例化，如果您真的需要在调用 main()之前访问它，您必须选择方法 1。

恕我直言，应该避免您的第三个想法，编译器特定的属性定义（即使它是 gcc）将使代码的可移植性降低。

于 2013-02-26T18:33:36.853 回答