如何以pack作为模板参数实例化专用模板类？
以pack作为模板参数实例化专用模板类需要使用可变参数模板（variadic template）的特性。可变参数模板允许在模板参数列表中使用可变数量的参数。
下面是一个以pack作为模板参数实例化专用模板类的示例代码：
// 定义一个可变参数模板类
template <typename... Args>
class MyTemplate {
// 类的成员和方法
};
// 使用pack实例化MyTemplate类
MyTemplate<int, double, std::string> obj1;
MyTemplate<char, bool> obj2;在上面的示例中，MyTemplate是一个可变参数模板类，它接受任意数量和任意类型的模板参数（pack）。通过在实例化时提供具体的模板参数，可以创建不同类型的MyTemplate对象。
这种方式的优势是可以根据实际需要灵活地定义和使用模板类，不受固定数量的模板参数限制。它适用于需要处理不同类型数据的场景，例如容器类、算法类等。
对于腾讯云相关产品和产品介绍链接地址，由于要求不能提及特定的云计算品牌商，这里无法给出具体的推荐。但可以根据实际需求，在腾讯云官网上查找相关的云计算产品和解决方案。
相关·内容
在我的一个C++项目中，我使用了许多模板。因为我不能将它们放入*.cpp文件中，所以它们整个函数目前都位于头中。
但是这一方面扰乱了头文件，另一方面也导致了长时间的编译。如何以干净的方式处理模板化函数的实现？
浏览 10提问于2013-11-03得票数 2
回答已采纳
有人能告诉我为什么我们要在下面一行中在Graph之后写size_t吗？ Graph<std::size_t> g; Graph是一个类名，g是一个对象。size_t在那里做什么？我们为什么要写这个呢？ 如果这个问题太简单了，我很抱歉。但我找不到关于这一点的解释，到目前为止，当我想要创建我编写的类的对象时： class_name object; 像这样： Graph g;
浏览 16提问于2020-01-06得票数 0
回答已采纳
template <typename T> struct s
{
};
template <> struct s<MyClass *>
{
};
... in main function
struct s<MyClass*> obj;
上面的代码可以编译，但我真的看不出使用完全的专门化能做什么
template <> struct s<MyClass *>
{
};
我不能添加指针变量(既不是常量也不是静态变量)，比如
template <> struct s<MyClass *obj >
浏览 0提问于2013-03-02得票数 0
回答已采纳
下面的结果是什么？它是不正确的，未定义的行为，还是定义良好，格式良好？
struct A {};
std::pointer_traits<A> x;
我问的原因是因为我想知道好奇心，也因为我想知道一个任意类型是否是一个指针。在这方面，我也想包括shared_ptr和朋友。我想知道是否有一个类型特征(谓词)，或者，如果没有，我是否可以使用pointer_traits并检测是否声明了element_type。
浏览 1提问于2013-03-12得票数 4
回答已采纳
1回答
从这个线程中我知道，如果我专门化一个类模板，我需要专门化所有的成员函数。
所以，我的理由是我要“实例化”一个模板类。(不确定这是不是正确的说法)
然后，因为这个实例化的类是一个完整的类，所以我可以专门化一个特定的方法。
// I have a template class like this -
template<class T, T invalidVal, int e> class A
{
static inline bool dummy(T value)
{
return 0;
}
}
// Now I create cla
浏览 2提问于2012-08-10得票数 1
回答已采纳
1回答
显式专业化认证是模板吗？
、、、
根据的说法，专门化是一个类/函数/...实例化的或显式专门化的。指出，一些显式专门化是模板，这使我相信显式专门化是专门化(在“从模板生成的实体”意义上)，而不是模板(有时)。
我的问题是，显式的特殊化是实际的具体实体(类/函数/...)，还是模板。如果不是，它们到底是什么?它们不是模板或专门化(遵循temp.spec p4提供的定义)
浏览 5提问于2019-05-29得票数 1
对于一个任务，我需要能够创建一个模板化的朋友类，我可以让程序的其余部分工作，但我不能跳过错误。我给出了定义这两个类的代码以及错误的照片。如果我需要更具体的问题，请告诉我，但老实说，我对模板一无所知。谢谢。
template<class T>
class Node{
friend class NodeStack;
public:
Node();
Node(const T & data, Node<T> * next = NULL);
浏览 0提问于2019-11-28得票数 2
2回答
我的代码如下
class A
{
public:
int Key() const;
};
class B : public A
{};
template<class T, int (T::*MemFunction)() const>
class TT
{
public:
int Get() const {return (m_t.*MemFunction)();}
private:
T m_t;
};
TT<B, &B::Key> t; // Wrong, cannot convert overloade
浏览 0提问于2013-01-12得票数 2
回答已采纳
1回答
OpenFOAM库定义了两种类型：volMesh和surfaceMesh，这两种类型都继承自GeoMesh<fvMesh>。我想定义一个接受参数的函数：
void foo(GeometricField<vector, fvsPatchField, GeoMesh<fvMesh> >& field) { ... }
然而，当我尝试调用函数时，g++给出错误"invalid initialization of reference type“：
// surfaceVectorField is a typedef GeometricField<
浏览 5提问于2014-10-21得票数 1
1回答
C++标准库中的哪些模板(如果有)具有一个或多个模板模板参数？
如果有很多，那么几个例子就可以了。
如果C++版本很重要，那么C++14/C++1y的最新草案是首选。
浏览 1提问于2014-08-29得票数 8
2回答
以下代码()在clang/gcc上运行良好，但无法在icc和msvc上编译。
惟一的区别是在class A中使用模板参数包，而class B则显式地给出所有模板参数。
正确的行为是什么？代码不正确吗？我是不是遗漏了什么？还是仅仅因为msvc/icc不符合标准？
更新
经过测试的编译器版本：
作品：
gcc 4.7.3、4.8.1、4.8.2、4.9.0、4.9.2
clang 3.3、3.4.1、3.5.0、3.5.1、3.6.0rc2
不起作用：
msvc-12.0 (2013)更新4
icc-13.0.1
代码
#include <unordered_
浏览 4提问于2015-02-20得票数 5
3回答
我用gcc编译了以下代码：
template<typename... Pack>
auto func(Pack... x) {
return (x + ...) ;
}
template<typename... Pack>
auto lamd = [](Pack... x) {
return (x + ...) ;
};
我可以用func(1,2,3)调用函数模板，但是在使用lamd(1,2,3)或lamd<int>(1,2,3)调用lambda时会出现错误。
浏览 4提问于2019-06-24得票数 4
回答已采纳
我的编译器是gcc 4.9.0。无法编译下列代码：
template<typename T, T i>
struct value {};
template<typename T>
struct value<T, 0> {};
// error: type 'T' of template argument '0' depends on a template parameter
原因是什么？那么，如何解决这个问题呢？
浏览 4提问于2014-07-09得票数 3
回答已采纳
示例：
template <typename T, typename U>
struct A {
void Print() {}
};
template <>
void A<int, float>::Print() {} // Okay
template <typename T>
void A<T, char>::Print() {} // Will produce error
问题：
我知道您必须在上面的代码中定义类模板部分专门化才能使其工作，我还从标准中知道The members
浏览 0提问于2012-01-11得票数 4
例如：
template<unsigned number>
struct A
{
template<class T>
static void Fun()
{}
};
template<>
struct A<1>
{
template<class T>
static void Fun()
{
/* some code here. */
}
};
并希望专门化A<1>::Fun()
template<>
template<>
voi
浏览 0提问于2013-07-06得票数 2
回答已采纳
3回答
我正在尝试创建一个模板类来将用户与数据类型隔离开来。我更喜欢使用适配器类，但需要更改的函数签名需要一个模板。
在下面的代码示例中(不是实际的项目，只是说明问题的简化版本)，而在main例程中，我能够使用ob_traits接口。但是，当我尝试创建使用ob_traits作为基类的模板化StructWrapper时，我得到了错误，并且gcc无法识别所创建的IntAdapter类。这在MSVC 8.0上编译，但在gcc 4.1.2 20070626 ( Red hat 4.1.2-14)上失败
所以有两个问题首先，你知道为什么编译会失败，出现下面指定的错误吗？
其次，对于如何以更简单的方式实现这个概念
浏览 0提问于2008-11-05得票数 2
2回答
我有一个函数，我想将其用于字符串容器，比如vector<string>或set<string>。显然，模板化似乎是最好的解决方案，但我不确定如何模板化容器。我试过了，但不起作用： template<class T>
string pack_addrs(T<string>& caddrs) {
string res = "";
for (string addr : caddrs) {
res += addr + ",";
}
return res.substr(0, res.size
浏览 12提问于2020-12-02得票数 3
回答已采纳
考虑一下下面的结构：S是一个类模板，带有一个可变的模板类型参数包...Ts。该类包含一个具有单个模板参数C的嵌套类模板N。C本身使用了一个非类型模板参数的可变包作为模板，这些参数的类型正好是Ts...。
template <typename ...Ts>
struct S
{
template <template <Ts...> typename C>
struct N
{
C<42> c;
};
};
GCC以如下理由拒绝了c的声明：
error: expansion pattern
浏览 2提问于2020-11-26得票数 16
我的目标是实现一个结构模板，该模板可用于检测模板替换是否格式良好或将失败。一个用法示例是根据模板参数是否具有可比性来提供两个版本的模板函数。 如果一个人显式地为每个场景提供结构，例如是否存在模板类型的相等运算符，则可以非常容易地解决这个问题，如here所示。但是我没能实现一个可以接受(几乎)任意构造作为模板参数的结构。 到目前为止，我所达到的“最佳”方法是使用模板参数。它可以编译，但它不适合参数替换应该是格式良好的情况。 #include <iostream>
#include <type_traits>
template <typename T = void
浏览 11提问于2019-06-09得票数 0
回答已采纳
6回答
在C++模板的上下文中，专门化和实例化有什么区别。根据我到目前为止所读到的内容，以下是我对特殊化和实例化的理解。
template <typename T>
struct Struct
{
T x;
};
template<>
struct Struct <int> //specialization
{
//code
};
int main()
{
Struct <int> s; //specialized version comes into play
Struct <float> r; //
浏览 0提问于2010-10-12得票数 49
2回答
template<typename T, typename U = T>
struct Test{};
template<typename T>
void func(Test<T>){ //#1
}
int main(){
func(Test<int>{}); //#2
}
在标准中似乎没有提到模板参数所需的默认参数的情况。
在中
如果参数声明中指定了初始化器-子句，则此初始化-子句将用作默认参数。默认参数将用于调用，其中尾随参数缺少。
在本节中，规则明确描述何时为函数调用提供默认参数。但是，我还没有在标准中找到类似于上面描述何时
浏览 2提问于2020-07-13得票数 5
3回答
我们有一个叫做std::conditional的小的元编程奇迹，描述了。在同一参考文献中，它说一个可能的实现是
template<bool B, class T, class F>
struct conditional { typedef T type; };
template<class T, class F>
struct conditional<false, T, F> { typedef F type; };
所以如果我在代码中做了一些类似的事情
typename std::conditional<true,int,double>::t
浏览 0提问于2017-06-15得票数 14
3回答
我是C++的新手。在我的学习阶段，我遇到了以下问题。我正在尝试从一个类模板Queue派生一个类stack。编译器在stack的构造函数中引发以下错误
..\src\TrainingDay2.cpp:44:3: error: 'b' was not declared in this scope
b=a;
请帮助找出根本原因。
#include <iostream>
using std::cout;
using std::endl;
template<class T> class Queue //Base class
{
private:
T
浏览 0提问于2015-03-13得票数 2
考虑以下模板模板参数的用法...
#include <iostream>
template <typename X>
class A
{
X _t;
public:
A(X t)
:_t(t)
{
}
X GetValue()
{
return _t;
}
};
template <typename T, template <typename T> class C >
class B
{
C<T> _c;
public:
B(T
浏览 1提问于2008-11-24得票数 3
回答已采纳
考虑以下c++程序：
class A
{
protected:
int x;
};
template<typename X>
using B = A;
template<typename T>
class C : public B<T>
{
public:
void f()
{
x = 0;
}
};
int main()
{
}
当使用clang和gcc使用-std=c++17 -pedantic-errors作为编译选项进行编译时，它们的行为有所
浏览 0提问于2020-09-06得票数 2
回答已采纳
3回答
编译如下：
template <typename T = int>
struct Test {};
template <typename T> void foo(T& bar) {}
int main()
{
Test t;
foo<Test>(t);
}
但与
template <typename T = int>
struct Test {};
template <typename T> void foo(T& bar) {}
int main()
{
Test t;
foo<
浏览 10提问于2022-03-30得票数 3
1回答
我有以下代码：
template<typename T, typename U>
struct combine;
template<template<typename...> typename Tpl, typename... Ts, typename... Us>
struct combine< Tpl<Ts...>, Tpl<Us...> >
{
using type = Tpl<Ts..., Us...>;
};
template<size_t Ind, size_t Curr, typ
浏览 11提问于2022-10-14得票数 0
回答已采纳
2回答
这是静态断言技巧的一部分。我不能理解非专门化的类是如何工作的。有人能给我解释一下吗？
编辑:带有宏的完整代码：(摘自)
#ifndef STATICASSERT_HXX
#define STATICASSERT_HXX
/*
Lifted direct from:
Modern C++ Design: Generic Programming and Design Patterns Applied
Section 2.1
by Andrei Alexandrescu
*/
namespace ww
{
template<bool> class compile_time
浏览 2提问于2011-01-28得票数 1
回答已采纳
1回答
我有一个函数void f<int N>()。只使用模板参数1和2调用f，例如f<1>()和f<2>()，而我为这两个参数高效地专门化了f。f将永远不会被任何其他参数调用，但是我还是用通用N定义了f，只是为了“清晰”。问题:如果是这样的话，编译器还会实例化这个未使用的f<N>()**?**定义吗?我觉得这会造成代码膨胀，因为我有几十个这样的函数，它们位于程序的性能非常关键的领域。
(相反，我正在考虑注释f<N>()定义，并将其替换为一个空定义，即void f<N>(){})。
浏览 3提问于2015-01-05得票数 1
回答已采纳
以下C++代码：
template<typename State>
class Node
{
public:
typedef typename State::Move Move;
...
}
说：
缺少类型说明符- int假设。注意: C++不支持默认-int。
我搜索了错误消息，每个人都建议将typename关键字添加到typedef行中，在我的例子中，这已经存在了。我还能做什么？
浏览 1提问于2016-10-08得票数 0
回答已采纳
1回答
我实际上正在分析一些鳕鱼，我发现了这个
Ptr<UniformRandomVariable> m_yMinVar;
我有一些c语言的经验，但没有c++，我所理解的是，这行代码声明了一个调用m_yMinVar的指针，它是“类型”<UniformRandomVariable>，其中"UniformRandomVariable“必须是其他cpp文件中的类，但我真的不知道，
我想确切地知道Ptr是什么，因为我的文本编辑器将它识别为变量类型
还有"<>“我不确定那是什么
最后，如果有人能分享给我一个链接，我可以在那里看到运算符和不同类型的声明变量和编
浏览 4提问于2018-11-18得票数 1
1回答
转换匹配显式实例化函数模板
、、、、
考虑使用隐式构造函数的模板。
template<typename T>
struct X { X(T) { } };
而这个函数模板
template<typename T>
void func(X<T>) { }
即使我显式地实例化了func<T>()的T = int
template void func<int>(X<int>);
这样的对func的调用不会编译
func(1);
错误：
没有匹配函数调用“func”
我知道模板参数演绎在转换中不能很好地工作，但在本例中，我创建了func的显式实例化，因此不需要
浏览 2提问于2020-02-01得票数 4
回答已采纳
unique_ptr有一个选项可以选择数组类型--稍后使用正确的删除器(带有数组delete[])：
std::unique_ptr<std::string[]> up(new std::string[10]); // OK
unique_ptr类本身的定义包括这种类型的专门化(注意，T[]大括号靠近定义本身)：
template<typename T, typename D>
class unique_ptr<T[], D> { ... }
但是，它不是string[]或int[]本身是一个类型，所以应该按照定义将其模板化为T类型，而不是T[]？换句话说，
浏览 0提问于2015-09-14得票数 1
回答已采纳
3回答
我不明白为什么下面的代码不能编译。你们能帮帮我吗？
#include <iostream>
template <typename T, typename ...Args>
void foo(T i, Args ... args){
std::cout << i << std::endl;
foo(args...);
}
template <typename T>
void foo(T i){
std::cout << i << std::endl;
std::cout << &#
浏览 23提问于2021-02-16得票数 1
回答已采纳
2回答
我想定义一个模板类MyClass，其中模板参数必须是特定模板类的专门化。在本例中，我希望MyClass是一个模板类，它的第一个模板参数接受A的专门化，第二个模板参数接受B的专门化。然后，我可以实例化这个类如下：
MyClass<A<int, int>, B<double, int>>;
现在，您可能会说，“只需将A和B的参数作为MyClass的模板参数”。不幸的是，在我的情况下，A和B都是可变模板，因此MyClass的参数列表中不可能找到A模板参数的结尾和B模板参数的开头。
A和B的示例如下：
template <typename... Args>
浏览 6提问于2021-07-04得票数 0
1回答
请考虑以下课程：
class Foo
{
enum Flags {Bar, Baz, Bax};
template<Flags, class = void> struct Internal;
template<class unused> struct Internal<Bar, unused> {/* ... */};
template<class unused> struct Internal<Baz, unused> {/* ... */};
template<class unused> str
浏览 2提问于2010-07-18得票数 10
回答已采纳
1回答
考虑下一个示例：
#include <iostream>
template< int a >
void foo();
int main(int argn, char* argv[])
{
foo<1>();
}
template<>
void foo<1>()
{
std::cout<<1<<std::endl;
}
编译失败，并显示以下错误消息：
rg.cpp:12: error: specialization of ‘void foo() [with int a = 1]’ after
浏览 1提问于2011-05-06得票数 5
回答已采纳
3回答
模板类中的C++非专门化成员
、、、、
我有一个关于模板类的问题。例如，以下面的类为例
template<class TBase> class CTemplateInherit : public TBase
{
public:
virtual void DoNonSpecializedWork();
virtual void DoTemplateWork();
virtual ~CTemplateInherit();
};
// In header file
template<class TBase>
bool CTemplateInherit<TBase>::DoTe
浏览 0提问于2012-09-02得票数 2
回答已采纳
1回答
我已经仔细阅读了许多关于这个主题的答案，但我仍然不能准确地计算出这两个关键字在作为嵌套模板类成员的非模板函数的作用域中是不是需要的。
我的参考编译器是GNU g++ 4.9.2和clang 3.5.0。
在下面的代码中，它们的行为几乎没有什么不同，我在代码中嵌入了注释，试图解释发生了什么。
#include <iostream>
// a simple template class with a public member template struct
template <class Z>
class Pa
{
// anything
public:
tem
浏览 5提问于2015-09-03得票数 3
2回答
#include "boost/numeric/ublas/matrix.hpp"
using namespace boost::numeric::ublas;
template <class matrixform,class input_T>
class Layer
{
private:
matrixform <input_T>;
public:
};
我想要能做到
int main ()
{
Layer<identity_matrix, double> mylayer;
}
但
layer.hpp:18: error：‘matr
浏览 3提问于2010-08-14得票数 0
1回答
这语法不合法吗？
、、、
以下内容将不会在GCC 4.8.1上进行汇编：
//struct Tag {}; // Program compiles if I use this.
template <typename T>
struct Base {
struct Tag {};
Base(Tag) {}
};
template <typename T>
struct Derived : Base<T> {
Derived(Tag tag) : Base<T>(tag) {}
// Derived(Base<T>::Tag tag
浏览 1提问于2015-01-11得票数 1
回答已采纳
3回答
将模板化类传递给模板函数
、、、、
我有一个非类型的模板类：
template<int N> class MyClass; // prototype
和一个通用模板函数：
template<class T> Parameters validParams(); // prototype
在模板函数中使用非类型模板类的正确语法是什么？如果我不使用模板化类，那么正确的语法是：
template<> Parameters validParams<MyClass>(); // prototype
我已经看了一下，试图找出什么语法应该在这里，任何帮助都是赞赏的！如果是这样对我来说最有意义，但这
浏览 0提问于2017-07-19得票数 1
将要
std::is_empty<std::tuple<Args...>>::value
如果Args中的所有类型都为空，则返回true？gcc 4.9的快速测试表明情况确实如此，但这是标准所要求的吗？
浏览 1提问于2014-10-16得票数 4
回答已采纳
你好，我正在试着理解这段代码：
vector<int> a = {5, 3, 6, 1, 7};
sort(a.begin(), a.end(), greater<int>());
for(int i : a) cout << i << " "; cout << endl;
为什么我要把括号放在更大的后面。这个更大的结构是这样定义的：
/// One of the @link comparison_functors comparison functors@endlink.
template<typename
浏览 2提问于2021-06-13得票数 1
回答已采纳
1回答
最近，我不得不设计一个建立在另一个模板类之上的类。某种程度上：
template<
typename T1,
template <class> class A,
..>
class B {
A<T1> a1;
// other members;
public:
bool insert(T1 const & value);
bool update(T1 const & value);
bool delete(T1 const & value);
bool contains(T1 const
浏览 1提问于2015-01-11得票数 1
2回答
我有一个实现类似CRTP模式的模板类的层次结构。我不明白为什么名称查找在标记为错误的行中失败，而在标记为“这里没有错误”的行中成功。
class CPublishedTypes
{
public:
typedef int published_t;
};
template<class Derived, class PublishedTypes> class Cbase: public PublishedTypes
{
public:
Cbase():ibase_(42){}
private:
published_t i
浏览 1提问于2013-10-04得票数 2
1回答
C#泛型是如何工作的？
、、、
C++模板在编译时生成。我听说C#泛型是在运行时生成的。这意味着它是在IL ->执行时生成的？此部分是否也包含在运行时中？
浏览 0提问于2019-03-04得票数 1
回答已采纳
1回答
template<typename T>
struct a
{
using type = int;
typename T::type i;
};
template<typename T, typename = a<T>>
void f1(T) {}
template<typename T, typename = typename a<T>::type>
void f2(T) {}
int main()
{
f1<int>(1); // ok
f2<int>(1); // error
浏览 3提问于2018-06-15得票数 11
回答已采纳
请考虑以下几点：
#include <type_traits>
void f(int);
void g(auto ...);
static_assert(std::is_same_v<decltype(f), decltype(g<int>)>); // succeeds in GCC 12.1, Clang 14.0.0, and MSVC 19.30
指定函数的参数类型列表是函数类型的一部分(很明显)：
函数类型的一部分是返回类型、parameter-type-list，-ref-限定符、cv-限定符-seq和异常规范，而不是默认的参数或尾部的re
浏览 5提问于2022-05-25得票数 3
4回答
我是一名"C“程序员，只知道极少量的C++。我正在查看一些开放源码的C++代码，试图了解它正在做的一些事情。我可以解决大部分问题，但有时有一些语法我不认识，我希望能够“查找”语法的含义，这样我就可以阅读足够多的内容来理解那一小段C++。但你不能简单地在谷歌上输入一堆符号--或者其他任何东西来查找C++中的含义。有什么建议可以让我在一般情况下做到这一点吗？
我现在正在努力解决的具体语法如下：
void Blah<BOARD>::Generate(SgPoint p)
在这种情况下，<BOARD>的意义是什么？我应该查些什么才能理解它？
浏览 0提问于2010-10-05得票数 10
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
实时音视频
对象存储
即时通信 IM活动推荐
腾讯云开发者
