dumb data object holds all common values c++, is this correct

Question

So I am new to c++ and I'm writing for a scientific application.

Data needs to be read in from a few input text files.

At the moment I am storing these input variables in an object. (lets call it inputObj).

Is it right that I have to pass this "inputObj" around all my objects now. It seems like it has just become a complicated version of global variables. So I think I may be missing the point of OOP.

I have created a g++ compilable small example of my program:

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

Summary of question: A lot of my objects need to use the same variables. Is my implementation the correct way of achieving this.

Answer 1

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

Answer 2

my answer would be based off your comment

"Yea I still haven't got the feel for passing objects around to each other, when it is essentially global variables im looking for "

so this 'feel for passing object' will come with practice ^^, but i think it's important to remember some of the reasons why we have OO,

• the goal (in it simplified version) is to modularise your code so as increase the reuse segment of code. you can create several InputObj without redefining or reassignig them each time
• another goal is data hiding by encapsulation, sometimes we don't want a variable to get changed by another function, and we don't want to expose those variable globally to protect their internal state.

for instance, if a and b in your InputObj where global variable declared and initialized at the beginning of your code, can you be certain that there value doesn't get changed at any given time unless you want to ? for simple program yes.. but as your program scale so does the chances of your variable to get inadvertently changed (hence some random unexpected behavior) also there if you want the initial state of a and b to be preserved , you will have to do it yourself ( more temp global variables? )

• you get more control over the flow of your code by adding level abstractions with classes/inheritances/operation overriding/polymorphisms/Abtract and interface and a bunch of other concepts that makes our life easier to build complex architectures.

now while many consider global variable to be evil, i think they are good and useful when used properly... otherwise is the best way to shoot yourself in the foot.

I hope this helped a bit to clear out that uneasy feeling for passing out objects :)

Answer 3

Is using your approach good or not strongly depends on situation. If you need some high speed calculation you can't provide incapsulation methods for your InputObj class, though they are recommended, because it will strongly reduce speed of calculation. However there are two rules that your can follow to reduce bugs: 1) Carefully using 'const' keyword every time you really don't want your object to modify:

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

2) Moving every action related with initial state of the object(in your case, as far as I can guess, your InputObj is loaded from file and thus without this file loading is useless) to constructor: Instead of:

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

use:

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

Answer 4

You are right that this way you have implemented global variables, but I would call your approach structured, and not complicated, as you encapsulate your global values in an object. This will make your program more maintainable, as global values are not spread all over the place.

You can make this even nicer by implementing the global object as a singleton (http://en.wikipedia.org/wiki/Singleton_pattern) thus ensuring there is only one global object.

Further, access the object through a static member or function. That way you don't need to pass it around as a variable, but any part of your program can easily access it.

You should be aware that a global object like this will e.g. not work well in a multithreaded application, but I understand that this not the case.

You should also be aware that there is a lot of discussions if you should use a singleton for this kind of stuff or not. Search SO or the net for "C++ singleton vs. global static object"