c ++具有相同实现的重载函数
c++ overloaded functions with equal implementation
我有两个重载函数,比如
void f(int);
void f(std::string);
和两个重载函数 g
具有与 f
相同的原型,但它们是 f
的简单包装器,因此它们的实现完全相同:
void g(int n) { f(n);}
void g(std::string n) { f(n); }
有没有办法避免写两次 g
的实现?我知道这可以通过像
这样的模板声明 g
来完成
template<typename T> g(T n) { f(n);}
但是我必须像
那样在函数调用中输入类型
g<int>(2);
g<std::string>("42");
我想知道避免两次编写 g
的实现而不强制用户在每个函数调用中显式写入类型名称的正确方法是什么?
“但我必须在函数中输入类型”,不,你不必这样做。 模板参数推导 为您完成。所以,函数模板是一个实用的解决方案。
你写的那个,
template<typename T> g(T n) { f(n);}
很好,只是它需要 void
return 类型。
您可以按如下方式支持移动优化:
template< class Arg >
void g( Arg&& arg ) { f( std::forward<Arg>( arg ) ); }
这里的 &&
不表示右值引用,而是所谓的 通用引用 ,因为它应用于已经可以作为引用的模板参数。
这样做的效果是std::forward
在大多数情况下可以准确地重现实参的那种,这叫做完美转发。
Is there a way of avoiding writing twice the implementation of g?
是的,有。
I know this can be done by declaring g via a template like
给你。
but then I'll have to type the type in the function call
不,你不知道。您可以让编译器推断类型:
g(2);
g("42");
我有两个重载函数,比如
void f(int);
void f(std::string);
和两个重载函数 g
具有与 f
相同的原型,但它们是 f
的简单包装器,因此它们的实现完全相同:
void g(int n) { f(n);}
void g(std::string n) { f(n); }
有没有办法避免写两次 g
的实现?我知道这可以通过像
g
来完成
template<typename T> g(T n) { f(n);}
但是我必须像
那样在函数调用中输入类型g<int>(2);
g<std::string>("42");
我想知道避免两次编写 g
的实现而不强制用户在每个函数调用中显式写入类型名称的正确方法是什么?
“但我必须在函数中输入类型”,不,你不必这样做。 模板参数推导 为您完成。所以,函数模板是一个实用的解决方案。
你写的那个,
template<typename T> g(T n) { f(n);}
很好,只是它需要 void
return 类型。
您可以按如下方式支持移动优化:
template< class Arg >
void g( Arg&& arg ) { f( std::forward<Arg>( arg ) ); }
这里的 &&
不表示右值引用,而是所谓的 通用引用 ,因为它应用于已经可以作为引用的模板参数。
这样做的效果是std::forward
在大多数情况下可以准确地重现实参的那种,这叫做完美转发。
Is there a way of avoiding writing twice the implementation of g?
是的,有。
I know this can be done by declaring g via a template like
给你。
but then I'll have to type the type in the function call
不,你不知道。您可以让编译器推断类型:
g(2);
g("42");