Simple example with templates

Question

This is a simple question, and I am sure that it has been answered before but I cannot seem to find a good answer.

I have a class, Point:

template<class T>
Point{
\\code
}

...and now I want a vector of Points, some of which have T as an integer which have T as a double. I want to write something like

template<class T>
std::vector<Point<T> > points;

But, alas, this doesn't compile with the error "expected primary-expression before 'template'". I haven't been able to fidget with this code to make it work. Also relevant is that points is in the main class, so I can't stick the template declaration outside the function.

If someone could direct me to a solution, I would be much obliged.

Thanks.

Answer 1

If your goal is to have a vector that holds both Point<int> and Point<double> you can use Boost Variant.

typedef boost::variant<Point<int>, Point<double> > VariantPoint;

Then:

std::vector<VariantPoint> my_vector;

my_vector.push_back(Point<int>(1, 0));
my_vector.push_back(Point<double>(1.5f, 2.0f));

Will work. Note that to inspect the elements afterwards, you probably will have to use the visitor pattern as documented here.

If your goal is to have distinct vector types that can only hold one type of Point, then you may use:

template<typename T> using PointVector = std::vector<Point<T>>; // C++11

// Now you can write:
PointVector<int> my_vector;

// Which is equivalent to:
std::vector<Point<int>> my_vector;

Or, if C++11 is not an option:

template<typename T> struct PointVector
{
  typedef std::vector<Point<T> > Type;
}

Then:

PointVector<int>::Type my_vector;

Answer 2

To get a single kind of vector, I would use inheritance:

template <typename T>
struct PointVector : public std::vector< Point<T> >
{
};

Note, the inheritance is just a mechanism to achieve the equivalent of a template typedef. This means, PointVector should not contain any data members or virtual functions. However, @ereOn's suggestion is preferred, and is discussed in the answer to this question.

The old fashioned way to achieve a variant would be to use a union.

class IntOrDouble {
    union {
        int i;
        double d;
    };
    bool is_int;
    bool is_double;
public:
    IntOrDouble () : is_int(false), is_double(false) {}
    IntOrDouble (int x) : is_int(true), is_double(false) { i = x; }
    IntOrDouble (double x) : is_int(false), is_double(true) { d = x; }
    int operator = (int x) {
        is_int = true;
        is_double = false;
        return i = x;
    };
    double operator = (double x) {
        is_int = false;
        is_double = true;
        return d = x;
    };
    operator int () const {
        if (is_int) return i;
        if (is_double) return d;
        return 0;
    }
    operator double () const {
        if (is_double) return d;
        if (is_int) return i;
        return 0;
    }
};
typedef std::vector< Point<IntOrDouble> > PointVector;

But it all seems a little over the top for this use case. I'd just use vectors of double all around, unless memory was really tight.