CODEWITHSUNDEEP
c++
Daniel Uspensky
Daniel Uspensky

Reputation: 168

How to exchange data between classes?

I'm learning C++ and moving my project from C to C++. In the process, I stumbled on this problem: how to save/update variables that are in use in several classes? In C I used global variables, but it is not good for C++.

So, let's assume we have 4 classes:

class Main_Window
{
    //...
    void load_data_menu_selected();
}

class Data
{
    //...
    double *data;
}

class Load_Data
{
    //...
    double *get_filename_and_load();
}

class Calculate
{
    //...
    int do_calculation()
}

So, Main_Window is class for application's main window where it interacts with user input etc.
I want to do:

  • create an instance of class Data in the Main_Window
  • use Load_Data for loading data from file and store it in the Data
  • use Calculation class for doing something with read data in Data class

    • The question is: where I should create classes, to make Data class members available from other classes. Should I use Inheritance?

    Upvotes: 7

    Views: 11239

    Answers (5)

    axw
    axw

    Reputation: 7083

    It sounds like you should not use inheritance here. The main reason for saying so is that you have a number of classes (Window, Calculator, etc.) using or doing something to an entity (i.e. Data). Inheritance is used to denote an "is a" relationship (i.e. if A inherits from B, A "is a" B).

    In this case, you use composition, which denotes a "has a" relationship. So each class takes a reference to an instance of Data, and acts upon that object.

    Who owns the Data object? To share a single Data object, you might want to look into Boost shared_ptr, which allows multiple reference-counting pointers to share an object allocated with "new".

    Upvotes: 0

    BЈовић
    BЈовић

    Reputation: 64203

    You need to know how to design in OO. Thinking in C is different from thinking in c++. You can that your classes have many methods. Well, that sound like a bad design.

    I can recommend you to start with the SOLID principle. Then start writing unit tests for your classes. TDD could help you improve your design even further.

    Upvotes: 0

    Bojan Komazec
    Bojan Komazec

    Reputation: 9526

    Start from observing what are possible relations between instances of two classes. Let us say a is an instance of class A and b is an instance of class B. If a uses b, class A can have as its member instance of class B (b), pointer to b (which is of type B*), or reference of b (which is of type B&). If only one method of class A uses b, you have again same three options: B, B* or B& can be method's arguments. Having B* and B& as class members suggests that a does not control b's lifetime so class A must have a method that sets these members through its parameters. The question of ownership (objects' lifetimes) has a big role in design of relationship between classes. Main relationships are briefly described in this article.

    Upvotes: 2

    Puppy
    Puppy

    Reputation: 146910

    Typically, you would pass (const) Data& around as an argument. If do_calculation() needs a Data to work with, then it takes Data&. But I can't really be more specific or useful unless you post more of your design.

    Upvotes: 1

    Matt
    Matt

    Reputation: 3848

    I think you only want to have a Main_Window class, and the rest should be members of that class.

    class Main_Window
{
 private:
 DataObject windowData;

 public:
 void loadData(string fileName);
 void calculate();
}

    Inside the loadData and calculate methods, you will be able to access the same data with this->windowData . Sorry if my syntax is bad, my c++ is rusty

    Upvotes: 1

    Related Questions