Конструктор шаблонов С++

Я хочу иметь класс без шаблона с конструктором шаблона без аргументов.

Насколько я понимаю, это невозможно, потому что это противоречило бы конструктору по умолчанию - я прав?), И обходной путь следующий:

class A{
   template <typename U> A(U* dummy) {
   // Do something
   }
};

Может быть, есть лучшая альтернатива этому (или лучшее обходное решение)?

Ответ 1

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

Foo<int> f = Foo<int>();

<int> - это список аргументов шаблона для типа Foo, а не для его конструктора. Там, где не будет списка аргументов шаблона конструктора, некуда идти.

Даже при обходном пути вам все равно придется передать аргумент, чтобы вызвать этот шаблон конструктора. Это не совсем ясно, чего вы пытаетесь достичь.

Ответ 2

Вы можете создать шаблонную функцию factory:

class Foo
{
public:
    template <class T> static Foo* create() // could also return by value, or a smart pointer
    {
        return new Foo(...);
    }
...        
};

Ответ 3

Насколько я понимаю, это невозможно сделать (потому что это противоречило бы со стандартным конструктором - я прав?)

Вы ошибаетесь. Это никоим образом не конфликтует. Ты просто не можешь это назвать.

Ответ 4

Некоторые моменты:

Если вы объявите любой конструктор (в том числе шаблонный один), компилятор воздержится от объявление конструктора по умолчанию.
Если вы не объявите конструктор-копию (для класса X один который принимает X или X& или X const &), компилятор будет генерировать default copy-constructor.
Если вы предоставляете конструктор шаблонов для класса X, который принимает T const & или T или T&, тогда компилятор, тем не менее, генерирует невыполненный по умолчанию copy-constructor, хотя вы можете думать, что это не должно быть, потому что, когда T = X, объявление соответствует объявлению конструктора-копии.
В последнем случае вы можете захотеть предоставить шаблонный конструктор без шаблонов вместе с шаблоном. Они не будут конфликтовать. Когда X будет передан, будет вызван nontemplated. В противном случае templated

НТН

Ответ 5

template<class...>struct types{using type=types;};
template<class T>struct tag{using type=T;};
template<class Tag>using type_t=typename Tag::type;

вышеупомянутые помощники позволяют работать с типами как значения.

class A {
  template<class T>
  A( tag<T> );
};

Тип tag<T> - это переменная без состояния, кроме того, что он кариес. Вы можете использовать это, чтобы передать значение чистого типа в функцию шаблона и вывести тип с помощью функции шаблона:

auto a = A(tag<int>{});

Вы можете передать несколько типов:

class A {
  template<class T, class U, class V>
  A( types<T,U,V> );
};
auto a = A(types<int,double,std::string>{});

Ответ 6

Вы можете сделать это:

class C 
{
public:
    template <typename T> C(T*);
};
template <typename T> T* UseType() 
{
    static_cast<T*>(nullptr);
}

Затем, чтобы создать объект типа C, используя int в качестве параметра шаблона для конструктора:

C obj(UseType<int>());

Поскольку вы не можете передавать параметры шаблона конструктору, это решение по существу преобразует параметр шаблона в обычный параметр. Использование функции UseType<T>() при вызове конструктора дает понять кому-то, кто смотрит на код, который предназначен для этого параметра, чтобы сообщить конструктору, какой тип использовать.

Одним из вариантов использования для этого было бы, если конструктор создает объект производного класса и назначает его переменной-члену, которая является указателем базового класса. (Конструктор должен знать, какой производный класс использовать, но сам класс не нуждается в шаблоне, поскольку всегда используется тот же тип указателя базового класса.)

Ответ 7

попробуйте сделать что-то вроде

template<class T, int i> class A{

    A(){
          A(this)
    }

    A( A<int, 1>* a){
          //do something
    }
    A( A<float, 1>* a){
         //do something
    }
.
.
.
};

Ответ 8

Вот обходной путь.

Создайте подклассу шаблона B из A. Создайте независимую от шаблона часть конструкции в конструкторе A. Замените элемент, зависящий от шаблона, в конструкторе B.