blocks|key|3205625|text|有没有一种不需要额外功能的方法？不，没有。为什么只对函数有效？因为对于函数，您实际上提供了参数。如果它被允许用于类，那么推断模板参数的唯一方法将是在调用构造函数进行初始化的情况下，这会产生许多额外的规则和异常，并使事情变得复杂。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3205626|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Is there a way without the extra function? No there isn't. Why the deduction works only for functions? Because with functions you actually provide arguments. If it were allowed for classes, then the only way to deduce the template parameters would be in case when a constructor was called for initialization, which makes lots of additional rules and exceptions and complicates things,

blocks|key|2920059|text|如果构造函数本身是一个模板，那么它可以在构造函数参数中工作。不同之处在于，当您使用帮助器时，您使用的是函数模板，其中编译器可以推断类型。如果没有帮助器，您将使用类模板，在调用(非模板)构造函数之前，编译器必须以某种方式推断类型。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2920060|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

It does work in constructor arguments, if the constructor is itself a template. The difference is that when you use your helper, you're using a function template, where the compiler can deduce the type. Without the helper, you're using a class template, where the compiler would have to somehow deduce the type before calling the (non-template) constructor.

blocks|key|2920078|text|不，没有额外的make函数是无法做到这一点的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2920079|它不能与构造函数一起工作的原因是因为它太复杂了。请考虑以下内容：|2920080|template+<typename+T>
struct+Foo
{
++++Foo(const+T&+val)+{+...+}
++++Foo(const+Foo<T>&+other)+{+...+}+//+Copy+constructor
};

Foo<int>+x;|code-block|syntax|javascript|2920081|如果我调用：|2920082|Foo(x);|2920083|这给了我一个Foo<+Foo<int>+>，还是我调用了一个Foo<int>的复制构造函数|offset|length|style|CODE|2920084|它在太多的地方会有歧义，所以额外的函数是必要的。|2920085|请注意，您可以通过使用模板模板来自动创建make函数：|2920086|template+<template+<typename>+class+TemplateClass,+typename+Type>
TemplateClass<Type>+make(const+Type&+x)
{
++++return+TemplateClass<Type>(x);
}|2920087|然后，您可以使用：|2920088|make<SomeClass>(123);+//+returns+a+SomeClass<int>|2920089|entityMap^0|0|0|0|0|0|6|F|U|8|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|14|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|15|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|16|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|17|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|18|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|19|8|@$O|1A|P|1B|Q|R]|$O|1C|P|1D|Q|R]]|9|@]|A|$]]|$1|S|3|T|5|6|7|1E|8|@]|9|@]|A|$]]|$1|U|3|V|5|6|7|1F|8|@]|9|@]|A|$]]|$1|W|3|X|5|F|7|1G|8|@]|9|@]|A|$G|H]]|$1|Y|3|Z|5|6|7|1H|8|@]|9|@]|A|$]]|$1|10|3|11|5|F|7|1I|8|@]|9|@]|A|$G|H]]|$1|12|3|-4|5|6|7|1J|8|@]|9|@]|A|$]]]|13|$]]

No, there is no way to do this without an extra make function.

The reason it doesn't work with constructors is because it would be ridiculously complicated. Consider this:

<pre><code>template &lt;typename T&gt;
struct Foo
{
 Foo(const T&amp; val) { ... }
 Foo(const Foo&lt;T&gt;&amp; other) { ... } // Copy constructor
};

Foo&lt;int&gt; x;
</code></pre>

What if I then call:

<pre><code>Foo(x);
</code></pre>

Does that give me a <code>Foo&lt; Foo&lt;int&gt; &gt;</code> or am I calling the copy constructor for a <code>Foo&lt;int&gt;</code>?

It would be ambiguous in too many places, so the extra function is necessary.

Note that you can automate the create of make functions a little by using template templates:

<pre><code>template &lt;template &lt;typename&gt; class TemplateClass, typename Type&gt;
TemplateClass&lt;Type&gt; make(const Type&amp; x)
{
 return TemplateClass&lt;Type&gt;(x);
}
</code></pre>

Then you can use:

<pre><code>make&lt;SomeClass&gt;(123); // returns a SomeClass&lt;int&gt;
</code></pre>

I often find the need to use the following pattern:

<pre><code>template&lt;typename T&gt;
class SomeClass : public Base {
 SomeClass(const T&amp; t) {...}
 ...
};
template&lt;typename T&gt;
SomeClass&lt;T&gt;* makeSomeClass(const T&amp; t) {
 return new SomeClass&lt;T&gt;(t);
}
</code></pre>

And to use it:

<pre><code>Base* = makeSomeClass(123);
</code></pre>

This is useful when I don't want to explicitly specify <code>T</code> because it is a very complex (function types, etc') and the function argument can deduce the type implicitly. 
Is there a way to do this without the extra "make" function? Why does template deduction work only in function arguments and not in constructor arguments?

C++: instantiate a templated class according to an argument

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我经常发现需要使用以下模式：template<typename T>class SomeClass : public Base { SomeClass(const T& t) {...} ...};template<typename T>SomeClass<T>* makeSomeClass(const T& ...

问C++：根据参数实例化模板化的类
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问C++：根据参数实例化模板化的类EN