Question

所以我是c ++的新手，我正在为科学应用而写作。

需要从几个输入文本文件中读取数据。

目前我将这些输入变量存储在一个对象中。（我们称之为inputObj）。

我现在必须在我的所有对象周围传递这个“inputObj”是对的。看起来它刚刚成为全局变量的复杂版本。所以我想我可能会忽略OOP的观点。

我创建了一个g ++可编译的程序小例子：

#include<iostream>

class InputObj{
// this is the class that gets all the data
public:
void getInputs() {
    a = 1;
    b = 2;
};
int a;
int b;
};

class ExtraSolver{
//some of the work may be done in here
public:
    void doSomething(InputObj* io) {
        eA = io->a;
        eB = io->b;
        int something2 = eA+eB;
        std::cout<<something2<<std::endl;
    };  
private:
    int eA;
    int eB;

};

class MainSolver{
// I have most things happening from here

public:
void start() {
    //get inputs;
    inputObj_ = new InputObj();
    inputObj_ -> getInputs();
    myA = inputObj_->a;
    myB = inputObj_->b;

    //do some solve:
    int something = myA*myB;

    //do some extrasolve
    extraSolver_ = new ExtraSolver();
    extraSolver_ -> doSomething(inputObj_);

};
private:
InputObj* inputObj_;
ExtraSolver* extraSolver_;
int myA;
int myB;


};


int main() {
MainSolver mainSolver;
mainSolver.start();
}

问题摘要：我的很多对象都需要使用相同的变量。我的实施是否是实现这一目标的正确方法。

Answer 1

当功能正常时，不要使用课程。

当自动存储工作正常时，不要使用new使用动态分配。

这是你怎么写的：

#include<iostream>

struct inputs {
    int a;
    int b;
};

inputs getInputs() {
    return { 1, 2 };
}

void doSomething(inputs i) {
    int something2 = i.a + i.b;
    std::cout << something2 << std::endl;
}

int main() {
    //get inputs;
    inputs my_inputs = getInputs();

    //do some solve:
    int something = my_inputs.a * my_inputs.b;

    //do some extrasolve
    doSomething(my_inputs);
}

我建议您阅读一本好书：The Definitive C++ Book Guide and List

Answer 2

我的回答将基于您的评论

“是的，我仍然没有感觉到将对象传递给对方，当它本质上是全局变量我正在寻找”

所以这种“传递对象的感觉”将来自练习^^，但我认为记住我们拥有OO的一些原因很重要，

目标（简化版本）是modularise您的代码，以便增加reuse代码段。你可以创建几个InputObj，而无需每次重新定义或重新分配它们
另一个目标是data hiding封装，有时我们不希望变量被另一个函数更改，我们不希望全局公开这些变量以保护其内部状态。

例如，如果您的InputObj中的a和b在代码开头声明并初始化全局变量，您是否可以确定除非您愿意，否则在任何给定时间都不会更改值？对于简单的程序是..但是因为你的程序规模如此，你的变量无意中被改变的可能性（因此一些随机的意外行为）如果你想保留a和b的初始状态，那么你必须自己做（更多临时全局变量？）

通过添加类/继承/操作覆盖/多态/ Abtract和接口以及一系列使我们的生活更容易构建复杂体系结构的其他概念，您可以在代码流中获得更多control。

现在虽然许多人认为全球变量是邪恶的，但我认为如果使用得当它们是好的和有用的......否则就是用脚射击自己的最好方法。

我希望这有助于清除那种传递物体的不安情绪：）

Answer 3

使用您的方法是否取决于具体情况。如果您需要高速计算，则不能为InputObj类提供封装方法，但建议使用它们，因为它会大大降低计算速度。但是，您可以遵循两个规则来减少错误： 1）每次你真的不想要你的对象修改时，小心使用'const'关键字：

  void doSomething(InputObj * io) -> void doSomething(const InputObj * io)

2）移动与对象的初始状态相关的每个动作（在你的情况下，据我所知，你的InputObj是从文件加载的，因此没有这个文件加载是没用的）到构造函数：而不是：

InputObj() { }
void getInputs(String filename) {
    //reading a,b from file
};

使用：

InputObj(String filename) {
    //reading a,b from file
};

Answer 4

你是对的，你已经实现了全局变量，但是当你将全局值封装在一个对象中时，我会称你的方法是结构化的，而不是复杂的。这将使您的程序更易于维护，因为全局值不会遍布整个地方。

通过将全局对象实现为单例（http://en.wikipedia.org/wiki/Singleton_pattern），您可以更好地实现这一点，从而确保只有一个全局对象。

此外，通过静态成员或函数访问对象。这样您就不需要将其作为变量传递，但程序的任何部分都可以轻松访问它。

您应该知道像这样的全局对象将是例如在多线程应用程序中运行不正常，但据我所知，情况并非如此。

你还应该知道，如果你应该使用单身人士来做这种事情，那么会有很多讨论。在SO或网上搜索“C ++ singleton vs. global static object”

哑数据对象包含所有常见值c ++，这是正确的

4 个答案: