将非类型模板参数放入元组
是指在C++编程中，可以使用元组（tuple）来存储非类型模板参数的值。元组是一个固定大小的、异构的、可变长的数据结构，可以存储多个不同类型的值。
非类型模板参数是指在模板中使用的常量值，而不是类型。它可以是整数、枚举、指针、引用等常量表达式。通过将非类型模板参数放入元组，可以方便地对这些参数进行管理和操作。
元组的优势在于它可以存储多个不同类型的值，并且可以通过索引或者使用std::get函数来访问和修改这些值。使用元组可以简化代码，提高代码的可读性和可维护性。
应用场景：
- 在编写通用的库或框架时，可以使用元组来存储和传递非类型模板参数，以支持更灵活的使用方式。
- 在编写模板元编程（TMP）时，可以使用元组来存储和处理非类型模板参数，以实现更复杂的编译时计算和类型推导。
- 在编写测试代码时，可以使用元组来存储测试数据和期望结果，以方便进行测试用例的管理和执行。
腾讯云相关产品推荐： 腾讯云提供了多个与云计算相关的产品和服务，以下是一些推荐的产品和产品介绍链接地址：
- 云服务器（CVM）：提供弹性、安全、稳定的云服务器实例，支持多种操作系统和应用场景。详情请参考：https://cloud.tencent.com/product/cvm
- 云数据库MySQL版（CDB）：提供高性能、可扩展的云数据库服务，支持自动备份、容灾、监控等功能。详情请参考：https://cloud.tencent.com/product/cdb_mysql
- 人工智能平台（AI Lab）：提供丰富的人工智能开发工具和服务，包括图像识别、语音识别、自然语言处理等功能。详情请参考：https://cloud.tencent.com/product/ailab
- 云存储（COS）：提供安全、可靠的对象存储服务，支持海量数据存储和访问。详情请参考：https://cloud.tencent.com/product/cos
请注意，以上推荐的产品和链接仅供参考，具体选择和使用需根据实际需求进行评估和决策。
相关·内容
据我所知，模板值需要在编译时知道。所以我写了一个小例子，看看我得到了它，但很明显我没有。所以我得到了这个：
`defValue' cannot appear in a constant-
expression
谁能告诉我这个问题是什么，以及如何解决它？
#include <iostream>
template <class T,T defaultVal, int dim=255>
class Vec
{
T _vec[dim];
int _dim;
public:
Vec () : _dim(dim)
{
浏览 2提问于2010-10-02得票数 3
回答已采纳
1回答
我有以下代码：
#include <concepts>
//Fibo Begins
template <std::unsigned_integral num>
struct Fibo {
constexpr static std::size_t value = Fibo<num - 1>::value + Fibo<num - 2>::value;
};
template <>
struct Fibo<1> {
constexpr static st
浏览 5提问于2022-01-23得票数 1
回答已采纳
1回答
如果我创建了一个指向基成员的指针，我通常可以将它转换为指向派生成员的指针，但当在下面的Buzz这样的模板中使用时就不能了，因为第一个模板参数会影响第二个模板参数。我是在与编译器bug作斗争，还是标准真的要求这样做不起作用？
struct Foo
{
int x;
};
struct Bar : public Foo
{
};
template<class T, int T::* z>
struct Buzz
{
};
static int Bar::* const workaround = &Foo::x;
int main()
{
// This
浏览 0提问于2010-10-27得票数 5
回答已采纳
2回答
可能重复：
为什么第一个声明是可以的，而第二个声明不是？为什么std::string不合适？
template <typename T, T x> struct foo { };
using namespace std;
int main()
{
foo<int, 0> f_int; // ok
foo<string, ""> f_string; // not ok
}
我得到：
error: a non-type template parameter cannot have
浏览 1提问于2012-11-24得票数 3
回答已采纳
我有两个版本的my_begin
template<typename T, typename std::enable_if<std::is_array<T>::value>::type* = 0>
typename std::decay<T>::type my_begin(T& array) {
return array;
}
和
template<typename T>
typename std::decay<T>::type my_begin(T& array,
typename
浏览 4提问于2014-10-10得票数 3
回答已采纳
3回答
我有以下代码：
template<int k>
void foo()
{
}
int main(int argc, char* argv[])
{
int k = 1000;
foo<k>();
return 0;
}
它不会编译，但如果我将k声明为const，它就会编译：
template<int k>
void foo()
{
}
int main(int argc, char* argv[])
{
const int k = 1000;
foo<k>();
return 0;
}
现在，我明白
浏览 2提问于2011-11-23得票数 5
回答已采纳
我想要创建一个模板，在那里我可以使用不同的向量类型，和常量作为相同类型的向量。我希望能够将常量作为模板参数传递，以便让编译器对其进行优化，而不需要显式的专门化。
所以我试着重复使用类型参数，但是我得到了非法类型。
#include <vector>
using namespace std;
template<typename WEIGHT, WEIGHT multiplier>
void test_multipier(vector<WEIGHT> &v)
{
uint16_t num = 16;
/*...*/
WEIGHT
浏览 5提问于2015-10-01得票数 0
回答已采纳
1回答
为什么下面的代码是错误的？模板接受哪种类型的参数？
class MyClass
{
int var;
};
template <MyClass a> struct s
{
};
int main()
{
MyClass var;
struct s<var>;
return 0;
}
浏览 0提问于2013-03-02得票数 0
回答已采纳
我一直在试验C++中的函数类型。注意，我指的不是像这样的指向函数的指针类型：
typedef void (*voidFuncPtr)();
但更具异国情调：
typedef void (voidFunc)();
我没想到下面的代码会被编译，但令人惊讶的是，它做到了：
template<voidFunc func>
class funcClass
{
public:
void call() { func(); };
};
void func()
{ }
void Test()
{
funcClass<func> foobar;
foobar.c
浏览 1提问于2012-10-20得票数 4
回答已采纳
3回答
用template <int N>定义模板意味着什么，我从一本书中的一个例子中读到：
typedef map<int, double> row;
template <int N> struct matrix;
{
map <int, row> my_matrix;
}
我通常看到模板后面跟着类，然后键入，即template <class int>
浏览 3提问于2014-07-16得票数 3
回答已采纳
1回答
代码取自Partial template function specialization with enable_if: make default implementation。我期望对dummy(5)的调用在“通用”重载和“整型”重载之间是模棱两可的，因为在这两种情况下，T都被推导为int。第二个参数在两种情况下都解析为void。在对dummy(5)的调用中，它们不是同样“排名”吗？编译器如何选择“通用”版本？ #include <iostream>
template<typename T, typename Enable = void>
void dummy(T
浏览 20提问于2021-07-24得票数 4
回答已采纳
有了即将推出的C++17特性，是否有可能实现std::function，例如，能够提供以下功能：
bool f(int n, double d) {}
bool g(bool b, char c) {}
bool h(bool b) {}
转换为自动模板化的std::function对象：
std::function<bool(auto, auto)> faa = f; // ok
std::function<bool(int, auto)> fia = f; // ok
std::f
浏览 2提问于2016-09-27得票数 9
回答已采纳
最近，我遇到了一个有趣的enable_if用法版本，可以有条件地启用一个可读性稍好的函数，因为该函数的返回类型不是enable_if的一部分(参见cleaner_usage)：
#include <type_traits>
using maybe_integral = int /* = or float -- then won't compile */;
using return_type = int;
typename std::enable_if<std::is_integral<maybe_integral>::value, return_typ
浏览 2提问于2015-08-26得票数 4
回答已采纳
3回答
在C++模板术语中，我们有非类型模板参数、类型模板参数和模板参数(然后是带有参数的相同列表)。
为什么叫“非类型”？这不是一种价值吗？它不应该是“值模板参数”吗？
如果我认为它们是值模板参数，我会错过什么吗？
注意:出于好奇，我查看了D语言的文档，他们称它为值。
浏览 3提问于2014-11-11得票数 13
回答已采纳
2回答
在C++中以空指针作为模板参数
、、、、
以下内容未进行汇编：
template<void *p>
class X {
// ...
};
int r;
int main()
{
X<&r> x;
return 0;
}
错误信息是
x.cc:10:6:错误:无法将模板参数“&r”转换为“无效*”
显式地将&r转换为(void *)也于事无补。错误消息如下：
x.cc:10:14:错误:无法将模板参数‘(void*)(&r)’转换为‘void*’
标准的哪一部分规定了这种行为？GCC版本是gcc版本5.2.1 20151003 (Ubuntu
浏览 2提问于2015-10-13得票数 11
3回答
考虑以下代码：
struct A {
constexpr operator int() { return 42; }
};
template <int>
void foo() {}
void bar(A a) {
foo<a>();
}
int main() {
foo<A{}>();
const int i = 42;
foo<i>(); // (1)
A a{};
static_assert(i == a, "");
bar(a);
foo&
浏览 7提问于2015-11-27得票数 5
回答已采纳
在C++中，以下操作是合法的：
template <int i>
run(){...}
run<3>(); // legal
const int j=3;
run<j>(); // legal because j is const
为什么以下内容是合法的或不合法的？
template <String s>
run(){...}
run<"hello">(); // legal or illegal?
const string s="hello";
run<s>(); // legal
浏览 0提问于2016-03-18得票数 0
我试着做这个模板实例化，但它不起作用。我发现了错误：
prog.cpp:7:15: error: template-id 'f<const A&, A()>' for 'void f()' does not match any template declaration
template <class T, T> void f() {}
struct A {};
template void f<const A &, A()>();
int main() {}
这很奇怪，因为当我主要做这件事时，它会起
浏览 1提问于2013-01-04得票数 2
回答已采纳
是否可以为模板非类型参数赋值？
例如
template<int N>
void foo(){
N = 4;
}
尝试编译这个代码时，我得到了：
error: lvalue required as left operand of assignment
N = 4;
^
什么样的值(Value Category)是模板参数，在函数体中可以“玩”多少？(例如，读取它们、写入它们、将它们转发到其他模板参数、打印它们等)。
例如，创建一个“注册”一个数字(在编译时作为模板参数传递)并在每次调用时(在运行时)打印该数字的函数模板，正确的方法是什么？
浏览 4提问于2019-04-25得票数 0
template <typename Foo, Foo Part>
struct TSelect {};
enum What {
The
};
template <typename Foo>
struct AnotherOneSelector {
static constexpr Foo Id = Foo::The;
};
template <typename Foo, typename SelectPartType>
struct THelper;
template <typename Foo>
struct THelp
浏览 3提问于2018-07-01得票数 12
回答已采纳
1回答
我有下面的示例代码，它们在Visual中编译得很好，但在GCC 6中没有编译。我理解它可能与模板参数推导失败有关，但我想不出一个正确的解决方案来解决这个问题。
#include <iostream>
#include <array>
//using namespace std;
namespace
{
template <int T>
std::array<char, T> operator&(const std::array<char, T>& l, const std::array<cha
浏览 0提问于2019-02-23得票数 1
回答已采纳
1回答
我试图使用模板元编程来实现正弦函数。然而，我得到的错误'radtest‘不是一个有效的模板参数的双重&因为在cv-资格冲突。以下是代码：
#include <iostream>
using namespace std;
template <double&, int, int> struct
Series;
template <double& rad> struct Sine
{
enum
{
maxterms=10
};
static inline doub
浏览 6提问于2017-05-16得票数 1
回答已采纳
1回答
我编写了以下隐藏成员函数模板的代码。
#include <iostream>
struct A
{
template<int> void func()
{
std::cout<<"Function tamplate of A"<<std::endl;
}
};
struct B : A
{
template<char> void func()
{
std::cout<<"Function tamplate of B
浏览 1提问于2017-10-16得票数 23
回答已采纳
2回答
在第14章(模板)中的C++标准中，它引用了几个不同名称的模板参数，这取决于它们的上下文。
非类型参数
template<int N>
class foo {};
模板参数
template<typename T>
class bar {};
类型参数
?????
在下面的引语中，看起来这是三种截然不同的东西，但是我不知道类型参数是什么？
14.1模板参数temp.param
9 ..。可以为不是模板参数包(14.5.3)的任何类型的模板参数(类型、非类型、模板)指定默认模板参数参数。..。
您可以在这里看到，它有三个不同的名称模板参数。如果templat
浏览 4提问于2013-03-12得票数 4
回答已采纳
如何在c++中获取某个类型的“嵌套”模板参数的数量？ 我想写一个返回T的模板参数数量的函数GetNumberOfTypes<T>() constexpr int a = GetNumberOfTypes<int>(); //a == 0
constexpr int b = GetNumberOfTypes<std::vector<int>>(); //b == 1
constexpr int c = GetNumberOfTypes<std::tuple<int,int>>(); //c == 2 这能以某种方式实现吗？
浏览 9提问于2021-04-14得票数 2
回答已采纳
给定以下类： template<typename BoringArg1 = int,
typename BoringArg2 = char,
typename ThisDefinitionIsSoLong = int,
typename WhoWroteThis = double>
class A {
// ...
}; 现在我想继承A，保持它的模板化： template<typename BoringArg1 = int,
typename BoringArg2 = char,
浏览 5提问于2021-01-29得票数 2
回答已采纳
1回答
这就是我一直坚持使用的代码片段。
template <class T, T nt>
class C;
struct base{
int i;
} b;
struct derived : base{} d;
C<base*,&d> obj;
为什么会出现这个错误could not convert template argument &d to base*
浏览 1提问于2011-04-27得票数 5
回答已采纳
在我的程序中，我使用的是自制的FFT。为了提高性能，我尝试使用模板在编译时计算复杂的因素。代码中产生错误的部分是
typedef std::complex<double> Complex;
typedef std::valarray<Complex> CArray;
void fft(CArray& x){
const size_t N = x.size();
if(N==1){return;}
CArray even = x[std::slice(0,N/2,2)];
CArray odd = x[std::slice(1,
浏览 6提问于2014-05-21得票数 0
1回答
我有以下类，它包装了一个成员函数：
#include <cstdio>
#include <type_traits>
#include <utility>
using namespace std;
class testclass {
public:
double get() { return d_; }
void set(double d) { d_ = d; }
double d_ = 0.0;
};
template<typename Retriever, Retriever retrieverFunc, typena
浏览 6提问于2022-07-10得票数 1
回答已采纳
2回答
为GUID值专门化模板
、、、
这是的后续
库中的头声明类GUID，如下所示
static const GUID CLSID_EH264VD =
{ 0x96b9d0ed, 0x8d13, 0x4171, { 0xa9, 0x83, 0xb8, 0x4d, 0x88, 0xd6, 0x27, 0xbe } };
我想编写一个直接从dll创建对象的函数，而不需要注册dll，因此我需要将每个CLSID映射到dll名称。就像这样
Create<CLSID_EH264VD>()
这将取决于专门化，例如
template<>
struct dll<CLSID_EH264VD>
{
char
浏览 5提问于2013-03-14得票数 3
回答已采纳
1回答
我尝试使用一个非类型模板参数，它的类型是一个模板实例，如下所示：
template<size_t num> class BitValue { ... };
class Foo {
// works
template<template<size_t> class BitValue, size_t num>
bool get(BitValue<num> && t) { ... }
// fails
template<typename T> bool
template<Bitvalue<
浏览 0提问于2015-04-10得票数 1
1回答
下面的C++11代码使用g++ 4.7.4、g++ 4.8.5、g++ 4.9.3和g++ 5.3.0编译，但没有使用clang++ 3.7.1或clang++ 3.8.0 (主干254750)：
template <typename F, F f> struct MetaValue {};
template <typename T> class IntSpec;
template <int V> class IntSpec<MetaValue<int, V> > {};
// note: template is declared
浏览 7提问于2016-03-16得票数 2
回答已采纳
我在玩SFINAE的时候发现了一些我无法解释的行为。
此
template<typename Integer,
std::enable_if_t<std::is_integral<Integer>::value>* = nullptr>
void foo(Integer) {}
template<typename Floating,
std::enable_if_t<std::is_floating_point<Floating>::value>* = nullptr>
void fo
浏览 48提问于2018-06-09得票数 23
回答已采纳
2回答
当我阅读mnist的源代码时，我会发现下面的代码。Tuple[type1, type2, ...]意味着元组包括类型，如type1 type2。为什么这里有双倍的？谢谢你的回答！
def __getitem__(self, index: int) -> Tuple[Any, Any]:
"""
Args:
index (int): Index
Returns:
tuple: (image, target) where target is index of th
浏览 0提问于2022-08-13得票数 0
2回答
为什么使用局部变量作为非类型参数是非法的？
例如，在下一段代码中，local_var不能作为X的参数。
template<int& x> struct X {};
void f(int local_var)
{
X<local_var> x;
}
浏览 0提问于2013-06-28得票数 6
回答已采纳
1回答
在我研究的模板中，我们只能有整型参数，即int，指向其他数据类型的指针，还有模板模板参数。
但在这里，我可以只传递一个简单的类，也可以作为模板参数。这是有效的还是我所理解的是错误的。这是一段代码。
template <typename T>
class A {
public:
T t;
};
class B {
public:
float f;
};
template <template<typename> class X, class H>
class C {
pu
浏览 0提问于2013-05-20得票数 1
回答已采纳
2回答
我有这个问题：
template <void (*F)(int)> struct FunctionWrapper // This compiles and works
{
static void call_it()
{
F(0);
}
};
class MyClass
{
public:
static void callMe(int k)
{
}
};
template <void (MyClass::*F)(int)> struct FunctionWrapper // Error - F in
浏览 0提问于2013-03-02得票数 2
回答已采纳
1回答
目标是创建一种“智能getter”，如果当前对象存在，则从当前对象获取值，如果不存在，则在父对象中查找该值。
因此，这个ValueGetter类包含指向包含它的对象的指针(在构造函数中作为运行时参数获取它)，以及指向它作为模板参数操作的成员的指针。
这是最简单的例子：
template <class StyleType, int StyleType::*value>
struct ValueGetter
{
ValueGetter(StyleType* containedIn);
int get();
// Looks if the value is present i
浏览 3提问于2013-05-21得票数 0
回答已采纳
我试图理解作为模板参数的“函数类型”和“函数指针”之间的区别，以及何时应用什么。或者，有什么区别？
简单的例子：
template <int Function(int)>
struct S1 {
//....
};
template <int (*Function)(int)>
struct S2 {
//....
};
int always42(int) {
return 42;
}
int main() {
S1<always42> s1;
S2<always42> s2;
//....
浏览 2提问于2020-04-12得票数 3
回答已采纳
2回答
为什么下面的代码没有在gcc或clang下编译：
class Foo {
public:
void bar(int) {}
};
template< class T, typename ...Args, void(T::*Member)(Args...) >
void member_dispatch(Args&&... args, void* userdata)
{
T* obj = static_cast<T*>(userdata);
(obj->*Member)(std::forward<Args>(arg
浏览 0提问于2018-03-24得票数 1
回答已采纳
下面的代码是我试图为客户需求实现的一个功能的简化的最小版本。
它无法在IBM编译器(version 9和version 11 )上编译，并出现错误A non-type template parameter cannot have type "int X::*".。然而，我已经在g++ 4.7.2，clang++ 3.2和Intel13.0上尝试了相同的代码，他们成功地编译了它。
我很想知道XLC是这里唯一明智的声音，还是其他编译器是正确的？
struct X {
X() : y(123) {}
int y;
};
struct XFoo {
typede
浏览 1提问于2013-02-05得票数 0
回答已采纳
1回答
为什么作为非类型参数传递的参数应该是全局的而不是局部的？不是只在编译时创建和分配内存吗？
在这种情况下，p是一个常量指针，所以它不能指向任何其他变量，那么它也给出了error.Why？
template<int* ptr>
class A{};
int x;
int *const p = &x;
int main() {
x = 9;
A<&x> ob;
A<p> ob2;//giving error
cin.get();
}
另外，为什么只允许整型作为非类型参数，而不允许使用char或float？
浏览 3提问于2013-05-23得票数 4
回答已采纳
1回答
在下面的代码中，我传递了类类型R和该类型的常量表达式作为模板参数。但是clang不接受这样的说法：
#include <iostream>
template<class T, T t>
void foo(){ std::cout << "foo()" << std::endl; }
class R
{
public:
int f;
constexpr R(): f(15){ }
};
constexpr R r;
int main(){ foo<R, r>(); } //note: candid
浏览 2提问于2015-02-07得票数 2
回答已采纳
4回答
对参数使用模板语法
、、、
请注意下面的std::get函数语法：
std::tuple <int, double, long &, const char *> bar(18, 6.5, 12, "Hello!");
cout << std::get<2>(bar); // Print the tuple’s third element.
我不熟悉这种语法..。
这是使用模板语法传递参数吗？
如果是，请提供一个std::get如何工作的简单示例。
浏览 4提问于2013-08-15得票数 0
回答已采纳
我发现gcc和clang允许在非类型模板参数类型子句中使用decltype(auto)。例如：
template <decltype(auto)>
struct X {};
int foo ;
int main() {
X<(foo)> x;
static_cast<void>(x);
}
它是符合标准的特性，还是一些？
浏览 4提问于2017-09-03得票数 45
回答已采纳
2回答
在这个27:35的中，Bryce Lelbach给出了以下示例：
template<auto... Dims>
struct dimensions {};
struct dynamic_extent {};
constexpr dynamic_extent dyn = {};
dimensions<64, dyn, 32> d;
此代码不编译。GCC抱怨说：
<source>:8:27: error: 'struct dynamic_extent' is not a valid type for a template non-type p
浏览 1提问于2018-06-21得票数 7
回答已采纳
1回答
GCC:函数包装模板的问题
、、、、
我正在GCC 5.3上试着让一些函数包装程序代码在clang上工作得很好。下面是一个简化的示例：
#include <iostream>
using namespace std;
template<class Sig, Sig F>
struct FunctionWrapper;
template<class Ret, class... Args, Ret (*Func)(Args...)>
struct FunctionWrapper<Ret(Args...), Func>
{
};
static int testFunc(int _a
浏览 1提问于2016-06-06得票数 5
1回答
是否可以使用特征来推断模板参数是Value还是Type？
template <typename A>
void function(){
if(is_value<A>()::value)
cout<<"A is value"<<endl;
else
cout<<"A is type"<<endl;
}
int main(){
function<int>();
function<3>();
}
输出
&#
浏览 0提问于2013-06-29得票数 2
回答已采纳
5回答
可能重复：
我有一节课：
template<typename ValueType, ValueType DefaultValue>
class SomeClass
{
public:
SomeClass() : m_value(DefaultValue){}
ValueType m_value;
};
我想这样用它：
SomeClass<int, 1> intObj; //ok
SomeClass<float, 1.f> floatObj; //error: 'float' : illega
浏览 6提问于2013-01-10得票数 3
回答已采纳
3回答
我知道在C++中，泛型实际上并不存在，但是您可以使用template来模拟它。当您构建代码时，编译器会对代码进行预处理，并生成一个新代码，替换为对象声明中指定的实际值的泛型值，然后是真正编译的新代码。例如，假设类A如下所示：
template<class T>
class A
{
T f();
};
然后在代码中的其他地方，我们有A<int> a;。实际编译的代码是：
class A
{
//Replaces T by int in the pre-processing
int f();
};
在这整个介绍之后，让我们讲到重点。
我的问题是：
浏览 0提问于2013-03-22得票数 0
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
实时音视频
即时通信 IM活动推荐
腾讯云开发者
