4

I am trying to solve the Conway's game of life in c++. So according to my design, I have a cell class which contains a list of 8 neighbours, which itself is an object of type cell. Is it ok to do that. The code looks like this

class Cell {
private:
  int position_row_;
  int position_colm_;
  std::shared_ptr<State> state_;

  std::vector<Cell> neighbours_;
};

Now, the other question that is bugging me is, what type of relationship is it. While designing i thought of it to be 'Aggregation'; but now i don't think so. Can someone please clarify?

divine-code
  • 107
  • 2
  • 6
  • Why don't you try it – ha9u63a7 Nov 15 '14 at 16:04
  • Probably you don't want to store the neighbors, but a link to them. Use pointers. – SlySherZ Nov 15 '14 at 16:05
  • No, you can't do that. Cell is an incomplete type until the closing brace of the class definition. You can't instantiate a standard container over an incomplete type. Moreover, you don't want to do that (this would create 8 separate copies of every cell, one in each of that cell's neighbors). – Jerry Coffin Nov 15 '14 at 16:14
  • The way you have implemented it here is composition: the neighbours are parts of the whole (copies) and their lifecycle is linked to the whole (i.e would the cell be destroyed, so would be the members of the array). But with pointers to neighbours you ahv agregation (parts are independent of the whole). – Christophe Nov 15 '14 at 16:29
  • @Christophe Thanks! I knew about aggregation but didn't know both entities can have the same type. – divine-code Nov 15 '14 at 17:20

3 Answers3

4

A class cannot include itself as a data member class C { C c; }; for two reasons:

  1. When you try to define the data member the class is still an incomplete type.
  2. You are creating an endless chain of objects which would require infinite memory.

A class can contain a vector of itself class C { std::vector<C> vec; }; because, like a pointer, a vector declaration only requires that data type has been declared - not defined.

Your code will compile and run but you said your intent was for aggregation which isn't the case:

  • Your code std::vector<Cell> neighbours; is a case of composition because the objects in the vector are owned by the Cell object.
  • Using pointers to other Cell objects std::vector<Cell*> neighbours; would be a case of aggregation because the Cell object would use the objects in the vector but not own them.
Sanders
  • 109
  • 5
  • Thanks! Actually i designed it thinking aggregation but was wrong with the implementation. Moreover, i didn't know both the entities can have the same type, in aggregation or composition. – divine-code Nov 15 '14 at 17:41
3
std::vector<Cell> neighbours;

You are storing copy of neighbours. What if state of any neighbour changes? Do you need that change to be reflected into the vector? If yes, better store the pointers to the neighbours:

std::vector<std::shared_ptr<Cell>> neighbours;
rockoder
  • 747
  • 11
  • 23
1

This is considered to be Reflexive Association. Because it is satisfying following conditions with having its own type has a member variable

The associated object (member) is otherwise unrelated to the object (class)
The associated object (member) can belong to more than one object (class) at a time
The associated object (member) does not have its existence managed by the object (class)

This can lead to a chain of associations The associated object (member) may or may not know about the existence of the object (class)

Bupa
  • 121
  • 3