blocks|key|294426|text|在调用构造函数模板时，无法显式指定模板参数，因此必须通过参数推导来推导它们。这是因为如果你说：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|294427|Foo<int>+f+=+Foo<int>();|code-block|syntax|javascript|294428|<int>是Foo类型的模板参数列表，而不是它的构造函数。构造函数模板的参数列表无处可去。|offset|length|style|CODE|294429|即使使用了变通方法，您仍然必须传递参数才能调用该构造函数模板。完全不清楚你想要达到什么目的。|294430|entityMap^0|0|0|0|5|6|3|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@$I|T|J|U|K|L]|$I|V|J|W|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|X|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|P|$]]

There is no way to explicitly specify the template arguments when calling a constructor template, so they have to be deduced through argument deduction. This is because if you say:

<pre><code>Foo&lt;int&gt; f = Foo&lt;int&gt;();
</code></pre>

The <code>&lt;int&gt;</code> is the template argument list for the type <code>Foo</code>, not for its constructor. There's nowhere for the constructor template's argument list to go.

Even with your workaround you still have to pass an argument in order to call that constructor template. It's not at all clear what you are trying to achieve.

blocks|key|3015875|text|您可以创建一个模板化工厂函数：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3015876|class+Foo
{
public:
++++template+<class+T>+static+Foo*+create()+//+could+also+return+by+value,+or+a+smart+pointer
++++{
++++++++return+new+Foo(...);
++++}
...++++++++
};|code-block|syntax|javascript|3015877|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

You can create a templated factory function:

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

blocks|key|3230138|text|据我所知，使用|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3230139|是不可能的(因为它会与默认构造函数冲突--我说的对吗？)|blockquote|3230140|3230141|3230142|你错了。它不会以任何方式冲突。你就是永远不能把它叫醒。|3230143|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$]]|$1|E|3|-4|5|6|7|M|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|N|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|P|8|@]|9|@]|A|$]]]|J|$]]

<blockquote>
 As far as I understand, it's impossible to have it (because it would conflict with the default constructor - am I right?)
</blockquote>

You are wrong. It doesn't conflict in any way. You just can't call it ever.

blocks|key|294484|text|template<class...>struct+types{using+type=types;};
template<class+T>struct+tag{using+type=T;};
template<class+Tag>using+type_t=typename+Tag::type;|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|294485|上面的帮助器允许您将类型作为值来使用。|unstyled|294486|class+A+{
++template<class+T>
++A(+tag<T>+);
};|294487|tag<T>类型是一个变量，除了它嵌入的类型外，没有任何状态。您可以使用此函数将纯类型值传递给模板函数，并由模板函数推导出该类型：|offset|length|style|CODE|294488|auto+a+=+A(tag<int>{});|294489|您可以传入多个类型：|294490|class+A+{
++template<class+T,+class+U,+class+V>
++A(+types<T,U,V>+);
};
auto+a+=+A(types<int,double,std::string>{});|294491|entityMap^0|0|0|0|0|6|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|X|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|Y|8|@]|9|@]|A|$B|C]]|$1|I|3|J|5|F|7|Z|8|@$K|10|L|11|M|N]]|9|@]|A|$]]|$1|O|3|P|5|6|7|12|8|@]|9|@]|A|$B|C]]|$1|Q|3|R|5|F|7|13|8|@]|9|@]|A|$]]|$1|S|3|T|5|6|7|14|8|@]|9|@]|A|$B|C]]|$1|U|3|-4|5|F|7|15|8|@]|9|@]|A|$]]]|V|$]]

<pre><code>template&lt;class...&gt;struct types{using type=types;};
template&lt;class T&gt;struct tag{using type=T;};
template&lt;class Tag&gt;using type_t=typename Tag::type;
</code></pre>

the above helpers let you work with types as values.

<pre><code>class A {
 template&lt;class T&gt;
 A( tag&lt;T&gt; );
};
</code></pre>

the <code>tag&lt;T&gt;</code> type is a variable with no state besides the type it caries. You can use this to pass a pure-type value into a template function and have the type be deduced by the template function:

<pre><code>auto a = A(tag&lt;int&gt;{});
</code></pre>

You can pass in more than one type:

<pre><code>class A {
 template&lt;class T, class U, class V&gt;
 A( types&lt;T,U,V&gt; );
};
auto a = A(types&lt;int,double,std::string&gt;{});
</code></pre>

blocks|key|3015961|text|以下是一些要点：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3015962|3015963|如果您声明任何构造函数(包括模板化的构造函数)，编译器将避免声明默认构造函数。|unordered-list-item|offset|length|style|BOLD|3015964|除非您声明了一个复制构造函数(对于X类，一个接受X、X&或X+const+&参数的类)，否则编译器将生成默认的复制构造函数。|CODE|3015965|如果你为类X提供了一个模板构造函数，它接受T+const+&或T或T&，那么编译器仍然会生成一个默认的非模板复制构造函数，即使你可能认为它不应该这样做，因为当T=X时，声明与复制构造函数declaration.|3015966|In匹配，在后一种情况下，你可能想要提供一个非模板复制构造函数以及模板复制构造函数。他们不会冲突。当X被传递时，非模板化的函数将被调用。否则模板化的|3015967|3015968|HTH|3015969|entityMap^0|0|0|5|2|0|O|1|Q|2|T|9|0|L|9|V|1|X|2|0|0|0|0^^$0|@$1|2|3|4|5|6|7|V|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|W|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|X|8|@$F|Y|G|Z|H|I]]|9|@]|A|$]]|$1|J|3|K|5|E|7|10|8|@$F|11|G|12|H|L]|$F|13|G|14|H|L]|$F|15|G|16|H|L]]|9|@]|A|$]]|$1|M|3|N|5|E|7|17|8|@$F|18|G|19|H|L]|$F|1A|G|1B|H|L]|$F|1C|G|1D|H|L]]|9|@]|A|$]]|$1|O|3|P|5|E|7|1E|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|1F|8|@]|9|@]|A|$]]|$1|R|3|S|5|6|7|1G|8|@]|9|@]|A|$]]|$1|T|3|-4|5|6|7|1H|8|@]|9|@]|A|$]]]|U|$]]

