3

所以我是 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();
}

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

4

4 回答 4

5

Don't use classes when functions will do fine.

Don't use dynamic allocation using new when automatic storage will work fine.

Here's how you could write it:

#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);
}

I'll recommend reading a good book: The Definitive C++ Book Guide and List

于 2012-12-19T10:37:04.537 回答
2

我的回答将基于您的评论

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

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

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

例如，如果您的 InputObj 中的 a 和 b 在代码开头声明和初始化全局变量，您能否确定除非您愿意，否则值不会在任何给定时间更改？对于简单的程序是的..但是随着程序的扩展，如果您希望保留 a 和 b 的初始状态，您的变量也有可能被无意更改（因此出现一些随机的意外行为），您将不得不这样做它自己（更多临时全局变量？）

  • control通过添加具有类/继承/操作覆盖/多态性/抽象和接口的级别抽象以及使我们的生活更容易构建复杂体系结构的一堆其他概念，您可以获得更多的代码流。

现在，虽然许多人认为全局变量是邪恶的，但我认为如果使用得当，它们是好的和有用的......否则是最好的办法。

我希望这有助于消除传递物体的不安感觉：）

于 2012-12-19T11:44:40.077 回答
1

使用你的方法好不好很大程度上取决于情况。如果你需要一些高速计算，你不能为你的 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
};
于 2012-12-19T11:34:47.300 回答
-3

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

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

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

您应该知道，像这样的全局对象在多线程应用程序中不能很好地工作，但我知道情况并非如此。

您还应该知道，是否应该使用单例来处理这类事情，会有很多讨论。在 SO 或网络上搜索“C++ 单例与全局静态对象”

于 2012-12-19T10:47:08.927 回答