使用可变模板调用成员函数
是一种在编程中动态调用成员函数的技术。可变模板是C++11引入的特性，它允许我们在编译时处理不定数量的参数。
在使用可变模板调用成员函数时，我们可以通过递归展开参数包的方式来实现。首先，我们需要定义一个递归终止条件，当参数包为空时，递归结束。然后，我们可以使用递归展开参数包的方式，逐个调用成员函数。
下面是一个示例代码：
// 定义一个类
class MyClass {
public:
void func1() {
std::cout << "func1 called" << std::endl;
}
void func2(int arg) {
std::cout << "func2 called with arg: " << arg << std::endl;
}
void func3(const std::string& arg1, int arg2) {
std::cout << "func3 called with args: " << arg1 << ", " << arg2 << std::endl;
}
};
// 定义一个可变模板函数，用于调用成员函数
template<typename T, typename... Args>
void callMemberFunc(T&& obj, Args&&... args) {
obj.func1(); // 调用成员函数func1
// 递归展开参数包，依次调用成员函数
(obj.*std::forward<Args>(args))...;
}
int main() {
MyClass obj;
callMemberFunc(obj, &MyClass::func2, 42); // 调用成员函数func2
callMemberFunc(obj, &MyClass::func3, "hello", 123); // 调用成员函数func3
return 0;
}在上述示例中，我们定义了一个名为MyClass的类，其中包含了三个成员函数func1、func2和func3。然后，我们定义了一个名为callMemberFunc的可变模板函数，用于调用成员函数。在main函数中，我们创建了一个MyClass对象obj，并通过callMemberFunc函数调用了func2和func3成员函数。
使用可变模板调用成员函数的优势在于可以在编译时进行类型检查，并且可以动态地调用不同的成员函数。这种技术在很多场景下都非常有用，例如实现回调函数、事件处理等。
腾讯云提供了丰富的云计算产品和服务，其中包括云服务器、云数据库、云存储等。具体推荐的产品和产品介绍链接地址可以根据实际需求和使用场景进行选择。
相关·内容
2回答
我在C++中看到了下面的程序
template <class T>
class Val {
protected:
T x0, x;
public:
Val(T t = 1) : x0(t), x(1) {}
T val() { return x; }
void promote() { this->promote_value(); }
};
由于某种原因，即使没有方法Val<int>(4).val();，promote_value()也可以正常工作。我试图删除模板：
class OtherVal {
protected:
in
浏览 1提问于2019-07-04得票数 11
回答已采纳
2回答
我知道编译器不会实例化未使用的模板函数，只要它们在类中不是虚拟的。
在一个简单的例子中，如果我有两个重载的模板函数，它们都使用相同的模板参数，那么编译器似乎会实例化这两个重载。我想这是必需的，这样编译器才能执行过载解析？重载是否免于函数模板的延迟实例化规则？我无法在标准中找到相关的文本。下面是一个示例：
template<typename T>
void foo(T) {zzz}
template<typename T>
void foo(T*) {}
int main()
{
int* blah;
foo(blah);
}
如果没有实例化第一个重载
浏览 4提问于2014-11-19得票数 2
回答已采纳
有人能给我解释一下这段代码是怎么一步一步的吗？我在这个话题中找到了它：和我什么都不懂：
template <typename TNode, typename... TNodes>
auto execute(TNode& n, TNodes&... ns)
{
[&](){ n.execute(ns...); }();
}
特别是部分：[&](){ n.execute(ns...); }();
是否与lambda微积分和编程语言如caml或ocaml有任何联系？
提前谢谢你
浏览 3提问于2016-11-18得票数 0
回答已采纳
2回答
只替换成员函数的模板语法
、、、
我试图创建一个函数重载，因此它只绑定(工作)一个成员函数。我看了一下std::mem_fn 的函数签名
template <class Ret, class T>
/* unspecified */ mem_fn (Ret T::* pm);
所以我把我的参数构造成这样
template <typename R, typename F>
auto call_me(R C::* func) {
return (mContainer.*func);
}
但是，我得到了这个错误。
.\template.cpp: In function 'int main()&
浏览 5提问于2017-10-16得票数 1
回答已采纳
我正在尝试使用C++ 4.8.2 (Ubuntu14.04环境)编译g++脉冲国际象棋引擎。
在链接阶段，我得到以下错误：
Linking CXX executable pulse-
CMakeFiles/pulse.dir/main.cpp.o: In function `pulse::MoveGenerator::MoveGenerator()':
/home/user/cpp/movegenerator.h:15: undefined reference to `pulse::MoveList<pulse::MoveEntry>::MoveList()'
li
浏览 0提问于2014-11-17得票数 1
回答已采纳
3回答
GCC并没有对我所做的一个我希望它会出错的例子说错：
class CannotBeCopied {
public:
CannotBeCopied(const CannotBeCopied&) = delete;
CannotBeCopied& operator=(const CannotBeCopied&) =delete;
CannotBeCopied() { }
~CannotBeCopied() { }
};
template<class T>
class FirstVector {
public:
First
浏览 2提问于2015-02-18得票数 0
回答已采纳
#include <bits/stdc++.h>
using namespace std;
constexpr int mod = 1e9 + 7, maxn = 2e6;
int N, M, p[1 << 10], buf[maxn];
template <bool t> struct line {
int *v;
int operator[](int y) const;
};
template <> int line<0>::operator[](int y) const { return v[
浏览 6提问于2022-05-25得票数 2
回答已采纳
我正在编写一个C++11代码库，并想知道如何在传递任意参数的成员类型上调用任何函数。注意，由于我使用的是std::invoke.，所以不能使用像 C++11这样的东西
我开始在Outer类中创建一个函数模板，但是我的初次尝试给出了一个编译错误。
#include <iostream>
#include <utility>
#include <type_traits>
struct Inner {
void bar(int x) {
std::cout << "Called: x=" << x <&l
浏览 3提问于2020-02-19得票数 0
回答已采纳
6回答
是否有任何方法(内置或代码模式)来确保向可变函数传递正确数量的参数？(这将包含在API中，显然，我可以检查我自己的内部代码。)
我在考虑需要一个UN32幻数作为最后一个传递的参数，并检查它在可变函数中的有效性。有人对此有什么想法吗？
浏览 0提问于2011-07-26得票数 3
回答已采纳
3回答
D成员函数属性
、、
考虑：
class B
{
public:
int i = 4;
}
class A
{
public:
B b;
this()
{
b = new B;
}
ref B f()
{
return b;
}
}
成员函数f前面的ref存储类是多余的，对吗？类对象总是通过引用传递，所以返回B和ref B是等价的吗？
第二：pure成员函数？纯函数是只返回依赖于参数的内容。因此，它不应该依赖于类的任何数据成员，因为即使是传入的相同参数，它们也可能更改函数的输出。因此，pure成员函数也是stati
浏览 6提问于2011-12-26得票数 3
回答已采纳
1回答
struct A // some class
{
void method(); // non-static member method
static void function(); // static member method
};
void function(); // global function
vector<A> vi; // any such `std` like container
我想要有一个函数(比如Iterate())，它可以用下面的方式调用：
Iterate(vi, &A::method); // (1)
Iterate(vi, &
浏览 0提问于2012-12-29得票数 3
回答已采纳
我有一个日志记录函数，它使用“.”参数，并使用vsprintf_s创建最终输出字符串。
它工作得很好，只是我总是必须使用c_str()来打印字符串
起初，我认为这不是一个问题，但是在每个字符串变量之后添加所有这些.c_str()是很痛苦的，而我总是忘记它们。
我想也许一个C++大师可以在这个问题上启发我，有什么办法让我的日志功能自己来处理这个问题吗？
void Logger::print(const std::string fmt, ...)
{
va_list args;
int len;
char * buffer;
va_start(args, fmt);
浏览 2提问于2019-03-07得票数 0
我正试着开发一个简单的记录器。
我有一个具有以下原型的函数：
class Logger{
public:
std::unique_ptr<MyStream> & getLogger(string, string);
}
我想做这样的事
logger = Logger();
logger.log("INF", "HGH") << "My message" << endl;
为此，我重载了operator<<
template<typename T>
inline frien
浏览 1提问于2014-05-06得票数 0
回答已采纳
我正在努力理解，并在这个主题上找到了。
以紧凑的形式：
#include <tuple>
namespace sqlite {
namespace utility {
template<typename> struct function_traits;
template <typename Function>
struct function_traits : public function_traits<
decltype(&Function::operator(
浏览 2提问于2015-12-15得票数 2
回答已采纳
我有一个自定义记录器，它使用记录器->logf(format，...)用于日志记录的样式varargs方法。我有对象句柄，它是指针的包装器。我有一个特殊的格式说明符来打印对象(使用toString()方法，类似于Java)
“句柄”不是“简单可复制的”，因为它们可以从许多输入类型构造，并且具有转换器转换操作符，该操作符返回指向所包含的对象类型的指针。(类似于ComPtr<> )
在windows C++中，我只需传递句柄，varags方法就会看到指针。现在，GCC认为这是一个错误。句柄是"sizeof(void *)“
有没有办法让GCC在varags方法上允许这样做
浏览 0提问于2017-12-19得票数 2
我尝试使用QtConcurrent运行一个成员函数。我只是在学习c++和qt，我使用了我在他们的官方文档中找到的方式：。
mainWindow.cpp
#include "mainwindow.h"
#include "./ui_mainwindow.h"
#include "testclass.h"
#include <QtConcurrent>
#include <QFuture>
#include <QDebug>
#include <QThread>
void testFunction
浏览 6提问于2021-11-21得票数 0
就我所理解的RAII成语，当应用于一个类所需要的资源时(如果我错了，请纠正我)，一个需要资源的类应该定义一个适当类型的成员，当使用类实例被销毁时，它的析构函数将被自动调用，如下所示：
class Skybox
{
public:
Skybox() : tex_(...) {}
private:
Texture tex_;
};
除了使用智能指针在堆上分配资源之外，如果资源成员需要在资源初始化之前在Skybox构造函数中执行一些代码，如何应用此模式？例如：
class Skybox
{
public:
Skybox(con
浏览 0提问于2011-11-22得票数 4
回答已采纳
3回答
我有自己的固定大小数组类型，我希望可以从constexpr构建std::initializer_list，而不必显式定义size模板参数。
我想我可以使用模板演绎指南，但看起来它并没有将std::initializer_list::size()作为一个函数来处理。
下面是一个尝试为std::array (类似于我的类型并有相同问题)编写一个演绎指南的示例：
namespace std
{
template<typename T> array(initializer_list<T> initialiserList) -> array<T, initia
浏览 0提问于2019-01-06得票数 14
回答已采纳
1回答
多样性函数被废弃了吗？
、、、
既然C++11有可变模板函数，那么变量函数是否被废弃了？更具体地说，在特定的情况下，变量函数有什么优势吗？我知道各种宏都有它们的用途。各种函数呢？
浏览 2提问于2014-06-19得票数 2
回答已采纳
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
回答已采纳
3回答
我想到了这门课：
class Point
{
public:
int X, Y;
mutable int Z;
constexpr Point(int x, int y) :X (x), Y(y), Z(0)
{ }
constexpr int GetX() const
{
// Z++; // Wont compile, but following expression is valid!
return X+Z;
}
int GetY() const
{
Z++;
浏览 6提问于2016-08-09得票数 8
回答已采纳
1回答
在重载运算符时使用函数
、、、、
我目前正在开发一个游戏，以提高我的C++技能，我正在尝试使用更高级的概念，以便更多地了解语言本身。
我正在创建一副卡片，使用enum来存储值，并且想要重载<<操作符，以便有一种干净的方式打印所有内容。
//Card.h
private:
Value value;
Suit suit;
enum Value {
TWO = 2, THREE...
};
enum Suit {
DIAMONDS, SPADES, CLUBS, HEARTS
};
Card(Value value, Suit suit);
friend
浏览 7提问于2022-01-23得票数 0
有没有办法将成员函数作为参数传递给全局函数？我找到了，但它并没有真正解决我的问题。
假设我有以下全局函数：
double Function(double (*fEval)(double F1, double F2),double min, double max,int numArgs,...);
bool Function2(double (*fEval1)(double F1, double F2),double (*fEval2)(double F1, double F2),double xmin, double xmax, double ymin, double ymax,double
浏览 0提问于2012-05-05得票数 3
2回答
请考虑以下代码：
template <typename T>
struct Test
{
Test() = default;
explicit Test(const T& arg)
: m_member(arg)
{
}
T m_member{};
};
int main()
{
Test<int> t1;
int v2 = 34;
Test<int&> t2(v2); // (!)
ret
浏览 0提问于2019-09-03得票数 4
回答已采纳
假设我在C++中定义一个函数，如下所示：
void foo(int &x) const {
x = x+10;
}
假设我这样叫它：
int x = 5;
foo(x);
现在通常(没有const关键字)，从调用者的角度来看，这将成功地更改x的值，因为变量是通过引用传递的。const关键字会改变这一点吗？(即从调用者的角度来看，x的值现在是15吗？)
我想我搞不懂当const关键字被附加到函数定义的末尾时它会做什么……任何帮助都是非常感谢的。
浏览 0提问于2010-10-21得票数 1
回答已采纳
人们应该把最终的价值保存在哪里？
在StatefulWidget (当然是我的子类)实例中，并通过widget.thatFinalField从State (子类)访问它，或者
在State本身。我已经看过这两种方法了..。每个人都有什么优点和缺点吗？
浏览 4提问于2017-05-09得票数 10
回答已采纳
2回答
模板构造怪异
、、
可能重复：
继续我以前的，(我在编辑2中发现了这种情况)
在代码中简单地列出：
#include <iostream>
struct Printer
{
Printer() { std::cout << "secret code" << std::endl; }
};
template <class A>
struct Class
{
template <class B, class C>
Class(B arg)
{
C c; /* the 'secret code
浏览 2提问于2011-06-15得票数 1
回答已采纳
1回答
我在一些地方看到了在C++中使用std::array而不是C样式数组的建议，声称它是一种更好、更安全、没有开销的替代方案。请参见：
标准容器阵列..。没有任何空间管理超出它需要的东西，它的元素，..。换句话说，它就像一个没有问题的内置数组。()
然而，据我所知，作为一个模板容器，就程序大小而言，将有一个开销，因为它将为每个不同的N个数组实例生成代码。
假设我的程序在不同的地方使用std::array，对于N有几个不同的整数，这会导致代码膨胀吗？可以忽略不计？
对于一般的非类型模板参数，我应该担心这个吗？
浏览 1提问于2014-07-29得票数 35
回答已采纳
1回答
如何通过模板技术调用可能存在的成员函数，我不想使用虚拟方法，因为类是任意的。
例如：
class A {
void setValue(int value);
};
如何定义一个模板来调用类A的setValue (如果它存在的话)，否则什么也不做。
模板类似于：
template <typename T>
struct call_if_exist {
void invokeOrNot(T& a, int value){ // EXISTING: setValue
a.setValue(value);
}
}
template <t
浏览 3提问于2013-09-08得票数 1
回答已采纳
1回答
以下代码在GCC中运行良好，但无法在clang中编译：
#include <iostream>
#include <string>
template <typename T>
struct A {
template <typename C>
A(const C& c) { std::cout << "base" << std::endl; }
};
template <>
template <>
A<std::string>::A<std::stri
浏览 1提问于2018-04-16得票数 2
回答已采纳
5回答
我试图允许一个子类定义变量函数专门化。例如：
#include <iostream>
#include <vector>
#include <memory>
class BaseClass
{
public:
BaseClass() {};
virtual ~BaseClass() {};
template<typename GenericData>
void ReceiveData(GenericData &inData)
{
throw std::runtime_error(
浏览 6提问于2018-01-12得票数 0
回答已采纳
struct X{
template<class T>
X(){}
};
有没有可能瞬时生成这样的类型呢？
浏览 0提问于2011-06-04得票数 9
回答已采纳
1回答
“可变的用于指定成员不影响类的外部可见状态(通常用于互斥对象__、备注缓存、延迟评估和访问检测)。”。
这句话让我纳闷：
指导方针:记住“M&M规则”：用于成员变量、可变变量和互斥(或原子)，__。[参考: GotW #6a解决方案:Const-正确性，第1部分(更新为C ++11/14)]()
我理解为什么“M&M规则”适用于const-functions数据成员:允许std::mutex在锁定/解锁互斥数据成员的同时实现线程安全，但是“M&M规则”也适用于std::atomic数据成员吗？
浏览 4提问于2022-03-28得票数 1
回答已采纳
1回答
您可以将模板应用于C++CX中的引用类，也可以将其应用于普通类。显然，您不能将模板应用于委托并引用它，这样编译器就会根据需要多次实现它。您可以尝试在ref类中定义模板委托，但这样就不能将其设置为公共的，甚至是内部的，这就违背了您的目的。但是，您可以在本机类中引用委托实例。例如，您可以接受C++CX委托作为本机类的参数，也可以将其作为引用，但不能在类本身中定义类型。
有人知道如何让可变模板原生类使用并持有与模板的返回类型和可变参数匹配的WinRT/UWP委托吗？
这个模板将被完全编译成一个windows运行时组件，并且只需要在内部使用。
浏览 1提问于2015-11-26得票数 0
我有自己的Runnable类，可以存储函数指针、成员函数(可能是lambda)指针或函式，并以一种方式运行它。下面是它的简化版本：
template<typename returnType, typename... args>
class Runnable
{
private:
template<typename rreturnType, typename... aargs>
struct FuncBase
{
virtual returnType run(aargs...) const = 0;
virtual
浏览 0提问于2014-12-28得票数 0
回答已采纳
我正在学习c++模板技术。
我做了一个带有可变模板增强的构造器，如下所示。
这个类非常简单，所以它没有意义。但是，我无法调用该函数。编译器告诉我它不能直接调用构造函数。
我怎么能叫它呢？
#include <utility>
class TemplateVariadicAugments {
public:
template <typename FutureInnterTemplateClass, typename... Args>
TemplateVariadicAugments(Args&&... args) : value_(st
浏览 10提问于2017-01-19得票数 1
回答已采纳
1回答
重载C++模板类虚函数
、、、、
下面是重现我遇到的问题的代码。Base类是一个具有虚函数foo的模板类。foo有一个添加传入参数的默认实现。
SimpleDerived是从Base派生出来的，用std::string对其进行了专门化。SimpleDerived重载虚拟Base<T>::foo()函数。当在main中调用时，这个类可以很好地编译，并且它的foo输出是预期的。
#include <iostream>
template<class T>
struct Base
{
virtual void foo(T val)
{
T local = val +
浏览 0提问于2013-06-15得票数 6
回答已采纳
2回答
如何调用模板类的模板ctor？
、、、、
template<typename T>
struct A
{
template<typename U>
A() {}
template<typename U>
static void f() {}
};
int main()
{
A<int>::f<int>(); // ok
auto a = A<int><double>(); // error C2062: type 'double' unexpected
}
这个问题在代码中是不言而喻的
浏览 5提问于2017-05-05得票数 4
回答已采纳
当将std::unique_ptr移动到lambda中时，不可能在其上调用reset()，因为它似乎是const：
error C2662: void std::unique_ptr<int,std::default_delete<_Ty>>::reset(int *) noexcept': cannot convert 'this' pointer from 'const std::unique_ptr<int,std::default_delete<_Ty>>' to 'std::unique_
浏览 0提问于2019-07-04得票数 35
回答已采纳
2回答
struct Value {
using a_type = int;
a_type f() { return 1; }
};
template<typename T>
struct Wrapper {
T t;
auto call_f() { return t.f(); }
};
int main() {
Wrapper<Value> w;
Wrapper<int> w2;
w.call_f();
}
这是很好的关于Clang和GCC的。Wrapper<int>被实例化，即使不能推断Wr
浏览 5提问于2016-08-08得票数 4
回答已采纳
1回答
我们都知道C++类模板不会生成未使用的成员函数，如下所示：
template<typename T>
class A
{
public:
void WrongFunction(T t);
void RightFunction(T t);
};
template<typename T>
void A<T>::WrongFunction(T t)
{
std::vector<T> v;
auto a = "abc" - v;
}
template<typename T>
void
浏览 0提问于2015-04-21得票数 3
回答已采纳
我从上读到
根据数字类型的不同，精度可以任意大(仅受可用内存的限制)、在编译时固定(例如，50或100小数位)或由成员函数在运行时控制的变量。这些类型是支持表达式模板的，比简单的用户定义类型具有更好的性能.
我阅读了一些更多的文档，但没有发现任何关于在运行时更改精度的内容。我只看到了允许我在编译时设置精度的模板，这不是我想要的(我想创建一个使用非常高的缩放因子来缩放分形的程序)。
如何创建允许在运行时更改其精度的双重类型？
浏览 1提问于2015-11-21得票数 4
回答已采纳
3回答
我有一个如下的程序：
int main()
{
int val = 4;
auto add = [val](int a)->int{
val += 2;
return a+val;
};
cout << add(3) << endl;
cout << val << endl;
return 0;
}
Xcode中有一个编译错误:不能赋值给不可变lambda中由copy捕获的变量。
我的问题是:如果我们选择使用副本(使用"=“或值名)，这个值不能被分配一个
浏览 0提问于2014-09-14得票数 16
回答已采纳
我当时在玩C++，我对此感到困惑：
非类型模板参数cppreference.com 必须是结构类型，而文字类类型是结构类型的示例。然后，它“文字类型是类型的常数变量，他们可以被构造，操作，并返回从常数函数”(强调地雷)。(函数的返回类型必须是文字类型。)
因此，我的理解是，可以从函数返回，暗示是文字类型，暗示是结构化类型，暗示可以用作非类型的模板参数。
但是，std::optional似乎可以从constexpr函数(下面的bar)返回，但不能用作非类型模板参数(下面的foo)。到底怎么回事？
#include <optional>
template <std::option
浏览 2提问于2021-12-19得票数 0
回答已采纳
2回答
以下代码无法按预期编译：
#include<iostream>
class Enclosing {
int x;
class Nested { int y; };
void EnclosingFun(Nested *n) {
std::cout << n->y; // Compiler Error: y is private in Nested
}
};
但是，如果我将EnclosingFun转换为模板成员函数，编译器(gcc-7)不会抱怨访问y：
#include<iostream>
class E
浏览 0提问于2018-03-11得票数 3
回答已采纳
第23项的有效C++ (第三版)由斯科特迈尔斯标题为：“更喜欢非会员的非朋友功能比成员的功能”。我理解Scott的意图是，只要一个函数可以按照现有的最小成员函数来实现，它就应该是独立的。
然而，我今天看到了一种观点，即拥有一个独立的函数来调用一个改变状态的成员函数是一种糟糕的做法。这一意见基本上是说，所有独立的职能都应该是纯的。这是一个普遍的理解，还是我最初的理解也是正当的？
浏览 0提问于2016-02-17得票数 4
1回答
我有一个模板类，包含各种参数列表：
template<class ...Args>
struct Data{
};
现在，我希望有带有各种“通用引用”参数列表的构造函数，因此我将构造函数设置为模板：
template<class ...Args>
struct Data{
template<class ...CtrArgs>
Data(CtrArgs&& ... args){
// do something
}
};
现在我想做一个Data的实例
Data<int, MyClass, bool
浏览 2提问于2014-07-24得票数 1
回答已采纳
4回答
我有一个这样的类：
template<class T> class A : public T {
// this is done to wrap the base class version of a virtual function
virtual void F(int i) {
if(i < 0) T::F(-i);
else T::F(i);
}
//...
对于基类可以用来构造的任何一组参数，它必须是可构造的：
template <typename T1> A(T1 t1) : T(t1) {}
template <typename
浏览 7提问于2010-09-14得票数 1
回答已采纳
与可变函数模板方法相比，通过::std::initializer_list传递多个参数有什么优势吗？
在代码中：
template <typename T> void f(::std::initializer_list<T> const);
template <typename ...A> void f(A&& ...args);
请注意，通过SFINAE或static_assert()，也可以将A...类型限制为单一类型。参数可以遍历...
浏览 1提问于2016-05-10得票数 5
我尝试实现了一个不完全相同但非常类似的make_array版本：
我发现这段代码似乎不能工作，我说的对吗？
using MyType = std::pair<int, float>;
constexpr auto the_array = make_array<MyType>({1, 7.5f});
这里的问题似乎是，即使make_array显式地指定了第一个模板参数，参数仍然来自参数包，这与显式指定的参数无关。
这意味着代码将无法工作。
有没有什么解决方案可以让上面的代码正常工作？
我的版本
template <class Val = void, class.
浏览 14提问于2016-08-19得票数 1
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
实时音视频
即时通信 IM
对象存储活动推荐
腾讯云开发者
