C++ объркан между cast оператор и променлив конструктор

Мисля, че най-простото беше да накарате кода си да работи е да замените оператора за преобразуване с конструктор на преобразуване. Тъй като този конструктор е по-специализиран от променливия конструктор, той винаги трябва да има предимство.

Няма объркване. Конструкторът винаги ще бъде предпочитан пред функция за преобразуване и във вашия случай вашият тип е винаги конструируем от всякакъв вид аргумент. Ето много намален пример:

struct foo {
    template<typename T>
    foo(T t);
}

template<typename T>
foo::foo(T)
{ static_assert( std::is_same<T, int>::value, "" ); }

Обърнете внимание на декларацията на конструктора на шаблона (нарочно отделих декларацията от дефиницията): като се вземе T, всеки вид инициализатор се приема. std::is_constructible<foo, T>::value се отнася за всички T, въпреки че само int ще даде правилна програма. Други типове ще задействат static_assert, когато конструкторът е инстанциран.

Има таен сос за постигане на това, което искате, и името му е SFINAE -- надяваме се, че сте чували за него преди. За да обясня свободно (в случай, че не сте), ако преместите потенциална грешка от тялото на шаблона някъде в декларацията, тогава специализациите, които биха довели до такава грешка, ще бъдат отхвърлени в процеса на разрешаване на претоварване. За да го поставите в код:

struct foo {
    template<
        typename T
        , typename std::enable_if<
            std::is_same<T, int>::value
            , int
        >::type...
     >
     foo(T t);
};

което би било SFINAE версията на предишния измислен пример. С такава декларация тогава нещо като foo f = 42.; няма да доведе до същия вид грешка, както преди. Компилаторът би се оплакал напр. че няма подходящо преобразуване от double в foo, сякаш конструкторът изобщо не съществува. Това е, което искаме, защото ако не съществува такъв конструктор, тогава правилата диктуват, че ще се търси подходящ оператор за преобразуване. (Е, не че е голяма помощ в случая с double, но няма значение.)

Обърнете внимание, че има няколко начина да използвате SFINAE и този се оказа любимата ми форма. Можете да намерите други, като научите за SFINAE. (И за протокола не е толкова страшно с правилното използване на шаблонни псевдоними, където в крайна сметка изглежда като EnableIf<std::is_same<T, int>>....)

Направете своя конструктор ясен и използвайте:

vec4 someVec4; 
// ....
vec3 someVec3 = someVec4;

Разглеждайки вашия SSCCE, има някои стъпки за почистване, които можете да приложите.

Големият проблем с шаблона на универсален конструктор е, че той съвпада с всичко, освен ако конструктор без шаблон е точно съвпадение. Ако грешите дори с cv-квалификация, ще бъде избран шаблонът на универсалния конструктор. Когато имах подобен проблем, ми беше предложено да добавя стойност за маркиране като първи параметър:

enum my_marker { mark };
//...
template<typename T, unsigned int N>
class Vector
{
    //...
    template<typename ... Args>
    explicit Vector(my_marker, Args ... args);
};
//...
Vector<int, 4>  va( mark, a1, a2 );

Вашите други конструктори няма да използват този маркер, така че сега можете да ги правите разлика. Между другото, имате друго припокриване с конструкторите, които могат да приемат T стойност:

template<typename T, unsigned int N>
class Vector
{
    //...
    Vector( T empty );
    Vector( std::initializer_list<T> set );
    //...
};
//...
Vector<int, 4>  vb{ 5 };  // always chooses the list ctr
Vector<int, 4>  vc( 6 );  // I think this uses the single-entry ctr.

Когато имате масив като аргумент на функция, той ще се третира като указател по подразбиране, игнорирайки всякаква информация за оразмеряване. Трябва да го предадете по препратка, ако трябва да запазите размера:

template<typename T, unsigned int N>
class Vector
{
    //...
    Vector( T const (&set)[N] );  // "T set[N]" -> "T *set"
    //...
};
//...
int             aa[ 4 ] = { 1, 2, 3, 4 }, bb[ 3 ] = { 5, 6, 7 };
Vector<int, 4>  vd( aa );  // The new signature won't accept bb.

Това преобразуване от масив към указател предотвратява прякото присвояване на масиви, но те са неявно присвоими при изчисляване на специалните функции. Това означава, че вашият оператор за присвояване не е необходим; кодът по подразбиране ще направи правилното нещо.

Чували ли сте за итератори? Ако е така, тогава използването на тези плюс делегиращи конструктори, стандартни алгоритми и инициализатори може да намали вашия код.

#include <algorithm>
#include <cassert>
#include <initializer_list>

enum mark_t  { mark };

template< typename T, unsigned N >
class Vector
{
    // The "set" functions are unnecessary, see below.
public:
    // The automatically defined copy-ctr, move-ctr, copy-assign, and
    // move-assign are OK.

    T elements[N];

    Vector()  : elements{}  {}
    // Vector()  : Vector( T{} )  {}  // ALTERNATE
    // Can be removed if following constructor uses a default argument.

    Vector(T empty)
    // Vector(T empty = T{})  // ALTERNATE
    { std::fill( elements, elements + N, empty ); }

    Vector(T const (&set)[N])
    { std::copy( set, set + N, elements ); }

    Vector(std::initializer_list<T> set)
        : elements{}
    {
        assert( set.size() <= N );
        std::copy( set.begin(), set.end(), elements );
        // If you were willing to use std::for_each, why not use a more
        // appropriate algorithm directly?  The lambda was overkill.
        // WARNING: there's an inconsistency here compared to the cross-
        // version constructor.  That one fills unused spots with ones,
        // while this one does it with zeros.
        // WARNING: there's an inconsistency here compared to the single-
        // value constructor.  That one fills all elements with the same
        // value, while this one uses that value for the first element but
        // fills the remaining elements with zeros.
    }

    template<typename ... Args>
    explicit Vector( mark_t, Args ... args)
        : elements{ args... }
        //: elements{ static_cast<T>(args)... }  // ALTERNATE
    {}
    // Array members can now be directly initialized in the member part
    // of a constructor.  They can be defaulted or have each element
    // specified.  The latter makes the private "set" methods unnecessary.
    // The compiler will automatically issue errors if there are too
    // many elements for the array, or if at least one "Args" can't be
    // implicitly converted to "T", or if you have less than "N" elements
    // but "T" doesn't support default-initialization.  On my system, the
    // example "main" flags int-to-float conversions as narrowing and post
    // warnings; the alternate code using "static_cast" avoids this.

    template < unsigned R >
    explicit Vector( Vector<T, R> const &v )
        : Vector( static_cast<T>(1) )
    { std::copy( v.elements, v.elements + std::min(R, N), elements ); }

    T &operator [](unsigned int param)
    { return this->elements[param]; }
    const T &operator [](unsigned int param) const
    { return this->element[param]; }
};

typedef Vector<float, 2> vec2;
typedef Vector<float, 3> vec3;
typedef Vector<float, 4> vec4;

int main()
{
    vec4 someVec4(mark, 1, 2, 3, 4);
    vec3 foo = static_cast<vec3>(someVec4);

    return 0;
}