С++ запутался между оператором приведения и вариативным конструктором

Я думаю, что проще всего заставить ваш код работать, заменив оператор преобразования конструктором преобразования. Поскольку этот конструктор является более специализированным, чем конструктор с переменным числом аргументов, он всегда должен иметь приоритет.

Нет никакой путаницы. Конструктор всегда будет предпочтительнее функции преобразования, и в вашем случае ваш тип всегда может быть создан из любого аргумента. Вот сильно сокращенный пример:

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;
}