C++11的模板类型判断——std::is_same和std::decay_c++ 判断模板类型

link之家
链接快照平台
输入网页链接，自动生成快照
标签化管理网页链接
相关文章推荐
细心的沙滩裤 · 《菊豆》：一段婶侄禁忌恋，展现性压抑和时代枷 ...· 7 月前 ·
直爽的饭盒 · Red ...· 1 年前 ·
豪情万千的打火机 · 女高校长张桂梅· 1 年前 ·
健身的杨桃 · ntoskrnl.exe+3f7620 ...· 1 年前 ·
跑龙套的牙膏 · 2067_百度百科· 1 年前 ·
C++11的模板类型判断——std::is_same和std::decay
问题提出：有一个模板函数，函数在处理int型和double型时需要进行特殊的处理，那么怎么在编译期知道传入的参数的数据类型是int型还是double型呢？
如：
#include <iostream>
template<typename TYPE>
void typeCheck(TYPE data)
    //do something check data type
    //std::cout<< out put the type
这里就需要用到C++11的type_traits头文件了，type_traits头文件定义了很多类型检查相关的方法，上面的例子具体用到了其中两个结构： 
std::is_same 判断类型是否一致 
位于头文件<type_traits>中 
这个结构体作用很简单，就是两个一样的类型会返回true 
bool isInt = std::is_same<int, int>::value; //为true 
下面是官方的例子： 
#include <iostream>
#include <type_traits>
#include <cstdint>
void print_separator()
    std::cout << "-----\n";
int main()
    std::cout << std::boolalpha;
    std::cout << std::is_same<int, int32_t>::value << '\n';   // true
    std::cout << std::is_same<int, int64_t>::value << '\n';   // false
    std::cout << std::is_same<float, int32_t>::value << '\n'; // false
    print_separator();
    std::cout << std::is_same<int, int>::value << "\n";          // true
    std::cout << std::is_same<int, unsigned int>::value << "\n"; // false
    std::cout << std::is_same<int, signed int>::value << "\n";   // true
    print_separator();
    // unlike other types 'char' is not 'unsigned' and not 'signed'
    std::cout << std::is_same<char, char>::value << "\n";          // true
    std::cout << std::is_same<char, unsigned char>::value << "\n"; // false
    std::cout << std::is_same<char, signed char>::value << "\n";   // false
通过std::is_same即可判断两个类型是否一样，特别在模板里面，在不清楚模板的参数时，此功能可以对一些特定的参数类型进行特殊的处理。 
 这里说个题外话，大家是否通过std::is_same发现，char既不是unsigned char也不是signed char，char就是char，这和int是signed int的缩写是不一样的，char的表达范围可能等同于signed char，也可能等同于unsigned char，取决于编译器，一般是等同于signed char，但这个仅仅是范围等同，就像32位上int和long范围是一样的，但不是同一个类型。 
 因为用途不同，char用于表达字符，理论上不应该关心其正负的实现，而signed char 和 unsigned char 用于表达数值，或可移植的char。 
回到正文，std::is_same可以判断两种类似是否一样，那么用在模板里就是利器了，本位一开始提到的那个问题就可以这样写： 
#include <iostream>
template<typename TYPE>
typeCheck(TYPE data)
    if(std::is_same<TYPE,int>::value)
        std::cout<<"int type";
        //do something int 
        //.........
