C ++ 템플릿 생성자

C ++ 템플릿 생성자

---

인수가없는 템플릿 생성자가있는 템플릿이 아닌 클래스를 원합니다.

지금까지 내가 이해, 그것은 (는 기본 생성자와 충돌을 일으킬 수 있기 때문에, - 그것을 가지고하는 것은 불가능하다 ? 내가 맞다 ), 그리고 해결 방법은 다음과 같다 :

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

아마도 이것에 대한 더 좋은 대안이 있습니까 (또는 더 나은 해결 방법)?

---

생성자 템플릿을 호출 할 때 템플릿 인수를 명시 적으로 지정하는 방법은 없으므로 인수 공제를 통해 추론해야합니다. 당신이 말하면 :

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

는 <int>유형에 대한 템플릿 인수 목록입니다 Foo없는 생성자를 들어,. 생성자 템플릿의 인수 목록이 갈 곳이 없습니다.

해결 방법이 있더라도 해당 생성자 템플릿을 호출하려면 인수를 전달해야합니다. 당신이 무엇을 달성하려고하는지 전혀 명확하지 않습니다.

---

템플릿 팩토리 함수를 만들 수 있습니다.

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

---

내가 이해하는 한, 그것을 가질 수는 없습니다 (기본 생성자와 충돌하기 때문에-맞습니까?)

당신은 잘못. 어떤 식 으로든 충돌하지 않습니다. 당신은 단지 그것을 호출 할 수 없습니다.

---

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

---

일부 요점 :

• If you declare any constructor(including a templated one), the compiler will refrain from declaring a default constructor.
• Unless you declare a copy-constructor (for class X one that takes X or X& or X const &) the compiler will generate the default copy-constructor.
• If you provide a template constructor for class X which takes T const & or T or T& then the compiler will nevertheless generate a default non-templated copy-constructor, even though you may think that it shouldn't because when T = X the declaration matches the copy-constructor declaration.
• In the latter case you may want to provide a non-templated copy-constructor along with the templated one. They will not conflict. When X is passed the nontemplated will be called. Otherwise the templated

HTH

---

You could do this:

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

Then to create an object of type C using int as the template parameter to the constructor:

C obj(UseType<int>());

Since you can't pass template parameters to a constructor, this solution essentially converts the template parameter to a regular parameter. Using the UseType<T>() function when calling the constructor makes it clear to someone looking at the code that the purpose of that parameter is to tell the constructor what type to use.

One use case for this would be if the constructor creates a derived class object and assigns it to a member variable that is a base class pointer. (The constructor needs to know which derived class to use, but the class itself doesn't need to be templated since the same base class pointer type is always used.)

---

try doing something like

template<class T, int i> class A{

    A(){
          A(this)
    }

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

---

Here's a workaround.

Make a template subclass B of A. Do the template-argument-independent part of the construction in A's constructor. Do the template-argument-dependent part in B's constructor.

참고URL : https://stackoverflow.com/questions/3960849/c-template-constructor