C++ 为什么我们应该在下面的代码中使用模板包装器？ 模板 无效写入（T） {} 模板 无效写入（const std:：string&） {} //Q2>此模板的用途是什么？ 模板结构将类型转换为参考 { 类型定义T值_类型； }; 模板 结构将类型转换为参考 { typedef std:：字符串常量和值类型； }; 模板 结构将类型转换为参考 { typedef std:：字符串常量和值类型； }; 模板结构HelloStruct{ void运算符（）（常量T&T）常量{ 给我写信（t）； } }; 模板结构值 { 类型定义T值_类型； }; 模板 无效功能AA（常数T和一个参数） { HelloStruct（）（一个参数）； //HelloStruct（）（一个参数）；//Q1>为什么不简单地使用T？ }

我见过一些类似于上面的遗留代码

问题1>以下两种情况的区别是什么？选择案例1的主要好处是什么

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?
}

HelloStruct（）（一个参数）；//案例1

VS

HelloStruct（）（一个参数）；//为什么不直接使用T？//案例2

问题2>为什么我们必须在这里引入一个间接过程，如下所示

HelloStruct<T>()(one_arg); // Why not simply use T?     // case 2

write_me（t）；

为什么不直接打以下电话

write_me<typename convert_type_to_ref<T>::value_type>(t);

write_me（t）；

谢谢你的问题1）这两个案例是一样的。。。在这方面。然而，在某些情况下，它不能是相同的。 此主题称为类型特征，使用第一次编写可以使用更通用的方法来确定更复杂数据结构的基本类型。 e、 g

#包括
#包括
#包括
模板
结构特征
{
typedef typename traits:：value_type value_type；
};
模板
结构特征
{
typedef无符号字符值\u类型；
};
模板
结构特征
{
类型定义值\u类型；
};
模板
结构特征
{
typedef无符号短值_type；
};
模板
结构特征
{
typedef int value_type；
};
模板
结构特征
{
typedef无符号值\u类型；
};
模板
结构特征
{
typedef长值_类型；
};
模板
结构特征
{
typedef无符号长值_type；
};
模板
结构特征
{
typedef long long value_type；
};
模板
结构特征
{
类型定义浮点值\u类型；
};
模板
结构特征
{
typedef双值_类型；
};
模板
结构特征
{
typedef双值_类型；
};
int main（）
{
std：：cout对于你的问题1）这两种情况是相同的…在那种情况下。但是，在某些情况下，它不可能是相同的。
此主题称为类型特征，使用第一次编写可以使用更通用的方法来确定更复杂数据结构的基本类型。
e、 g

#包括
#包括
#包括
模板
结构特征
{
typedef typename traits:：value_type value_type；
};
模板
结构特征
{
typedef无符号字符值\u类型；
};
模板
结构特征
{
类型定义值\u类型；
};
模板
结构特征
{
typedef无符号短值_type；
};
模板
结构特征
{
typedef int value_type；
};
模板
结构特征
{
typedef无符号值\u类型；
};
模板
结构特征
{
typedef长值_类型；
};
模板
结构特征
{
typedef无符号长值_type；
};
模板
结构特征
{
typedef long long value_type；
};
模板
结构特征
{
类型定义浮点值\u类型；
};
模板
结构特征
{
typedef双值_类型；
};
模板
结构特征
{
typedef双值_类型；
};
int main（）
{
标准：：cout
问题1>以下两种情况的区别是什么？选择情况1的主要好处是什么

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?
}

HelloStruct（）（一个参数）；
和
HelloStruct（）（一个参数）；
是相同的

TValue
可以按原样使用，以避免扣除：

typedef float value_type;

struct useless_struct
{
  typedef double value_type;
}; 

HelloStruct<useless_struct::value_type> a; // == HelloStruct<double>
HelloStruct<value_type> b; // == HelloStruct<float>

是

write_me（t）；

鉴于

write_me<const std::string&>(t);

write_me（t）；

是

write_me（t）；

但是在

write_me<int>(t);

模板结构HelloStruct{
void运算符（）（常量T&T）常量{
给我写信（t）；
}
};

t
已经通过常量引用，因此这种微观优化似乎更为多余

问题1>以下两种情况的区别是什么？选择情况1的主要好处是什么

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?
}

HelloStruct（）（一个参数）；
和
HelloStruct（）（一个参数）；
是相同的

TValue
可以按原样使用，以避免扣除：

typedef float value_type;

struct useless_struct
{
  typedef double value_type;
}; 

HelloStruct<useless_struct::value_type> a; // == HelloStruct<double>
HelloStruct<value_type> b; // == HelloStruct<float>

是

write_me（t）；

鉴于

write_me<const std::string&>(t);

write_me（t）；

是

write_me（t）；

但是在

write_me<int>(t);

模板结构HelloStruct{
void运算符（）（常量T&T）常量{
给我写信（t）；
}
};

t
已被常量引用，因此此微观优化似乎更为多余。
您提供的代码似乎只是增加了复杂性，没有任何好处。您确定您提供了模板的完整定义。“Q2>此模板的用途是什么？”可能连作者都不知道。要么它在正确的位置缺少了一个
&
，要么模板完全没有意义“更好”名称应该是
convert_type_to_type
convert_type_to_ref
没有做它说应该做的事情。你确定代码是正确的，并且它不是
typedef T&value_type；
？看起来有人有一个愚蠢的方法来重新实现
std:：add_reference
，你现在的代码似乎只是增加了复杂性没有优势。你确定你展示了templa的完整定义吗
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);
    }
};