deriving and 'overloading' of an attribute

[jabbah]

What I want to do is something like this:

class A{
  protected:
    vector<int> data;
  public:
    doit(){
      // work on the onedimensional data
    }
}
 
class B : class A {
  protected:
    vector<vector<int>> data; // overload the data
  public:
    doit(){
      // work on the twodimensional data
    }
}
 

So in B one of the members (data) of A is replaced and those methods that work on data have to be changed, but A and B still do have a lot in common (unlike from what my minimal example shows)

I have started to implement it this way and it does work, but I feel that this is no good design, since both versions of the attribute data do exist in an instance of B. I would rather want to somehow really replace the onedimensional version. I was thinking of maybe adding an assertion in B to ensure that the A::data is not initilized, but thats only an ugly hack and no solution. I guess that this is not such an infrequent problem, only I could not find any useful answers myself.

I hope my question is understandable and I'd be glad if someone could point me in the right direction.

[Ganon11]

I don't think it's possible to overload a data member - in other words, your current implementation (having both B::data and A::data present in B) may be your only implementation possible. You could make A::data private so that B is unaware of its existence, but I think it will still exist.

[weaknessforcats]

Do keep in mind that a vector<int> can have any dimensions you need.

For example, if there are 12 ints in the vector, you could say that it is an array of [12] or an array [6][2] or an array [4][3] or an array [2][2][3]. You manage the dimensions by using iterators.

You just need the one vector<int> in the base class. The iterators for the dimensions can be in the derived classes.

[jabbah]

thanks ganon11 and weaknessforcats and sorry for answering so late - was away from work.


a friend has suggested that I could make another class C which has the common things and then A and B each derive directly from C. ( Now that I wrote it down it sounds so easy that I guess that was what I was looking for. )


still I'm puzzling with this:

Do keep in mind that a vector<int> can have any dimensions you need.

For example, if there are 12 ints in the vector, you could say that it is an array of [12] or an array [6][2] or an array [4][3] or an array [2][2][3]. You manage the dimensions by using iterators.

You just need the one vector<int> in the base class. The iterators for the dimensions can be in the derived classes.

That sounds as if you would suggest that I could remove line 12 of the code above and somehow manage to write data[i][j] inside of B::doit(). That can't possibly work, can it? I dont get what you mean.

[weaknessforcats]

I dont get what you mean.

Assume the vector<int> is in the base class.

Let's assume I want to use it as a 2D int array of [4][3].

I derive a class MyClass from class A. Inside MyClass are row and col variables

Suppose I want row 2 col 1.

Row 2 is 3 * 2 or 6.

Col 1 is 1.

So element [2][1] is 6 + 1 or element [7] in the vector.

It's the same calculation the compiler makes to get the element [2][1] when you use the address of element 0 as the starting point.

Read this:

First, there are only one-dimensional arrays in C or C++. The number of elements in put between brackets:

int array[5];
 

That is an array of 5 elements each of which is an int.

int array[];
 

won't compile. You need to declare the number of elements.

Second, this array:

int array[5][10];
 

is still an array of 5 elements. Each element is an array of 10 int.

int array[5][10][15];
 

is still an array of 5 elements. Each element is an array of 10 elements where each element is an array of 15 int.

int array[][10];
 

won't compile. You need to declare the number of elements.

Third, the name of an array is the address of element 0

int array[5];
 

Here array is the address of array[0]. Since array[0] is an int, array is the address of an int. You can assign the name array to an int*.

int array[5][10];
 

Here array is the address of array[0]. Since array[0] is an array of 10 int, array is the address of an array of 10 int. You can assign the name array to a pointer to an array of 10 int:

int array[5][10];
 
int (*ptr)[10] = array;
 

Fourth, when the number of elements is not known at compile time, you create the array dynamically:

int* array = new int[value];
int (*ptr)[10] = new int[value][10];
int (*ptr)[10][15] = new int[value][10][15];
 

In each case value is the number of elements. Any other brackets only describe the elements.

Using an int** for an array of arrays is incorrect and produces wrong answers using pointer arithmetic. The compiler knows this so it won't compile this code:

int** ptr = new int[value][10];    //ERROR
 

new returns the address of an array of 10 int and that isn't the same as an int**.

Likewise:

int*** ptr = new int[value][10][15];    //ERROR
 

new returns the address of an array of 10 elements where each element is an array of 15 int and that isn't the same as an int***.

With the above in mind this array:

int array[10] = {0,1,2,3,4,5,6,7,8,9};
 

has a memory layout of

0 1 2 3 4 5 6 7 8 9

Wheras this array:

int array[5][2] = {0,1,2,3,4,5,6,7,8,9};
 

has a memory layout of

0 1 2 3 4 5 6 7 8 9

Kinda the same, right?

So if your disc file contains

0 1 2 3 4 5 6 7 8 9

Does it make a difference wheher you read into a one-dimensional array or a two-dimensional array? No.

Therefore, when you do your read use the address of array[0][0] and read as though you have a
one-dimensional array and the values will be in the correct locations.

[jabbah]

ok, got it. thanks weaknessforcats.

[bfoo75]

you could always make an abstract base class:

 
class base {
  public:
    virtual void doit() = 0
}
 
class A : class base {
  protected:
    vector<int> data;
  public:
    doit(){
      // work on the onedimensional data
    }
}
 
class B : class base {
  protected:
    vector<vector<int>> data; // overload the data
  public:
    doit(){
      // work on the twodimensional data
    }
}
 
 

[weaknessforcats]

class base {
public:
virtual void doit() = 0
}

class A : class base {
protected:
vector<int> data;
public:
doit(){
// work on the onedimensional data
}
}

class B : class base {
protected:
vector<vector<int>> data; // overload the data
public:
doit(){
// work on the twodimensional data
}
}

The whole point is to not overload the data.

[jabbah]

you could always make an abstract base class

Yeah and I think thats just plainly the right thing (tm) to do in this situation and I was just caught somewhere in my thinking and couldnt find the base class (not necessarily abstract) in my head.

The whole point is to not overload the data.

Right, I felt uncomfortable with my first attempt and I was just wondering whether there was something wrong with my approach of overloading data, or whether thats something one should avoid at all.


Regarding your suggestion:

if there are 12 ints in the vector, you could say that it is an array of [12] or an array [6][2] or an array [4][3] or an array [2][2][3].

Im not going to do this in my current situation, but I'll try to keep it somewhere in my brain. - its an interesting idea.

thanks anybody