Здравствуйте, collider, Вы писали:

C>Ну а если бы и это не проканало, я бы ему int последовательно в другие щели пихал бы.

Ну да, ну да:
void test_t(struct_t<std::vector<int>>(std::vector<int>(123)))
тоже вариант.

Здравствуйте, collider, Вы писали:

C>>>Пример ваш не корректен,конечно foo<int>.
К>>Это почему вдруг? Чем специализации хуже основного шаблона?
C>ну наверное тем, что 123- это int
У foo<char> как раз есть конструктор от int

Здравствуйте, collider, Вы писали:

C>А фиг знает, я ж до конструктора не доберусь, пока struct_t не конкретизирую.

Да, верно, дело в этом.
А дальше уже правила становятся не очень очевидными, поэтому вывод не стали делать слишком умным.
Надеюсь, вариант с промежуточной функцией (в которой явно задано правило, какую struct_t<T> выбрать) у тебя прокатил?

А сколько раз ещё тебе придётся писать вот так:

template <typename T>
struct SomeStruct__
{
    SomeStruct__(const T& t) 
    { 
        // какой-то код
    }
    // много кода, полей, методов
};

template <typename T>
SomeStruct__<T> SomeStruct(const T& t) 
{
    return SomeStruct__<T>(t);
}

Это конструкция случайно не имеет специального названия?

Здравствуйте, B0FEE664, Вы писали:

BFE>Здравствуйте, collider, Вы писали:

C>>Ну а если бы и это не проканало, я бы ему int последовательно в другие щели пихал бы.

BFE>Ну да, ну да:
BFE>void test_t(struct_t<std::vector<int>>(std::vector<int>(123)))
BFE>тоже вариант.

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

Здравствуйте, B0FEE664, Вы писали:

BFE>Здравствуйте, collider, Вы писали:

C>>>>Пример ваш не корректен,конечно foo<int>.
К>>>Это почему вдруг? Чем специализации хуже основного шаблона?
C>>ну наверное тем, что 123- это int
BFE>У foo<char> как раз есть конструктор от int

конструктор то может и подходит, но без конкретизации шаблона никто ничего о нем не знает.

Здравствуйте, T4r4sB, Вы писали:

TB>Здравствуйте, collider, Вы писали:

C>>А фиг знает, я ж до конструктора не доберусь, пока struct_t не конкретизирую.

TB>Да, верно, дело в этом.
TB>А дальше уже правила становятся не очень очевидными, поэтому вывод не стали делать слишком умным.
TB>Надеюсь, вариант с промежуточной функцией (в которой явно задано правило, какую struct_t<T> выбрать) у тебя прокатил?

TB>А сколько раз ещё тебе придётся писать вот так:
TB>

TB>template <typename T>
TB>struct SomeStruct__
TB>{
TB>    SomeStruct__(const T& t) 
TB>    { 
TB>        // какой-то код
TB>    }
TB>    // много кода, полей, методов
TB>};

TB>template <typename T>
TB>SomeStruct__<T> SomeStruct(const T& t) 
TB>{
TB>    return SomeStruct__<T>(t);
TB>}
TB>

TB>Это конструкция случайно не имеет специального названия?
Ну как сказать... Приведенный мною пример немного проще, чем на самом деле.
Сама идея была в том, чтобы упростить жизнь при использовании классов и дать возможность передавать как обертку struct_t<T> так и T
в конструкторы. А я человек, прямо скажем, ленивый, и хотел эту мелкую проблему как то хитренько и быстренько обойти.
Не получилось, пришлось добавлять конструкторы с struct_t<T> и T.