C++ design - vector classes with different element types

Question

I am trying to design a group of related classes. For example:

• one table class holds a vector of integer, and has a function returning integers from the vector
• another table class holds a vector of double, and has a function returning doubles from the vector

Ideally I'd like to have the two classes share the same pointer type, and have the same interface so that they can constructed, and used in a similar way by client. The only difference is that one class is expected to return integer, and the other double.

I have read a few books on design patterns, and I understand the difference between inheritance vs composition. Though I am still a beginner on class design and I suspect I missed something obvious. Below are my questions:

1. Is it a good practice to have undefined data member or function members? In the sample coding below. The child class will define only part of the data and function member from the base class.
2. Ideally I would like to have a common interface between the two child classes. however, since function get_value1 from one class returns integer, the other get_value2 from another class returns double, I have to give them a different function name. This is not critical, but can it be avoided?
3. Should I avoid inheritance and simply create two different classes? especially when the two classes do not share the same user interface?

 

class Base_Table
{
    std::vector<int> vec_int_;
    std::vector<double> vec_dbl_;
    virtual int get_value1(int);
    virtual double get_value2(int i);
};

class Int_Table : public Base_Table
{
    std::vector<int> vec_int_;
    virtual int get_value1(int i) override
    {
        return vect_int_[i];
    }
 };

class Frac_Table : public Base_Table
{
    std::vector<double> vec_dbl_;
    virtual double get_value2(int i) override
    {
        return vect_int_[i];
    }
};

Answer 1

Create a template class. Your use-case is why templates were created. For your example this is quite simple:

template <class T> 
class Table
{
    std::vector<T> vec;
    T get_value(int i) const { 
        return vec[i];
    }
}

But why are you using "get_value" instead of defining operator[] like this:

    T operator[](int i) const {
         return vec[i];
    }

Answer 2

C++ design - vector classes with different element types

It looks like you want to have some sum type or tagged union. Perhaps you want to use std::variant.

Notice that most containers are homogeneous. In particular, all components of a std::vector have the same type (so stricto sensu your question does not make any sense). But that type could of course be a tagged union.

It is unclear if you want a vector of tagged unions (e.g. std::vector<std::variant<int,float>> ...), or a tagged union of vectors (like std::variant<std::vector<int>,std::vector<float>>). These are different!

You could also have your own class containing some union (and implement your tagged union above that). Then you need to follow the rule of five.

You might also use placement new and manage some memory yourself.

^{(what you really want to do is actually unclear; please reason by specifying precisely some abstract data type, e.g. the signature of the desired class - its public member functions - and its behavior)}

Notice that int and double are different and somehow incompatible POD types. They generally have different sizes, different alignments, and are handled differently (e.g. sit in different processor registers; so the ABI needs to know about them). So casting between int and double usually requires some conversion (at the machine level) and is not "free" (takes at least one machine instruction, and could lose information). and an aligned sequence of bytes has different meaning when considered as an array of int and an array of double...

Answer 3

Inheritance does not apply. You could do it with a so called template class but I would not recommend it. If T is a value type like in your case you typically want to perform arithmetic operations on it and these do not work well with T. So you would be better of treating integer tables as different from float tables and have different, dedicated and independent classes for them. That only share methods names for readability/consistency.

Edit: Apparently, as pointed out by Kevin, the particular limitation described above does not apply to C++ (it is valid for C#). You would still want to consider whether all the operations you are going to implement will be meaningful for integers and floating type numbers alike though. This may be hard to foresee. I mean, the "smart" solution may bite you in the arse later.

If for instance, if you needed to create an operation that will give you the average value in a column, that would require you to apply some rounding logic if you were dealing with integers. But not if you were dealing with floats. You would not be so happy with your fancy template solution at that point.