模板专门化:只接受特定类型的C++模板(重新访问)
模板专门化是指在C++编程中，只接受特定类型的模板参数的一种技术。通过模板专门化，可以为特定类型的参数提供特定的实现，从而优化代码的执行效率和内存占用。
模板专门化可以分为两种类型：完全特化和部分特化。
完全特化是指为特定类型的参数提供完全独立的实现。当模板参数的类型与完全特化的类型完全匹配时，编译器会选择使用完全特化的实现。完全特化可以通过在模板定义之后使用template<>语法来实现。
部分特化是指为特定类型的参数提供部分实现。当模板参数的类型与部分特化的类型匹配时，编译器会选择使用部分特化的实现。部分特化可以通过在模板定义之后使用template<typename T, typename U>语法来实现。
模板专门化的优势在于可以针对特定类型的参数进行优化，提高代码的执行效率和内存占用。它可以根据不同的参数类型生成不同的代码，从而更好地适应不同的应用场景。
在实际应用中，模板专门化可以用于优化数据结构和算法的实现，提高程序的性能。例如，在处理大规模数据时，可以通过模板专门化来针对不同的数据类型进行优化，从而提高程序的运行速度。
腾讯云提供了多个与C++开发相关的产品，例如云服务器、容器服务、函数计算等。这些产品可以帮助开发者在云环境中进行C++应用的开发、部署和运行。具体产品介绍和链接如下：
- 云服务器（ECS）：提供可扩展的虚拟服务器，支持自定义操作系统和应用程序环境。了解更多：云服务器产品介绍
- 容器服务（TKE）：基于Kubernetes的容器管理服务，提供高可用、弹性伸缩的容器集群。了解更多：容器服务产品介绍
- 函数计算（SCF）：无服务器计算服务，支持按需运行代码，无需关心服务器管理。了解更多：函数计算产品介绍
通过使用腾讯云的这些产品，开发者可以快速搭建和部署C++应用，并享受腾讯云提供的高性能和稳定性。
相关·内容
我一直在尝试用c++进行更多的多线程编程，而且我很难理解std::promise，所以我开始在这个网站上搜索答案，瞧，有个人和我有同样的问题。但是阅读答案使我更加困惑--这是答案中的代码，大概是std::packaged_task的类似实现
template <typename> class my_task;
template <typename R, typename ...Args>
class my_task<R(Args...)>
{
std::function<R(Args...)> fn;
std::promise&
浏览 6提问于2015-12-02得票数 6
回答已采纳
2回答
我想按相反的顺序对包含int的向量进行排序，但是由于我已经习惯了在c++中键入演绎，所以我传递了函数对象greater<>()，而没有指定int，因为它还能是什么呢？这在使用g++时不起作用，但是使用了visual编译器，但是我注意到visual使用了void (不确定这是否可行)。函数对象可以自动推断类型吗?为什么或者为什么？如果没有，是否有一些解决办法，因为类型可以长时间键入？
浏览 4提问于2015-12-30得票数 2
回答已采纳
C++模板专门化规则提到的专门化必须比主模板更专业化。下面的第1段代码段会导致编译错误，其中说第二行不是更专门化，但是最后一行(#2)看起来非常接近于#1。这两个代码段都将专门化的int N作为0，那么为什么第一个代码段被抱怨为“不是更专门化”呢？
// #1
template<int N, typename T1, typename... Ts> struct B;
template<typename... Ts> struct B<0, Ts...> { }; // Error: not more specialized
// #2
template&l
浏览 0提问于2020-12-10得票数 3
回答已采纳
2回答
C++标准禁止部分专门化的朋友声明。(第14.5.3/8节)：
友人声明不应声明部分专门化。[例子：
template<class T> class A { };
class X {
template <class T> friend class A<T*>; //error
};
-最终例子]
其他问题，如，已经收到了援引这一禁令的答案，但我想知道理由。我看不见它，也找不到我最喜欢的搜索引擎。然而，我可以发现，它可以直接回到C++98标准，因此，其基本原理大概是非常基本和明确的。有人能给我解释一下吗？
浏览 1提问于2013-05-15得票数 17
4回答
与C++模板混淆
、、、
我正在查看一些c++代码，并不理解模板声明在这种情况下的用途：
template<> void operator>>(const ClassA& s, const ClassB d) {...}
template<>的语义是什么
浏览 2提问于2011-01-17得票数 2
回答已采纳
我正在读一些c++代码，下面的代码列表让我非常困惑。
我可以猜到它试图定义一个专门的模板，它试图对输入的args类型进行特征化。但我有几个问题：
第一个模板看起来既像派生模板，又像模板专门化，如果它是派生的，如何从自身派生结构？如果是模板专门化，模板定义在哪里？
template<typename F>
struct function_traits : public function_traits<decltype(&F::operator())>
{};
template<typename R, typename C, typename ... Arg
浏览 1提问于2018-09-11得票数 6
回答已采纳
3回答
我是C++的初学者，正在使用"C++ Primer Plus“这本书自学这门语言，并对编程变得更加自如。
我在书中做了一些与函数模板主题相关的摘录，我有两个问题。
我不明白为什么下面的显式专门化不起作用：
template <typename T>
T lesser(T a, T b)
{
return a > b ? a : b;
}
template <>
box lesser<box>(box& a, box& b)
{
return a.volume > b.volume? a
浏览 3提问于2012-09-08得票数 0
回答已采纳
我有一个关于的问题。
这是一个理论问题，涉及的代码可能会被认为是写得不好。但是，我想彻底理解模板语法。
假设两个模板专门化仅按template<...>行中模板参数的顺序不同，如下所示：
#include <iostream>
// Primary template
template<typename T1, typename T2, typename T3>
class A
{};
// Specialization #1
template<typename T2, typename T3>
class A<int, T2, T3&g
浏览 5提问于2012-06-17得票数 1
6回答
在关于C++的书中，为什么我们被教导使用函数重载，当我们在C++中使用模板时？
展示模板的有效(和正确)使用不是更好吗？而在大多数关于C++的书中，函数重载都是在哪里教的呢？
或者，是否有充分的理由使用其中一个而不是另一个？
浏览 4提问于2012-09-08得票数 37
回答已采纳
1回答
在C++中为一个类的模板T变量。它的绑定时间是多少？
我在考虑编译时，因为在将它绑定到值/地址之前，它需要知道传递给它的值是什么。
浏览 0提问于2016-04-09得票数 0
(这个问题是评论中讨论的一个分支。)
说强调地雷
在命名显式函数模板专门化的 时，可以在中留下未指定的，条件是它可以从函数参数类型中推导出来。 示例：
模板类数组{ /* . */ }；模板空排序( Array & v)；//显式专门化排序(Array&) //带有推导的模板- int template<>空洞排序(Array&)类型的参数；
- 端例
它显然适用于foo(T)的(完全)显式专门化，在下面的示例中：
#include <iostream>
template <typename T>
void foo(T
浏览 3提问于2020-04-23得票数 5
回答已采纳
2回答
我读过关于和的文档，但不明白在这个示例中使用了什么样的专门化(msdn链接只是因为我当前的环境，这个问题或多或少是理论性的)。我需要c++标准和/或c++标准段落的文档或参考链接中使用的名称。我试图解决的问题很复杂，很难直接问，但我知道如何使用与本示例中使用的类似的方法。
template<class T>
struct is_vector {
static bool const value = false;
};
template<class T>
struct is_vector<std::vector<T>> {
stat
浏览 5提问于2014-03-13得票数 4
回答已采纳
2回答
由于三行代码，以下C++翻译单元格式不正确：
template <int x, int y> struct S {}; // [1]
template <int w, int z> struct S {}; // [2] <-- ill-formed
template <int x> struct S<x,5+2> {}; // [3]
template <int w> struct S<w,3+4> {}; // [4] <-- ill-formed
template <> struct S<
浏览 0提问于2019-10-04得票数 1
回答已采纳
1回答
std::function类是模板化的，因此当我们希望它包装一个函数时，如下所示：
void printInt(int integer)
{
std::cout << int << '\n';
}
我们使用std::function<void(int)>。直到最近，我还认为这是类的一个奇怪的细微差别，但是在C++中搜索委托实现时使用了类似的语法。
void(int)到底是什么，我们用技术术语来称呼它是什么？这似乎是用代码峰值表示“一个函数需要一个int，并返回空”的标准方式，但是我的直觉告诉我，这太简单了。
其次，我注意到当我看到使用
浏览 2提问于2014-11-07得票数 4
回答已采纳
1回答
考虑下面的模板，它是专门化的：
template<typename R>
R func() {
return 0;
}
template<>
auto func() {
std::cout << "Auto deduced" << std::endl;
return 1;
}
我不确定是否允许这样的声明，但是当用Xcode编译它时，clang会发出一个奇怪的错误：
clang: error: unable to execute command: Segmentation fault: 11
clang:
浏览 3提问于2022-12-02得票数 3
我希望通过为我的自定义容器(在std之外)添加std::size和std::empty的模板专门化来扩展std命名空间。
我有两个问题：
为什么和 constexpr？据我所知，只有堆栈上的std::array和数组的大小和空值才能在编译时知道，而其他容器(如std::vector和std::map )则不然。那么，当std::size和std::empty将std::vector替换为模板参数时，它们又如何工作呢？
我尝试为我的自定义容器使用std::size和std::empty的模板专门化来扩展std::size，但是编译器无法推断出专用的模板方法。有人能解释我做错了什么吗？
浏览 5提问于2018-01-17得票数 3
回答已采纳
我在C++程序中有一个关于显式专门化的问题
我想为char* type做一个专门化，它将一个地址返回给最长的char数组，但我一直收到错误：
C:\Users\Olek\C++\8_1\main.cpp|6|error: template-id 'maxn<char*>' for 'char* maxn(char*)' does not match any template declaration|
C:\Users\Olek\C++\8_1\main.cpp|38|error: template-id 'maxn<char*>&
浏览 4提问于2017-07-23得票数 0
回答已采纳
1回答
我希望在C++中有一个通用的C++实现，它可以容纳任何类型的可定位对象。这样的物体具有2D位置。
不幸的是。可定位的课程可以有不同的方法来获得职位。
Getter getX()和getY()
std::pair<double，double>
sf::Vector2f
..。
将此类类打包到我的KDTree中的正确方法是什么？
My由以下节点组成：
template <typename T>
struct Node {
int id;
T element;
Node *left, *right;
Node(T ele
浏览 5提问于2021-12-04得票数 1
回答已采纳
我正在学习C++概念--模板专门化和部分模板专门化。有一个代码如下所示，这是我想要理解的，所以我正确地得到了这些概念。
关于这一点，我没有几个问题，以下是在下面提出的问题：
template <typename T, int nSize>
class Buffer
{
private:
T m_atBuffer[nSize];
public:
T* GetBuffer()
{
return m_atBuffer;
}
T& operator[](int nIndex)
{
return
浏览 4提问于2011-10-05得票数 0
回答已采纳
下面的程序同时给出了g++和clang中的错误。
#include <iostream>
#include <utility>
using namespace std;
//Since C++17 one can use fold expression to calculate factorial:
template <class T, T N, class I = std::make_integer_sequence<T, N>>
struct factorial;
template <class T, T N, T... Is&g
浏览 17提问于2020-05-31得票数 2
回答已采纳
在阅读wiki页面时，我发现了以下示例代码
template <class T>
struct is_pointer
{
template <class U>
static char is_ptr(U *); #1
template <class X, class Y>
static char is_ptr(Y X::*);
template <class U>
static char is_ptr(U (*)()); #2
static double is_ptr(...);
static T t;
浏览 3提问于2021-11-10得票数 0
回答已采纳
2回答
运行时检查开关情况
、、、、
我正在查看bencode规范，并且正在编写一个C++端口，该端口是洪流式比特流客户端的bencode实现(用python编写的)。Python实现包括一个{ data_types : callback_functions }的字典，通过该字典，函数包装器可以轻松地选择通过字典查找提供给包装函数的变量的数据类型来使用哪种编码函数。我在python原语的C++等价物的运行时搜索了变量类型，并发现typeid()可能提供了我想要的。我知道我的代码不会存储typeid()函数返回值的结果，但我不希望依赖于提供编译器特定字符串文字的函数。我找到了一个，它允许我提供一种可移植的方法来手动将类型指定为字符串
浏览 0提问于2014-07-01得票数 2
4回答
当我研究“类模板部分专业化”时，我阅读了以下代码
#include <iostream>
using namespace std;
template <typename T1, typename T2>
class stream
{
public:
void f() { cout << endl << "stream<typename T1, typename T2>::f()"; }
};
template <typename T1>
class stream<T1, int>
浏览 4提问于2011-05-23得票数 0
1回答
今天我试着做一些我惊讶地发现不起作用的事情。我有一个以类型和值作为参数的模板。我想专攻type参数，但保留value参数。就像这样
template <class T = void, bool Enabled = false>
struct seFoo {};
template <bool Enabled>
struct seFoo<int, Enabled> {};
// Doesn't work :(
seFoo<false> foo;
但是，由于模板参数太少，这会导致编译错误。似乎在编译器查看部分专门化之前，实例化必须与非专门化
浏览 0提问于2019-04-04得票数 1
学习C++，出现了函数模板。这一章提到了模板专门化。
template <> void foo<int>(int);
void foo( int );
当你可以使用第二个的时候，为什么要专攻？我认为模板应该是泛化的。当您只使用一个常规函数时，为特定数据类型专门化一个函数有什么意义呢？
显然，模板专门化的存在是有原因的。什么时候使用？我读过萨特的文章，但我需要更多的外行版本，因为我只是在学习这些东西。
浏览 0提问于2010-09-11得票数 6
回答已采纳
是否有一种方法可以使用C++概念来要求类派生自模板类，而模板参数又是另一个模板类的派生类。
示例：
template <class T>
class A{};
template <class T>
class B{};
class X{};
class Y : public A<X> {};
class Z : public B<Y> {};
我如何在B中签入，即T是某些X的表单std::is_base_of<A<X>,T>，而不指定X是什么？我不想将X添加到B的模板参数列表中，因为我不想在每个从B派生的实例(例如，
浏览 6提问于2022-04-19得票数 6
回答已采纳
下面的示例代码在gcc下编译，并按我所希望的那样工作。它允许我使用函数定义作为模板参数实例化一个对象，但随后该类可以使用函数中的不同类型，就好像它们是作为类型模板参数单独传递的一样。
template<class FuncSignature> class Obj;
template<class Type1, class Type2> class Obj<Type1 (Type2)>
{
public:
Type1 var1;
Type2 var2;
};
int main(int argc, char **argv)
{
Obj<cha
浏览 1提问于2010-11-28得票数 6
回答已采纳
1回答
我不断地阅读和研究，不同的帖子，c++的书籍，文章，到目前为止还没有人向我解释这个构造的合理性。这没有任何意义，这真的让我很恼火。模板的全部意义在于将类型参数化为函数(或类，但我指的是函数模板，而不是类)。为什么要在没有type参数的情况下使用有趣的模板语法？
//this seems ridiculous. why would anybody ever use this?
template<> void Swap(int & a , int & b){}
//I would always use this if I needed to take care of a
浏览 0提问于2014-02-28得票数 6
1回答
假设我们有这样的代码：
class MyEvent {
timestamp:number;
}
class AEvent extends MyEvent{
x:number;
y:number;
}
class BEvent extends MyEvent{
key:string;
}
var fn:(event:MyEvent)=>void;
function AE(event:AEvent){
let x = event.x; //Ok, but BEvent hasn't 'x' property.
}
fn
浏览 0提问于2016-08-01得票数 0
1回答
模板专门化方法
、、
我有一个模板化的方法，我想要添加一个专门化。对于一个函数，我会写
template<> T function<typename T>() { /* ... */ }
我怎么才能用这个方法呢？
下面是一个最小的失败示例，我需要专门为<char>专门化<char>。
#include <vector>
class recver_t {
public:
// recv should work for chars, ints, and lists of those.
template <typename list_
浏览 0提问于2018-09-26得票数 2
回答已采纳
我在看Don Clugston的迷你库时，注意到了一个奇怪的语法技巧，它的结构如下：
TemplateClass< void( int, int ) > Object;
它看起来几乎就像是一个函数签名被用作模板实例声明的参数。
这项技术(它在FastDelegate中的出现显然是由于一个Jody Hagins)被用来简化具有半任意数量的模板参数的模板实例的声明。
也就是说，它允许这样做：
// A template with one parameter
template<typename _T1>
struct Object1
{
_T1 m_member1;
浏览 1提问于2011-01-10得票数 57
回答已采纳
1回答
我正在开发一个库，它使用了一个非常古老的C++表达式模板(ET)引擎，名为PETE。(我试图找到一个指向它的源代码的链接，所以我可以引用它，但我只找到了关于它的文章。)
快速概述:使用ET，C++编译器使用运算符infix-form (+，-，*，/)从表达式构建--表示表达式及其操作的C++类型。PETE方法的核心是ForEach类模板，用于稍后解析和计算表达式。
我想要做的是提供一个专门的ForEach，当它的参数满足特定条件时就会使用它。我正在尝试使用部分专门化和使用enable_if，但是编译器抱怨“不明确的部分专门化”。
如果需要的话，我很乐意发布代码的其他部分，但我将坚持使用直接类
浏览 3提问于2021-05-31得票数 1
回答已采纳
3回答
我正在学习C++模板，我创建了一个模板类来添加两个字符串，但是我得到了后续错误:请帮助我理解这个错误。
main.cc:65:52: error: no matching function for call to TheNameHolder<std::basic_string<char> >::TheNameHolder(const char [8], const char [7])
using namespace std;
template <class T>
class TheNameHolder{
T *a, *b;
public:
浏览 3提问于2013-07-23得票数 0
回答已采纳
当我声明一个std::unordered_map<boost::any, boost::any>类型的变量时，它会引发恼人的编译错误。
例如，any.cc
#include <map>
#include <boost/any.hpp>
int main() {
std::map<boost::any, boost::any> dict;
return 0;
}
以g++ any.cc -std=c++11 -I/usr/include/boost的形式编译上面的代码会发生很多错误，如下所示：
In file included f
浏览 5提问于2016-07-29得票数 0
回答已采纳
实际上，我正在试图理解c++中的一段代码，并在这段代码段中发现，这是一个新的数据类型吗？"homeDeliv“和"pickUp”到底是什么。它们是在这里定义的还是在其他地方定义的，只是在这里使用？
我对C++语法很陌生。请帮忙..。
template< typename Pac > struct Packets;
template<> struct Packets< homeDeliv > { static const unsigned ID = 0; };
template<> struct Packets< pi
浏览 4提问于2013-10-22得票数 0
回答已采纳
有两类：
class A {
public:
virtual void foo( int bar );
}
class B {
virtual void foo( string bar, int baz);
}
现在，我正在构建的类可以从任何一个类派生出来。但是有一些常见的助手代码，所以我想将它合并到一个基类中。必须从foo调用此公共代码，并且应该使用与相应的foo方法相同的参数。因此，我声明这个模板类，但不知道是否可以从模板参数中“提取”foo的签名(这是一个基类-- A或B)：
template<class Base>
class CommonBase : pu
浏览 1提问于2019-06-24得票数 2
回答已采纳
2回答
在相关问题中，描述了避免链接器错误的两种策略：
在头文件中实现整个模板；
使用template class Foo<int>语法显式实例化模板。
据我所知，#1似乎是“首选”方法，在每个库中都使用--大概是因为很难或不可能预测用户希望使用哪种类型的库。我的问题与策略2有关。
具体来说，我为什么要这么做？
FYI:我是C++的新手，有着沉重的C#背景。我已经习惯了.NET风格的泛型，这是比较直截了当的，是的，我理解它们为什么不同。但是，我假设C++开发人员仍然关心耦合。表单2难道没有引入一种特别烦人的耦合形式，在这种情况下，开发人员必须不断地编辑模板的.cpp文件，才
浏览 2提问于2014-07-28得票数 3
using FuncDef = void(int a, int b);
template <typename R, typename... Args>
class WrongFunction {
public:
void F1(R(*Fn)(Args...)) {}//error: C2091 function returns function
};
template <typename T> class Function;
template <typename R, typename... Args>
class Function<R(A
浏览 4提问于2021-01-29得票数 3
回答已采纳
我尝试在metrowerks CodeWrior5.5.3中使用boost.thread；在头文件thread.hpp中，我得到的错误是他正在重新定义thread::thread_data：
class BOOST_THREAD_DECL thread
{
private:
...
template<typename F>
struct thread_data:
detail::thread_data_base
{
F f;
thread_data(F f_):
浏览 4提问于2009-07-10得票数 3
回答已采纳
2回答
注意：，这似乎是一个问题的转贴：
我已经将C++模板专门化的问题归结为一个简单的案例。
它由一个简单的2参数模板类Thing组成，我想在其中专门介绍Thing<A,B>::doSomething() for B=int。
#include <cstdio>
// A 3-parameter template class.
template <class A, class B>
class Thing
{
public:
Thing(A a, B b) : a_(a), b_(b) {}
B doSomething();
private:
浏览 2提问于2011-05-26得票数 22
回答已采纳
3回答
如果我们考虑函数模板重载，C++中的标准行为是首先选择“最专门的”重载(从基本模板中选择)。下一步是查看所选的重载是否显式地专门化。如果是，则将选择匹配的显式专门化。。
您能否指出标准中定义第二步的位置(上一段中突出显示的部分)？
谢谢。
浏览 0提问于2018-09-11得票数 1
下面的代码给出了预期的编译器错误()：
1 template<bool> struct Range;
2
3 template<int value, typename = Range<true> > struct Unique;
4 template<int value> struct Unique<value, Range<(value > 1)> > { typedef char type[1]; };
5 template<int value> struct Unique<
浏览 1提问于2012-03-06得票数 6
回答已采纳
在c++标准库中，is_member_pointer实现为
template<typename _Tp>
struct __is_member_pointer_helper
: public false_type { };
template<typename _Tp, typename _Cp>
struct __is_member_pointer_helper<_Tp _Cp::*>
: public true_type { };
/// is_member_pointer
template<typ
浏览 0提问于2019-03-15得票数 5
2回答
标准库将std::hash实现为专用于不同类型的模板结构。它的用法如下：
#include <iostream>
#include <functional>
int main()
{
std::hash<int> hasher;
std::cout << hasher(1337) << std::endl;
return 0;
}
我的问题是，这个设计选择背后的原因是什么。为什么它没有实现为模板函数，并像这样使用：
#include <iostream>
#include <functio
浏览 3提问于2013-11-25得票数 20
回答已采纳
让我们想象一下，我有类似haskell的类课程，也许在c++。例如，可以这样实现：
template<typename T, typename val>
struct Maybe;
template<typename val> struct Maybe<std::true_type, val> {
using value = val;
};
template<> struct Maybe<std::false_type, void> {
};
template<typename val>
usin
浏览 0提问于2019-07-01得票数 0
回答已采纳
2回答
我有一个模板化的结构，然后我将其专门化如下：
template <class T>
struct FunctionSignature;
template <class Return, class Arg0>
struct FunctionSignature<Return (Arg0)>
{
typedef Return(*type)(Arg0);
};
所以我实例化如下：
FunctionSignature<int (const std::string& str)>::type f = &onefunction;
函数f
浏览 2提问于2018-01-05得票数 1
回答已采纳
4回答
请考虑以下几点：
template <class...>
struct MyT;
template <class T>
struct MyT<T> {};
template <template <class> class TT = MyT> struct A {}; // fine
using B = A<MyT>; // does not compile
int main() {
return 0;
}
当MyT被用作A的默认参数时，编译器(g++ 5.4.0)很高兴。但是，当它用于实例化A时，情况就不同了：
浏览 6提问于2016-09-26得票数 4
回答已采纳
1回答
今天，我和我的一个朋友为一个愚蠢的错误而挣扎，我想知道模板参数是如何在C++中工作的。考虑下面的代码，其中我尝试部分地专门化一个类attr<MyClass<I>>，其中I是一个unsigned int，尽管MyClass需要一个int参数：
#include <iostream>
template<int I>
class MyClass
{
};
template<typename T>
struct attr;
template<unsigned int I>
struct attr<MyClass<
浏览 1提问于2016-03-10得票数 7
回答已采纳
2回答
约束成员函数与显式模板实例化
、、、、
G++和Clang++一致认为以下代码段是无效的C++：
template<int dim, int rank>
struct Tensor {};
template<int dim>
double InnerProduct(Tensor<dim, 1> const &, Tensor<dim, 1> const &)
{ return 0.0; }
template<int dim>
double DoubleInnerProduct(Tensor<dim, 2> const &, Ten
浏览 2提问于2020-06-30得票数 9
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
实时音视频
对象存储
即时通信 IM活动推荐
腾讯云开发者
