Question

目前我从Java切换到C ++，这让我很难（但很多新的体验^^）。我正在编写一些包含我的程序配置的数据传输对象。我写了一些类，现在我想要一个类似于容器的类。

以下是容器的标题：

class MyContainer{

public:
MyContainer();
virtual ~MyContainer();

Config getConfig(TypeEnum type) {
    switch (type) {
    case ATYPE:
        return config_a;
    case BTYPE:
        return config_b;
    default:
        break;
    }

}

ConfigA config_a;
    ConfigB config_b;
};

配置中包含一些数据，并从另一个配置文件派生。

这是C ++ - 来源：

 MyContainer::MyContainer(){
  ConfigA config_a(int c = 1);
  ConfigB config_b(double b = 2.1);
  this->config_a = config_a;
  this->config_b = config_b;
}

我认为有几个问题。但对我来说，主要的问题是： 如何在此容器中获取这些配置以将其共享给我的程序的其他模块？我试图将config_a设置为指针，但我总是收到这些类型不匹配的错误消息。

 this->config_a = &config_a; //If ConfigA config_a; was ConfigA *config_a; instead

如果您还有一分钟的话，请告诉我getConfig - 方法是否可以这样工作。

如果还有另一个主题，请分享。感谢。

Answer 1

如果在标题中写入ConfigA configA，则在分配容器类时会自动分配configA。所以你不必像下面这样初始化它：
```
ConfigA config_a(1);
this->config_a = config_a;
```
相反，您可以执行以下操作：
```
this->config_a->value = 1;
```
无需撰写：
```
ConfigA config_a(int c = 1);
```
简而言之，提到的int c = 1是一项操作，其中包括：
- 在堆上为临时变量c分配空间（这也可以在输入方法时完成）
- 为其指定值，这会产生返回右侧值的副作用
- 返回的右侧值应用于ConfigA构造函数。
要理解这一点，请尝试以下方法：
```
int a, b, c;
c = (a = 2) + (b = 8);
printf("a = %d, b = %d, c = %d\n", a, b, c);
```
如果要将配置传递给其他模块，可以选择以下解决方案之一：

a）接受configs作为引用（配置类必须派生自相同的基类）：
```
ConfigA & configA = dynamic_cast<ConfigA &>(container.get_config(ATYPE));
```
在这种情况下，容器应按以下方式返回配置：
```
return this->configA;
```
但是标题应该被修改：
```
Config & getConfig(TypeEnum type) { (...)
```
b）接受配置作为指针（与上面相同）
```
ConfigA * configA = dynamic_cast<ConfigA *>(container.get_config(ATYPE));
```
在这种情况下，容器应按以下方式返回配置：
```
return &(this->configA);
```

最后，这就是我的方式：

class ConfigA
{
private:
    int i;

public:
    int GetI() const { return i; }
    void SetI(int newI) { i = newI; }
};

class ConfigB
{
private:
    float f;

public:
    float GetF() const { return f; }
    void SetF(float newF) { f = newF; }
};

class Config
{
private:
    ConfigA configA;
    ConfigB configB;

public:
    ConfigA & GetConfigA() { return configA; }
    ConfigB & GetConfigB() { return configB; }
};

class AppContext
{
private:
    Config config;

public:
    Config & GetConfig() { return config; }
};

// Somewhere in the code

Config & config = context.GetConfig();
ConfigA & configA = config.GetConfigA();
configA.SetI(44);

const-correctness也值得一提，但我们将把它作为OP的练习;）

Answer 2

您的代码：

ConfigA config_a(int c = 1);

表示返回ConfigA的函数原型，并使用默认值为1的int。但是如果你从表达式中分离int声明，它将改为其他东西：

int c;
ConfigA config_a(c = 1); //  This is construction of a ConfigA object

我会像这样编写构造函数：

MyContainer::MyContainer(int c = 1, double d = 2.1)
 :    config_a (c), config_b (d)  //  Construct the members in the intialization line
{
}

如果要共享指向这些成员的指针，请返回如下指针：

ConfigA * MyContainer::GetConfigA(){return &config_a;}
ConfigB * MyContainer::GetConfigB(){return &config_b;}

但是如果你想使用指针成员：

 MyContainer::MyContainer(int c = 1, double d = 2.1)
 :    pConfig_a (new ConfigA (c)), pConfig_b (new ConfigB (d))
{
}


ConfigA * MyContainer::GetConfigA(){return pConfig_a;}
ConfigB * MyContainer::GetConfigB(){return pConfig_b;}


 MyContainer::~MyContainer()
{
    delete pConfig_a;
    delete pConfig_b;
}

C ++容器类

2 个答案: