template<typename T>
void write_me(T t)
{}
template<>
void write_me<const std::string&>(const std::string&)
{}
// Q2> what is the purpose of this template?
template <typename T> struct convert_type_to_ref
{
typedef T value_type;
};
template <>
struct convert_type_to_ref <std::string>
{
typedef std::string const & value_type;
};
template <>
struct convert_type_to_ref <std::string &>
{
typedef std::string const & value_type;
};
template <typename T> struct HelloStruct {
void operator()(const T& t) const {
write_me<typename convert_type_to_ref<T>::value_type>(t);
}
};
template <typename T> struct TValue
{
typedef T value_type;
};
template <typename T>
void functionAAA(const T& one_arg)
{
HelloStruct<typename TValue<T>::value_type>()(one_arg);
// HelloStruct<T>()(one_arg); // Q1> Why not simply use T?
}
我见过一些与上面类似的遗留代码。
问题1>以下两种情况有什么区别？选择案例 1 的主要好处是什么？
HelloStruct<typename TValue<T>::value_type>()(one_arg); // case 1
VS
HelloStruct<T>()(one_arg); // Why not simply use T? // case 2
问题 2> 为什么我们要在这里引入一个间接的，如下所示？
write_me<typename convert_type_to_ref<T>::value_type>(t);
为什么不直接调用如下？
write_me<T>(t);
谢谢
问题1>以下两种情况有什么区别？选择案例 1 的主要好处是什么？
HelloStruct<typename TValue<T>::value_type>()(one_arg);并且HelloStruct<T>()(one_arg);是相同的。
TValue 可以按原样使用以避免扣除：
template <typename T> void fooA(typename TValue<T>::value_type);
template <typename T> void fooB(T);
thenfooA(42)将无效并需要显式fooA<int>(42).
而这两个fooB(42)和fooB<int>(42)有效。
问题 2> 为什么我们要在这里引入一个间接的，如下所示？
convert_type_to_ref<T>似乎是允许传递参数“效率”的试探性（如boost::call_traits）
所以
write_me<typename convert_type_to_ref<std::string>::value_type>(t);
是
write_me<const std::string&>(t);
然而
write_me<typename convert_type_to_ref<int>::value_type>(t);
是
write_me<int>(t);
但在
template <typename T> struct HelloStruct {
void operator()(const T& t) const {
write_me<typename convert_type_to_ref<T>::value_type>(t);
}
};
t 已经通过 const 引用传递了，所以这种微优化似乎更加多余。
本文收集自互联网，转载请注明来源。
如有侵权，请联系 [email protected] 删除。
我来说两句