Some points: 

<ul>
<li>If you declare any
constructor(including a templated
one), the compiler will refrain from
declaring a default constructor. </li>
<li>Unless you declare a copy-constructor (for class X one
that takes <code>X</code> or <code>X&amp;</code> or <code>X const
&amp;</code>) the compiler will generate the
default copy-constructor. </li>
<li>If you provide a template constructor for class X which takes
<code>T const &amp;</code> or <code>T</code> or <code>T&amp;</code> 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.</li>
<li>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</li>
</ul>

HTH

blocks|key|291395|text|你可以这样做：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|291396|class+C+
{
public:
++++template+<typename+T>+C(T*);
};
template+<typename+T>+T*+UseType()+
{
++++static_cast<T*>(nullptr);
}|code-block|syntax|javascript|291397|然后使用int作为构造函数的模板参数来创建C类型的对象：|offset|length|style|CODE|291398|C+obj(UseType<int>());|291399|由于您不能将模板参数传递给构造函数，因此此解决方案本质上将模板参数转换为常规参数。在调用构造函数时使用UseType<T>()函数可以让查看代码的人清楚地看到，该参数的目的是告诉构造函数要使用哪种类型。|291400|这样做的一个用例是，构造函数创建一个派生类对象，并将其分配给一个成员变量，该变量是基类指针。(构造函数需要知道要使用哪个派生类，但类本身不需要模板化，因为总是使用相同的基类指针类型。)|291401|entityMap^0|0|0|4|3|L|1|0|0|1F|C|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|W|8|@$I|X|J|Y|K|L]|$I|Z|J|10|K|L]]|9|@]|A|$]]|$1|M|3|N|5|D|7|11|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|12|8|@$I|13|J|14|K|L]]|9|@]|A|$]]|$1|Q|3|R|5|6|7|15|8|@]|9|@]|A|$]]|$1|S|3|-4|5|6|7|16|8|@]|9|@]|A|$]]]|T|$]]

You could do this:

<pre><code>class C 
{
public:
 template &lt;typename T&gt; C(T*);
};
template &lt;typename T&gt; T* UseType() 
{
 static_cast&lt;T*&gt;(nullptr);
}
</code></pre>

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

<pre><code>C obj(UseType&lt;int&gt;());
</code></pre>

Since you can't pass template parameters to a constructor, this solution essentially converts the template parameter to a regular parameter. Using the <code>UseType&lt;T&gt;()</code> 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.)

blocks|key|3230234|text|这里有一个解决方法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3230235|创建A的模板子类B。在A的构造函数中做与模板参数无关的构造部分。在B的构造函数中做依赖于模板参数的部分。|3230236|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

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.

blocks|key|291376|text|试着做像这样的事情|type|unstyled|depth|inlineStyleRanges|entityRanges|data|291377|template<class+T,+int+i>+class+A{

++++A(){
++++++++++A(this)
++++}

++++A(+A<int,+1>*+a){
++++++++++//do+something
++++}
++++A(+A<float,+1>*+a){
+++++++++//do+something
++++}
.
.
.
};|code-block|syntax|javascript|291378|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

try doing something like

<pre><code>template&lt;class T, int i&gt; class A{

 A(){
 A(this)
 }

 A( A&lt;int, 1&gt;* a){
 //do something
 }
 A( A&lt;float, 1&gt;* a){
 //do something
 }
.
.
.
};
</code></pre>

blocks|key|291408|text|只需简单地添加一个虚拟变量，如|type|unstyled|depth|inlineStyleRanges|entityRanges|data|291409|class+A+{
++template<typename+T>
++A(const+T&,+int+arg1,+int+arg2);
}|code-block|syntax|javascript|291410|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Just simple to add a dummy variable like
<pre><code>class A {
 template&lt;typename T&gt;
 A(const T&amp;, int arg1, int arg2);
}
</code></pre>

I wish to have a non-template class with a template constructor with no arguments.

As far as I understand, it's impossible to have it (because it would conflict with the default constructor - am I right?), and the workaround is the following:

<pre><code>class A{
 template &lt;typename U&gt; A(U* dummy) {
 // Do something
 }
};
</code></pre>

Maybe there is a better alternative for this (or a better workaround)?

C++ template constructor

编译器

我希望有一个非模板类和一个没有参数的模板构造函数。据我所知，这是不可能的(因为它会与默认构造函数- am right？冲突)，变通方法如下：class A{ template <typename U> A(U* dummy) { // Do something }};也许有更好的替代方案(或者更好的变通方法)？

问C++模板构造函数
EN

回答 9

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问C++模板构造函数EN

回答 9

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问C++模板构造函数
EN