使用可变模板的与维度无关的类

Question

I've got a scientific library that simulates two and three dimensional engineering problems. The 2D and 3D codes are very similar but handwritten specifically for 2D and 3D problems. For instance a simple point class explicitly has separate implementations in 2D and 3D.

I'm very new to c++11 but based on things I've read about it I have decided to test new features to seamlessly combine these codes into a dimension-independent framework. My first try was writing a simple generic point class as follows:

#include <iostream>

template<unsigned short dim, typename T=double>
class point{
    const T x[dim]; 

public:
    template<typename... X>
    point(X... xs): x{xs...} 
    {
        static_assert(dim>0, "A point needs to at least have one component");
    }

    friend std::ostream& operator<<(std::ostream& os, const point<dim,T>& p)
    {
        os << "(";
        for (unsigned short i=0; i<dim-1; i++)
            os << p.x[i] << ", ";
        os << p.x[dim-1] << ")" << std::endl;

        return os;
    }
};

int main(){
    point<3> p = {3., 4.};
    std::cout << p;
    return 0;
}

which works fine except I have two issues/questions. First and foremost, why do I need to template parameters T and X ? Why cant I tell the compiler to use the same template parameter for the variardic constructor? To me, this seems like a reasonable request!

Second, if I ever try point<2> p = {3, 5}; I get yelled at that narrowing conversion of 'xs#0' from 'int' to 'const double' inside { } [-fpermissive] . Why cant I initialize a double from an integer? I never thought that was illegal. Is this new to c++11 and if so what's the workaround here?

Answer 1

You could use std::initializer_list and use a std::vector instead of an array:

template<unsigned short dim, typename T=double>
class point{
    static_assert(dim>0, "A point needs to at least have one component");
    const std::vector<T> x;

public:
    point(std::initializer_list<T> xs): x{xs} 
    {}

    ...
};

Answer 2

I was able to get around the problem by forcing the compiler to cast inputs back to T :

template<unsigned short dim, typename T=double>
class point{
    static_assert(dim>0, "A point needs to at least have one component");
    const T x[dim]; 

public:
    template<typename... X>
    point(X... xs): x{static_cast<T>(xs)...} {}        
};

Although this is just awkward and I do not understand the rationale behind this change in the standard, this might be useful to someone!