Question

let’s say I want my users to use only one class, say SpecialData.
Now, this data class would have many methods, and depending on the type of data, the methods do different things, internally, but return externally similar results. Therefore my wanting to have one “public” class and other “private”, child classes that would change the behavior of methods, etc…

It would be amazingly more simple for some types of data that need to be built to do something like this:

SpecialData& sm = SpecialData::new_supermatrix();

and new_supermatrix() would return a SuperMatrix instance, which inherits from most behaviors of SpecialData.

my header:

static SpecialData& new_supermatrix();

my cpp:

SpecialData& SpecialData::new_supermatrix()(){
  return SuperMatrix(MATRIX_DEFAULT_MAGNITUDE,1000,1239,FLOAT32,etc...);
}

The problem is, I get this error, which is probably logical due to the circumstances:

invalid initialization of non-const reference of type ‘SpecialData&’ from a temporary of type ‘SpecialData’

So, any ideas?

Answer 1

Well, you’ve got three choices:

a) You want to have only one instance of SuperMatrix anyway. Then go for the static function member route as has already been suggested.

b) You want to create multiple instances. Then you have to return a pointer instead of references and create the objects with with new (i.e. return new SuperMatrix(...).

c) As an alternative to option b, you can also return merely an object, i.e.

SpecialData SpecialData::new_supermatrix()(){
return SuperMatrix(MATRIX_DEFAULT_MAGNITUDE,1000,1239,FLOAT32,etc...);
}

However, this requires a (deep-)copy operator (the default one won’t suffice more often than not), and it means that the object is created on the stack, then copied and that copy is being returned. The good thing is, this won’t leak memory if you don’t actually receive the result into a variable. The bad thing is, if the object is very large, this can be very memory- and time-consuming.

Whatever you are going to do with it, these solutions are mutually exclusive, both technically and logically. 😉