如何让C++推断我的模板typename参数？
在C++中，可以通过使用auto关键字和decltype关键字来帮助编译器推断模板的typename参数。
- 使用
auto关键字：可以将模板的typename参数替换为auto，让编译器根据函数参数的类型推断出模板参数的类型。例如：
template <auto N>
void printValue() {
std::cout << N << std::endl;
}
int main() {
printValue<42>(); // 编译器会推断出模板参数的类型为int
printValue<3.14>(); // 编译器会推断出模板参数的类型为double
return 0;
}- 使用
decltype关键字：可以使用decltype关键字获取表达式的类型，并将其作为模板参数的类型。例如：
template <typename T>
void printType(T value) {
std::cout << typeid(value).name() << std::endl;
}
int main() {
int num = 42;
printType(num); // 输出int
std::string str = "Hello";
printType(str); // 输出std::string
return 0;
}通过使用auto和decltype关键字，可以让C++编译器根据上下文推断模板的typename参数，从而简化代码并提高代码的可读性和灵活性。
腾讯云相关产品和产品介绍链接地址：
相关·内容
1回答
c++模板参数类型推断
、、、
我在C++中有这样一个模板
template<typename T, T* P> struct Ptr {};
所以我可以这样用它：
const int i = 0;
Ptr<int, &i> ptr;
或
Ptr<decltype(i), &i> ptr;
但是我不想两次指定int或identity i类型，我只想使用
Ptr<&i> ptr;
让编译器自己计算出int类型部分。
我如何声明我的模板来做到这一点？
我读过这个问题，但答案是使用宏，这不太好：
我可以通过没有宏的模板来完成这个任务吗？我正在使用VisualC
浏览 0提问于2014-12-09得票数 10
回答已采纳
2回答
我尝试用默认模板参数编写这个函数：
template<typename A, typename B>
void func(int i1, int i2, A a, B b = 123){
...
}
在我看来，我可以这样称呼它：func(1, 2, 3)和编译器应该从默认值中推断出B类型为int，但我得到了no instance of overloaded function。
在这种情况下，是否不正确的C++结构和编译器不能推断类型？
浏览 8提问于2021-11-29得票数 30
回答已采纳
我对“无法推断T的模板参数”错误有问题。
这是我的班级：
class PropertyAccess
{
public:
template <typename TClass, typename TType>
struct SetterPointer { typedef void (TClass::*Type)(const TType&); };
template <typename TClass, typename TType>
struct GetterPointer { typedef TType(TClass::*Type)
浏览 3提问于2015-07-01得票数 0
回答已采纳
1回答
C++中的特定模板友好
、、、
在C++中，我有一个关于特定模板友谊的问题。在C++ Primer一书中，具体的模板友谊如下所示：
template <class T> class Foo3;
template <class T> void templ_fcn3(const T&);
template <class Type> class Bar {
// each instantiation of Bar grants access to the
// version of Foo3 or templ_fcn3 instantiated with the
浏览 3提问于2012-10-09得票数 7
回答已采纳
是否有一种方法可以编写通用函数来清除C++中任何具有给定项类型的堆栈？我目前正在编写一个使用字符串堆栈和整数堆栈的程序，但我不知道如何将堆栈作为一个参数传递，该参数决定运行时它包含哪些数据，以及如何删除它。我的想法是：
void clearStack(stack &s) {
while(!s.empty())
s.pop();
}
但是，这说明了argument list for class template "std::stack" is missing。C++是否有一种将堆栈作为参数传递而不需要值类型的方法？
*注:这只是练习而已。环顾四周后
浏览 0提问于2020-10-15得票数 0
回答已采纳
3回答
再一次，我希望C++有更强大的typedefs：
#include <vector>
template<typename T>
struct A {
typedef std::vector<T> List;
};
template<typename T>
void processList(typename A<T>::List list) {
// ...
}
int main() {
A<int>::List list;
processList<int>(list); /
浏览 0提问于2010-07-08得票数 3
回答已采纳
例如，我有一个模板函数： template <typename T>
void SizeOf() {
std::cout << sizeof(T) << std::endl;
} 和另一个模板函数： template <typename T, template<typename S> class F>
void CallOn(T t) {
...
F<T>();
...
} 现在我想写这样的代码： double pi = 3.14;
CallOn<double, SizeOf>(pi); 有
浏览 18提问于2020-08-21得票数 2
回答已采纳
1回答
我正在为C++编译器编写一个方案(虽然Scheme与这个问题没有太大关系)，而且我有一组函数在Scheme代码中被调用，这些函数可以在生成的C++代码中等效地使用。我生成了C++函数"f“(见下文)，我无法理解为什么它不能工作(错误在下面)。我有三个模板参数，我还为函数提供了三个参数。如果你对这个问题有任何洞察力，请告诉我--真是令人难以置信的沮丧！
// from stdarg_macros.h
#include <stdarg.h>
#define INIT va_list args; va_start(args, nargs);
#define LOOP for (i
浏览 2提问于2020-08-15得票数 1
回答已采纳
我有一个函数，需要能够为不同的容器类型工作，例如
void foo(const std::vector<bar>& param1, const std::vector<double>& params2)
和
void foo(const std::list<bar>& param1, const std::list<double>& params2)
其中bar是我写的class。函数体本身使用通用的C++标准库函数。
有什么办法可以让我避免这种情况吗？我试过了
template<typename T>
浏览 5提问于2017-07-10得票数 2
回答已采纳
C++和Java在处理参数多态方面有类似之处:它们都会将类型参数推断为常规函数或方法，但都要求程序员在调用构造函数时显式地给出类型参数(尽管在Java 7中已经改变了这一点)。
这种行为背后的技术原因是什么？
编辑：我错误地认为这也适用于Scala。以下是Java的一个示例：
class Foo<T> {
Foo(T x) { }
}
<T> void foo(T x) { }
Foo<Integer> f = new Foo(3);
foo(3);
这两种方法都是合法的，但第一种是创建“原始类型”而不是Foo<Integer>，并
浏览 2提问于2013-12-20得票数 2
回答已采纳
1回答
这句话：
auto test = add<Suc < Suc < Suc < Suc < Zero > > > > > (three, one);
如果我用以下文字代替：
auto test = add(three, one);
我忽略了错误候选模板:无法推断模板参数'W'，使用带有std=c++11的Clang编译器--我无法想象任何其他满足W的值--有办法修复它吗？
#include <type_traits>
template<typename T>
class Nat
浏览 4提问于2019-11-20得票数 0
回答已采纳
基于的实例
template<template<typename T, typename A> class C, typename T, typename A>
^^^^^^^^^^^^^^^^^^^^^^
void erase(C<T, A>&c, const T& item)
{
c.erase(std::remove(c.begin(), c.end(), item), c.end());
}
int _tmain(int /
浏览 0提问于2012-03-09得票数 1
回答已采纳
我想知道C++中是否有一种方法可以在不添加decltype关键字的情况下确定像is_type_same_v(a, int*[3])这样的变量类型？
比如,
int (*a)[3];
using namespace std;
cout<<is_same_v<decltype(a), int(*)[3]> <<endl;
// Is there sth like,
// cout<<is_type_same_v<a, int(*)[3]> <<endl;
我认为第二种方式会更直接。
浏览 5提问于2022-11-12得票数 0
2回答
C++不使用T = Hoge&来实例化模板。
一个最小的例子是：
hoge.h：
#包括类Hoge { public: Hoge()：hoge(0) {} ~Hoge() {} int hoge；void print() { printf("%d\n"，hoge)；}；
hoge.cpp：
#包括"hoge.h“模板void f(T ){ a.print()；} template void f<Hoge &>(Hoge & a)；
main.cpp：
#包括"hoge.h“int main(void) { Hoge
浏览 0提问于2018-01-09得票数 10
回答已采纳
1回答
为什么C++不能确定我打算用这个语法创建一个unique_ptr<A>呢？(a以前曾被宣布为unique_ptr<A>)
a = unique_ptr(new A());
必须包含<A>似乎是非常多余的。这对于我使用的大多数函数模板都有效，为什么不使用unique_ptr呢？
编辑： C++现在支持make_unique，没有冗余。
浏览 4提问于2011-04-03得票数 5
回答已采纳
我是编程和C++的新手。我有一个函数，我想接受带有模板值的函数指针作为参数。这就是我的意思。 我有这个函数： template<typename... ColumnTypes, typename... ParameterTypes>
void query(std::function<void(bool success, ozo::rows_of<ColumnTypes...>& results)> callback, const
std::string& query, ParameterTypes&& ...
浏览 50提问于2020-12-18得票数 2
回答已采纳
我有以下代码：
template <typename, typename>
struct AAA{};
template<typename ...Args>
void f(AAA<Args...> *) {}
int main() {
f<int, int>(nullptr);
}
此代码将导致编译错误。使用g++ -std=c++1z编译时，错误如下所示：
prog.cc: In function 'int main()':
prog.cc:8:24: error: no matching function for
浏览 4提问于2017-07-26得票数 40
回答已采纳
1回答
我有以下C++代码，它编译：
A职能：
template <typename T> T funcC(int a, double b)
{
return a + b;
}
然后，我主要做以下几点：
int (*anythingInt)(int,double);
double (*anythingDouble)(int,double);
anythingInt = &funcC;
anythingDouble = &funcC;
std::cout << anythingInt(12, 17.5) << std::endl;
std:
浏览 5提问于2022-11-27得票数 2
我试图使用一个接受std：：函数的模板，但是模板参数推导失败了。
double foo(){
return 2.3;
}
template <typename V>
void funcC (V (*fptr)()){
std::cout << "C function's value is\"" << fptr() << '\"' << std::endl;
}
template <typename V>
void funcCxx (std::functio
浏览 7提问于2022-01-24得票数 1
回答已采纳
2回答
请注意，这只是一个关于模板语法的问题--不是一般的面向c++对象的多态设计。这个例子就是为了这个目的而制作的。
假设我有一个基类：
class A: public B
{
...
};
我用它..。
A a;
a.DoSomething();
如果我想做这样的事情，就能在编译时派生出A，不仅是从B，而且是从其他类。这样我就可以像这样使用它：
A<B> a; // like class A : public B
a.doSomething();
A<C> ac; // like class A : public C
浏览 1提问于2013-12-20得票数 4
回答已采纳
描述了如何流独立的std::variant。但是，当std::variant存储在std::unordered_map中时，它似乎不起作用。
下面的
#include <iostream>
#include <string>
#include <variant>
#include <complex>
#include <unordered_map>
// https://stackoverflow.com/a/46893057/8414561
template<typename... Ts>
std::ostream&a
浏览 1提问于2018-10-17得票数 26
回答已采纳
3回答
这是一个中等水平的问题。我通过存储指向函数的指针在c++中注册我的事件。目前，我将函数存储在boost::function<void (Event*)>中，当事件被触发时，该函数将接受指向事件的指针作为参数。
为了注册一个新事件，我这样做..。
Event::Register("click", "Image18", boost::bind(&MyMenu::OnClick, this, _1));
MyMenu::OnClick(DKEvent* event) <-- calls this
我希望尽可能简化我的代码的用户端。如何将b
浏览 8提问于2015-05-05得票数 1
回答已采纳
我以为我已经开始掌握C++的诀窍了……
然后，我编写了我认为我们是非常简单的模板化函数，突然之间，似乎什么都没有意义了。编译器甚至不喜欢我定义了一个模板化的函数，这看起来有点疯狂。它是一个单一的编译单元，所以我不确定它会抱怨什么。
#include <vector>
#include <iostream>
typedef std::vector<int> int_vec_type;
template <typename Type>
bool print_vec(Type::const_iterator itr, const Type::con
浏览 0提问于2012-09-25得票数 0
回答已采纳
1回答
我有下面的C++11示例，其中有一个call函数，它使用各种模板来接受和调用泛型类方法：
#include <utility>
template <typename T, typename R, typename... Args>
R call(R (T::*fn)(Args...), T *t, Args&&... args) {
return ((*t).*fn)(std::forward<Args>(args)...);
}
class Calculator {
public:
int add(con
浏览 2提问于2014-11-18得票数 9
回答已采纳
2回答
我定义了这样一个函数，其中有一个模板类
template<typename Key, typename Value, template <typename, typename> class Map>
struct ForEachOf {
void operator()(const Map<Key, Value>& map, std::function<void (Key, Value)> func) {
for(const auto& pair : map) {
浏览 3提问于2015-08-29得票数 2
回答已采纳
有没有办法在C++中使用const std::type_info&作为模板参数？
例如
template < typename T > class A
{
public:
A(){}
const std::type_info& type() const
{
return typeid(T);
}
};
template < typename T > void Do()
{
// Do whatever
}
int main()
{
A<int> MyA;
// Som
浏览 4提问于2014-01-30得票数 1
1回答
我经常在c++中使用闪电战库。它有很多不错的功能，比如打印一个只需打印的二维数组
cout<<A<<endl;
然而，输出结果如下(对于2x2数组)
2 x 2
[ 4 5
2 1]
现在，我希望摆脱2x2维度和它所放置的括号，因为当我希望直接使用文件绘制某些东西时，它有时会产生问题。我该怎么做呢？
浏览 4提问于2012-06-01得票数 0
回答已采纳
1回答
中断很长时间后，我将重新访问C++，我希望使用模板来设计 --将函数应用于集合中的每个元素的模板。
忽略了我的map不返回任何东西(这里是一个非因素)，如果传递给"map“的函数不需要接受附加参数，我就实现了我想要的：
#include <iostream>
template <typename C, void fn(const typename C::value_type &)> void map(const C & c) {
for(auto i : c) {
fn(i);
}
}
struct some_
浏览 1提问于2021-06-13得票数 2
回答已采纳
1回答
根据入参判断返回类型
、、、
我正在尝试实现一个通用的配置文件解析器，我想知道如何在我的类中编写一个方法，该方法能够根据输入参数的类型来确定它的返回类型。我的意思是：
class Config
{
...
template <typename T>
T GetData (const std::string &key, const T &defaultValue) const;
...
}
为了调用上面的方法，我必须使用如下代码：
some_type data = Config::GetData<some_type>("some_key"
浏览 3提问于2012-06-18得票数 2
回答已采纳
下面的最小代码给出了一个编译错误：
#include <iostream>
#include <functional>
using namespace std;
template<typename ActionType, typename... Cols>
void print_action(function<ActionType*(Cols..., ActionType)> action_factory)
{
}
int main(int argc, char *argv[])
{
print_action<string,
浏览 4提问于2016-01-07得票数 2
我是C++的新手，目前正在努力了解模板函数是如何工作的。首先，我想添加两个相同类型的数值，这很容易理解。
template <typename T>
T add(T a, T b){return a+b;}
int main(){
float a_f=2.5;float b_f=1.5;float c_f;
int a_i=2;int b_i=1;int c_i;
c_f = add(a_f, b_f);
c_i = add(a_i, b_i);
return 0;
}
接下来，我想要添加两个具有不同和相等类型的数字。我天真的假设是：
tem
浏览 3提问于2020-02-03得票数 0
回答已采纳
我正在使用c++。我有字符串，它可以包含以^开头的元素和以$结尾的元素。这个元素可以是int或string。
示例：
"....^15$asdasd"-> 15
"...^bbbb$ccc"->"bbbb"
我想编写lambda函数来完成这个任务。如果我使用模板函数，代码将如下所示：
template <typename T>
T getElem(string S)
{
T retElem;
// make calculations
// ....
return retElem;
}
浏览 1提问于2017-08-04得票数 0
回答已采纳
3回答
目前，我正在尝试让一些代码对不同的类型做出不同的反应。这不是确切的代码，但它传达了信息。
template<class A, class B>
struct alpha {
enum { value = 0 };
};
template<class T, class... Args>
struct alpha<std::tuple<Args...>, T> {
enum { value = 1 };
};
// This gets ignored
template<class T, class... Args>
struc
浏览 0提问于2011-07-20得票数 5
回答已采纳
即使在阅读了许多在线资源和其他问题(包括和 )之后，我仍然很难用c++清楚地表达以下内容。我希望避免重复的模板参数，这似乎是不必要的。
例如，泛型类型“A”的容器“H”具有泛型类型“B”的泛型方法“M”。这表达了我对'H‘和方法’M‘的意图：
template<typename A>
struct H
{
explicit H(A x) : x(x) { }
A x;
template<typename B>
H<B> M(std::function<H<B>(A)> g) { return
浏览 0提问于2013-06-19得票数 2
回答已采纳
2回答
在我的C++旅行中，我遇到了以下成语(例如，中的Abseil)，用于确保模板函数不能显式指定模板参数，因此它们不是保证API的一部分，可以自由更改而不破坏任何人：
template <int&... ExplicitArgumentBarrier, typename T>
void AcceptSomeReference(const T&);
它似乎确实奏效了：
foo.cc:5:3: error: no matching function for call to 'AcceptSomeReference'
AcceptSomeReference
浏览 5提问于2021-06-28得票数 15
回答已采纳
当我编写C++代码时，如下所示：
#include <iostream>
#include <memory>
#include <functional>
template <typename T>
struct Node
{
T data;
std::shared_ptr<T> left;
std::shared_ptr<T> right;
Node(const T& data)
:data(data)
{}
};
template <typena
浏览 4提问于2021-06-03得票数 0
回答已采纳
1回答
我正试图把我的注意力放在C++模板和复制语义上。我理解为什么我不能调用assign1 (它请求rvalue引用，我提供了一个lvalue引用)，但是为什么我能够调用assign2，这会施加同样的约束呢？
template<typename... Args>
void assign1(Args&& ... arguments) { }
template<typename A, typename... Args>
void assign2(Args&& ... arguments) { }
template<typename A,
浏览 5提问于2020-04-26得票数 1
回答已采纳
当我们在c++中使用模板时，我正在试验如何推断参数，我遇到了一个对我来说很奇怪的案例。
根据我的理解，模板参数应该出现在调用参数中。但在下面的代码中，我尝试跳过第一个模板参数，代码编译并运行良好。我想我的理解有差距。
这只是一个实验性的代码：
#include <iostream>
#include <cstring>
#include <string>
#include <typeinfo>
using namespace std;
template <typename T, typename T1>
T1 const&
浏览 15提问于2018-06-26得票数 0
回答已采纳
2回答
在C++14中，不可能使用多参数包调用函数模板：
#include <future>
template<class... Futures, class... Incrementables>
void foo(Futures&... futures, Incrementables... incrementables)
{
}
int main()
{
std::future<int> a, b;
int x, y;
// ERROR
foo(a, b, x, y);
return 0;
}
因为不清楚第一个参数包的结束位置和
浏览 1提问于2016-09-23得票数 10
回答已采纳
在我的C++程序中，我需要调用具有不同数据类型(int、float、double、char等)的模板化函数。并运行bar1()、bar2()方法。
如何在不显式地为每个类型编写调用的情况下做到这一点？
foo<int>::bar1()
foo<int>::bar2()
foo<int>::bar3()
...
foo<float>::bar1()
foo<float>::bar2()
foo<float>::bar3()
...
浏览 3提问于2011-12-29得票数 2
回答已采纳
3回答
在构造函数的参数中使用类型时，是否有一种方法可以避免指定类模板参数？
我有：
template< typename T, typename X >
class myclass {
myclass( typename X ) {};
X myfunct() { return X(); };
};
那么，是否有某种设计模式可以使用
myclass< TType > myclass_object( x_object );
而不是
myclass< TType, XType > myclass_object( x_object );
感谢你的模板编程专家，这
浏览 2提问于2011-07-06得票数 1
2回答
我很难理解C++模板模板参数的语法。我理解为什么它们是有用的，根据的出色描述，我只是发现它们的语法很难理解。取自上述网站的两个示例(还有其他示例)：
template <typename T, template <typename> class Cont>
class Stack;
和
template <template <typename,typename> class Cont>
class Wrapper3;
显然，如果不了解这种语法背后的原理，就不可能对这些声明进行泛化。记忆更难，而且似乎也没有多大帮助。
编辑:我意识到我对一个问题的尝
浏览 0提问于2011-09-02得票数 6
回答已采纳
这是一个C++编程的初学者。(同样在英语中，很抱歉我的英语很差...ToT)
我搜索了与我的问题相关的主题，但我找不到它们。我希望这篇文章不是重复的。
我想写一些包装ostream对象的类来操作我的输出。
在我的学习中，我正在尝试设计通用的输出流类，这样我就可以让一个子类继承basic_ostream类模板。
如您所知，basic_ostream类需要两个模板变量(实际上，只有第一个是必需的，另一个的默认值为char_traits<_CharT>)。
但是，我坚持为我的类创建一个构造函数，让编译器从构造函数的参数中自动推导出模板变量。
下面是我的类头的一部分：
#include &
浏览 0提问于2018-07-31得票数 0
在我的C++代码中，我这样写：
template <typename T, typename Pred>
inline const T BestOfTwo(const T& lhs, const T& rhs, Pred p = std::less<T>())
{
return p(lhs, rhs) ? lhs : rhs;
}
但是，当我给BestOfTwo(3，5)打电话时，这是行不通的。编译器告诉我没有匹配的重载实例。所以现在我不得不这样写：
template <typename T, typename Pred = std::le
浏览 2提问于2014-12-22得票数 12
回答已采纳
1回答
我从编译器那里得到以下错误:预期的error: no match for 'operator+' (operand types are 'Expected<double>' and 'Expected<double>')要么是类型，要么是异常。
template<typename T>
class Expected
{
template<typename U>
Expected<U> apply(std::function<U(T)> f)
{
浏览 0提问于2017-11-18得票数 0
回答已采纳
2回答
生成比较器函数的向量
、、、
我的问题是用不同的比较器函数测试快速排序的实现：std::less和std::greater。但是我不想复制只是两个比较器不同的测试代码，所以我想把它们放到一个向量中(或者其他什么东西？)反复检查它们。
为了简化这篇文章，让我们假设我想在两个函数的向量上编写一个循环，将0和1作为参数并输出一个布尔值。以下是我对此的看法：
#include <iostream>
#include <vector>
#include <functional>
int main() {
auto fs = std::vector<>{std::less<
浏览 5提问于2016-08-21得票数 0
回答已采纳
5回答
我正在尝试了解如何使用C++(11) <type_traits>。
下面是我的简单测试程序
#include <type_traits>
template<class U, class S>
inline U add(typename std::enable_if<std::is_unsigned<U>::value,U>::type a,
typename std::enable_if<std::is_signed <S>::value,S>::type b)
{
ret
浏览 1提问于2013-06-07得票数 9
回答已采纳
2回答
我正在尝试实现一个C++程序，给出一个元素列表，从列表中打印出唯一的元素。
我比C++更了解C，但我现在才真正开始学习C++ (编码)。
我只读过C++的概念--模板是什么--我对函数模板很满意，但我只是阅读了类模板，我想我对在哪里使用哪一个感到困惑，正如下面的场景所应用的那样。
下面是我到目前为止所写的内容(*请注意，函数isUnique应该做其他的事情，但我现在只是在里面编写可验证的操作)：
cppArrays.h
#include <iostream>
#include <cstdlib>
#include <vector>
#include <
浏览 3提问于2016-07-10得票数 0
回答已采纳
我正在尝试编写函数，它大致类似于接受两个容器实例(假设目前它们是相同的)的函数，包含相同的类型并将它们合并。这是我的矢量函数：
template<typename T>
void test(std::vector<T> v1, std::vector<T> v2) {
std::cout << "called nested for c\n";
}
而且起作用了。
现在，我想有一个可以工作的集合或向量。我试试看：
template<typename T, template <typename> typename
浏览 0提问于2018-09-26得票数 3
2回答
我目前正在学习c++的完美转发，我遇到了一些让我感到困惑的东西。很确定这是件蠢事。当我在lvalue上使用std::forward时，它使用rvalue函数。这是个很糟糕的解释所以我要给你看代码。
#include <iostream>
void check(int&& other) {
std::cout << "Rvalue" << std::endl;
}
void check(int& other) {
std::cout << "Lvalue" <<
浏览 8提问于2021-05-20得票数 1
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
实时音视频
即时通信 IM
对象存储活动推荐
腾讯云开发者