视乎很美好，再看一个示例： 
// is_same example
#include <iostream>
#include <type_traits>
#include <cstdint>
typedef int integer_type;
struct A { int x,y; };
struct B { int x,y; };
typedef A C;
int main() {
      std::cout << std::boolalpha;
      std::cout << "is_same:" << std::endl;
      std::cout << "int, const int: " << std::is_same<int, const int>::value << std::endl;//false
      std::cout << "int, int&: " << std::is_same<int, int&>::value << std::endl;//false
      std::cout << "int, const int&: " << std::is_same<int, const int&>::value << std::endl;//false
      std::cout << "int, integer_type: " << std::is_same<int, integer_type>::value << std::endl;//true
      std::cout << "A, B: " << std::is_same<A,B>::value << std::endl;//false
      std::cout << "A, C: " << std::is_same<A,C>::value << std::endl;//true
      std::cout << "signed char, std::int8_t: " << std::is_same<signed char,std::int8_t>::value << std::endl;//true
      return 0;
is_same:
int, const int: false
int, int&: false
int, const int&: false
int, integer_type: true
A, B: false
A, C: true
signed char, std::int8_t: true 
发现std::is_same的判断是很严格的 
 但是有时候在编辑模板的时候又发现用std::is_same的判断太过严格，还是之前的例子： 
#include <stdlib.h>
#include <iostream>
#include <type_traits>
template<typename TYPE>
void typeCheck(TYPE data);
int _tmain(int argc, _TCHAR* argv[])
    int a = 1;
    const int& b = a;
    int& c = a;
    int d[12];
    const int& e = d[7];
    typeCheck(a);//int type
    typeCheck(b);//int type
    typeCheck(c);//int type
    typeCheck(d[7]);//int type
    typeCheck(e);//int type
    typeCheck(8);//int type
    system("pause");
    return 0;
template<typename TYPE>
void typeCheck(TYPE data)
    if(std::is_same<TYPE,int>::value)
        std::cout<<"int type"<<std::endl;
    else if(std::is_same<TYPE,std::string>::value)
        std::cout<<"string type"<<std::endl;
        std::cout<<"other type";
int type
int type
int type
int type
int type
int type 
测试后发现，虽然变量b,c使用引用，但std::is_same还是能识别出来的，但是！！ 
 如果我显示的指定模板参数类型时情况有不一样了： 
#include <stdlib.h>
#include <iostream>
#include <type_traits>
template<typename TYPE>
void typeCheck(TYPE data);
int _tmain(int argc, _TCHAR* argv[])
    int a = 1;
    const int& b = a;
    int& c = a;
    int d[12];
    typeCheck<int>(a);        //int type
    typeCheck<const int&>(b);//other type
    typeCheck<int &>(c);        //other type
    typeCheck<const int&>(d[7]);//other type
    typeCheck(8);                //int type
    system("pause");
    return 0;
template<typename TYPE>
void typeCheck(TYPE data)
    if(std::is_same<TYPE,int>::value)
        std::cout<<"int type"<<std::endl;
    else if(std::is_same<TYPE,std::string>::value)
        std::cout<<"string type"<<std::endl;
        std::cout<<"other type";
int type
other type
other type
other type
int type 
瞬间结果就不一样了，这很好了解，从上面可知道，std::is_same对int和const int\int &\const int&等都是区别对待的，但在写模板函数时，经常会强制指定常引用进行传参，以免进行数据拷贝，这时候is_same就做出了不相等的判断，但是有时候其实我们还是希望TYPE和const TYPE& 是能认为是一样的，这时就需要std::decay进行退化处理 
std::decay 退化类型的修饰 
std::decay就是对一个类型进行退化处理，他的实现如下: 
template< class T >
struct decay {
private:
    typedef typename std::remove_reference<T>::type U;
public:
    typedef typename std::conditional< 
        std::is_array<U>::value,
        typename std::remove_extent<U>::type*,
        typename std::conditional< 
            std::is_function<U>::value,
            typename std::add_pointer<U>::type,
            typename std::remove_cv<U>::type
        >::type
    >::type type;
看着比较抽象，其实就是把各种引用啊什么的修饰去掉，把cosnt int&退化为int，这样就能通过std::is_same正确识别出加了引用的类型了 
 上面的例子改为： 
#include "stdafx.h"
#include <stdlib.h>
#include <iostream>
#include <type_traits>
template<typename TYPE>
void typeCheck(TYPE data);
int _tmain(int argc, _TCHAR* argv[])
    int a = 1;
    const int& b = a;
    int& c = a;
    int d[12];
    typeCheck<int>(a);//int type
    typeCheck<const int&>(b);//int type
    typeCheck<int &>(c);//int type
    typeCheck<const int&>(d[7]);//int type
    typeCheck(8);//int type
    system("pause");
    return 0;
template<typename TYPE>
void typeCheck(TYPE data)
    if(std::is_same<typename std::decay<TYPE>::type,int>::value)
        std::cout<<"int type"<<std::endl;
        std::cout<<"other type"<<std::endl;
在cppref有个更加详细的例子： 
#include <iostream>
#include <type_traits>
template <typename T, typename U>
struct decay_equiv : 
    std::is_same<typename std::decay<T>::type, U>::type 
int main()
    std::cout << std::boolalpha
              << decay_equiv<int, int>::value << '\n'
              << decay_equiv<int&, int>::value << '\n'
              << decay_equiv<int&&, int>::value << '\n'
              << decay_equiv<const int&, int>::value << '\n'
              << decay_equiv<int[2], int*>::value << '\n'
              << decay_equiv<int(int), int(*)(int)>::value << '\n';
在模板里可以通过std::is_same判断模板的类型，从而实现对不同类型的区别对待
在堆类型要求不是非常严格的情况下，可以使用std::decay把类型退化为基本形态，结合std::is_same用，可以判断出更多的情况
                    C++11的模板类型判断——std::is_same和std::decay问题提出：有一个模板函数，函数在处理int型和double型时需要进行特殊的处理，那么怎么在编译期知道传入的参数的数据类型是int型还是double型呢？ 如：#include <iostream>template<typename TYPE>void typeCheck(TYPE data){    //do so
				C++中判断数据的类型
       在实际的项目中经常要进行数据类型的转换，特别是字符串转成数字或者数字转字符串，而在进行数据类型转换之前要先知道数据的类型。
这时如何判断一个数据的数据类型这个问题就自然而然的遇到了。在本人几次遇到这个问题的情况下，这次来做一个总结。
1.typeid
	typeid这个函数在头文件typeinfo.h中，在使用这个函数时要加上头文件：#include<...
GTSRB图像分类
测试精度摘要
./models/shwangnet/logs/test_shwangnet_lr_0.001_weight_decay_0.005.log最佳准确性日志文件以进行验证
使用定制的按类精度（
draw_accuracy.py
）计算代码，而不是matcaffe。
（TA允许，因为docker环境尚不支持MATLAB）
亚历克斯网
CaffeNet
BatchNorm（ShwangNet）
AlexNet
BatchNorm
CaffeNet
BatchNorm
+辍学率：0.2
87.6％
89.8％
90.0％
88.5％
88.6％
I.我的python代码所需的python包
python==2.7
pycaffe
pandas
存储和预处理数据
制作LMDB
将数据存储在<./data/train>和<./data/test>
制作path_test.txt和path_label_train.txt
python
gen_lmdb.py
将LMDB文件存储在./da
a)T不会被推导为引用类型,形参会被推断为引用类型(&类型)
b)如果实参带const,实参的const属性会成为模板T的组成部分,且形参也会带上const属性(const &)
2.若T为引用,且带有const属性
template<class T>
void fun(const T&);
a) T不会被推断为const类型(即使实参.
				作者：朱金灿来源：http://blog.csdn.net/clever101  在使用模板时经常会碰到两种需求：一种是判断输入的两个模板类型是否一样，另一种情况是判断输入的模板类型是否为指定的类型。从网上找了些资料，实现了这两种需求。  首先是实现判断输入的两个模板类型是否一样，代码很简单：//利用 c++模板 类型 推导思想，实现最简单的 判断两个类型 是否一样的 方法
template&lt...
				0x02_env
 Eurorack AD/ASR 包络和 CV 发生器
该模块响应门极/触发脉冲产生双极控制电压。 该按钮选择它如何响应输入脉冲：Attack-Decay 或 Attack-Sustain-Release。 零电平和触发（峰值）电平分别设置在输出电压范围 (-5 - +5 V) 内的任何位置。
 ** 工作正在进行中 **
$ redditHot = $ c -> redditHot ( $ decay , $ ups , $ down , $ date );
echo $ redditHot . "\n" ;
 * Hacker News
				EfficientDet_PyTorch
注意（注意）：
训练请使用SGD优化器（动量为0.9）。不要使用亚当。会造成不收敛。推荐lr：Pre_train（1e-4-> 1e-3-> 1e-2-> 3e-2）-> Train（5e-2）-> Post_Train（3e-2-> 1e-2-> 1e-3）推荐weight_decay：4e-5或1e-4（区别不大） 使用SGD优化器进行训练（动量为0.9）。 不要使用亚当。 会导致不收敛
有两个分支，一个是按照论文书写（官方），一个是参考zylo117的代码（ zylo117 ），并同时使用他的预训练模型书写（万分感谢），请按实际情况选择有两个分支，其中一个（官方）是根据本文编写的，另一个（大师）是根据“ Zylo117”的代码编写的，并使用他的预训练模型（非常感谢），请根据实际情况
train_example.py的意义是展示模型输入的格式t
1.1函数模板的声明
函数模板可以用来创建一个通用的函数，以支持多种不同的形参，避免重载函数的函数体重复设计。它的最大特点是把函数使用的数据类型作为参数。
函数模板的声明形式为：
template
(参数表)
其中，template是定义模板函数的关键字；template后面的尖括号不能省略；typename（或cl
				模板类型推导规则
当你准备迫切地想要了解本文的内容时，说明你对c++的了解已经比较深入了！本文将试图介绍c++11之后的模板类型推导机制是怎样的（加入右值引用概念），诚然，模板类型推导规则是了解GP（泛型编程，Generic Programming）的基础和前提，但只会这个还远远不够，泛型编程对我来说还是一个触不可及的范式；哪怕你不准备学习使用GP，模板类型推导规则仍然是一个合格的c++工程师必备的知识，模板在现代c++开发中还是很常用的！
c++的函数/类模板为我们提供了这样一种语义：可以针对多种不定的类
				std::remove_cv和std::decay都是C++标准库中的模板类，用于处理类型的特性。
std::remove_cv用于移除类型中的const和volatile修饰符。在C++11中，我们需要使用typename std::remove_cv<T>::type的形式来获取移除修饰符后的类型。而在C++14及其后的标准中，我们可以使用std::remove_cv_t<T>的形式来简化代码。\[2\]
std::decay用于对一个类型进行退化处理。它会移除类型中的引用修饰符，并将数组类型转换为指针类型。在C++11中，我们需要使用typename std::decay<T>::type的形式来获取退化后的类型。\[1\]在C++14及其后的标准中，我们可以使用std::decay_t<T>的形式来简化代码。\[2\]
总结来说，std::remove_cv用于移除类型中的const和volatile修饰符，而std::decay用于对类型进行退化处理，移除引用修饰符并将数组类型转换为指针类型。
#### 引用[.reference_title]
-  *1* [C++11的std::is_same和std::decay使用与源码解析](https://blog.csdn.net/weixin_43798887/article/details/118311126)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^insert_down1,239^v3^insert_chatgpt"}} ] [.reference_item]
-  *2* [【C++ 泛型编程 入门篇】C++元模版中std::remove_reference_t和std::remove_cv_t的运用](https://blog.csdn.net/qq_21438461/article/details/131193312)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^insert_down1,239^v3^insert_chatgpt"}} ] [.reference_item]
-  *3* [C++的std::is_same与std::decay](https://blog.csdn.net/sinat_31608641/article/details/124598754)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^insert_down1,239^v3^insert_chatgpt"}} ] [.reference_item]
[ .reference_list ]
                    Jiacheng Wei: 
                    COleDateTime t1(COleDateTime::GetCurrentTime());
COleDateTimeSpan tsp(1,0,0,0);
for (int i=0; i<1000; i++)
    x[i] = t1.m_dt;
    y[i] = sin(float(i));
    t1 += tsp;
是这里的代码实现的吗？