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

最新推荐文章于 2024-09-26 10:30:31 发布
最新推荐文章于 2024-09-26 10:30:31 发布
阅读量7.1w 收藏 151
点赞数 79
分类专栏： C++ 文章标签： C++11 C++ stl is-same decay
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/czyt1988/article/details/52812797
版权

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 
    }
    else
    {
        //.........
    }
}

视乎很美好，再看一个示例：

// 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;
    }
    else
    {
        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;
    }
    else
    {
        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;
    }
    else
    {
        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';
}

输出:

true
true
true
true
true
true

总结：

  • 在模板里可以通过std::is_same判断模板的类型，从而实现对不同类型的区别对待
  • 在堆类型要求不是非常严格的情况下，可以使用std::decay把类型退化为基本形态，结合std::is_same用，可以判断出更多的情况
尘中远
关注
专栏目录
C++(11)：通过is_same检查类型，decay退化类型
风静如云的博客
04-27 1298
C++11的标准库引入了is_same<T1, T2>函数，可以通过其成员value检查类型T1与T2是否相同： #include <iostream> using namespace std; template<class T> void print(T t) { if(is_same<T, int>::value) { printf("value is:%d\n", t); } else if(is_same<T, const ch
C++(20)：通过remove_cvref_t退化类型
风静如云的博客
11-27 354
介绍了如果通过decay退去类型的修饰符。
C++中使用模板传递函数类型
lslxdx的专栏
11-08 3429
首先看了常用的写法： int fi(char){ return 1; } int main(){ int (*pf)(char)=fi; //以下两种函数调用方式,没有区别 pf('a');//ok (*pf)('a');//ok return 0; } 是的，你可能就此以为函数指针在调用的时候，是否解引用都无所谓了吧？我跟你想得一样，是的，这是对的，但是注意我
c++类模板及参数类型的运行时判断
JoeBlackZQQ的专栏
04-14 9757
/* C++类模板及参数类型的运行时判断(typeid) */ #include #include #include using namespace std; template class Exercise { public: typedef T Type; typedef vector VT; Exercise(int n); void Display(); p
std::is_same详细解释
最新发布
qq_39437730的博客
09-26 239
是 C++ 标准库中的一个类型特性（type trait），用于判断两个类型是否相同。它在头文件中定义，并提供了一种编译时检查类型相同性的机制。
C++模板：函数模板和模板函数
热门推荐
HavenZhao的专栏
05-20 14万+
1.函数模板的声明和模板函数的生成 1.1函数模板的声明 函数模板可以用来创建一个通用的函数，以支持多种不同的形参，避免重载函数的函数体重复设计。它的最大特点是把函数使用的数据类型作为参数。 函数模板的声明形式为： template (参数表) {     函数体 } 其中，template是定义模板函数的关键字；template后面的尖括号不能省略；typename（或cl
C++判断模板类型
我的博客
05-13 2035
1 #include <iostream> 2 #include <type_traits> 3 using namespace std; 4 template<typename T> 5 void test(T a) 6 { 7 cout<<std::is_same<T,int>::value<<endl; 8 9 } 10 int main() 11 { 12 ..
[c++] 带类型判断的模板
I have a adream
07-12 1493
#include &lt;iostream&gt; #include &lt;type_traits&gt; template&lt;typename T&gt; T* PrintType(int* x) { if(std::is_same&lt;T,int&gt;::value) { std::cout &lt;&lt; "int type" &lt;&lt; std::endl;
c++ 模板类型推断
sbsbsbsbsb_1的博客
01-17 1897
1.若T为引用,但不是万能引用: template<class T> void fun(T&); a)T不会被推导为引用类型,形参会被推断为引用类型(&类型) b)如果实参带const,实参的const属性会成为模板T的组成部分,且形参也会带上const属性(const &) 2.若T为引用,且带有const属性 template<class T> void fun(const T&); a) T不会被推断为const类型(即使实参.
std::remove_cv和std::decay
07-27
std::remove_cv和std::decay都是C++标准库中的模板类，用于处理类型的特性。 std::remove_cv用于移除类型中的const和volatile修饰符。在C++11中，我们需要使用typename std::remove_cv<T>::type的形式来获取移除...
std::bind 源码分析
c553110519的专栏
08-22 799
c++11 bind 原理
C++编程法则365天一天一条（217）std::thread构造、拷贝、移动
二进制君
12-06 6460
从上面可以看到，std::thread的拷贝构造、赋值都被禁用了，只允许移动构造和初始化构造、默认构造、移动赋值。
C++ 模板
weixin_44235615的博客
03-19 1812
基本概念：模板就是建立通用的模具，大大提高代码的复用性。 特点： 模板不可以直接使用，只是一个框架 模板的通用并不是万能的 泛型编程主要利用的思想就是模板 模板分为函数模板和类模板 总结： 函数模板利用关键字template 使用函数模板有两种方式：自动类型推导、显示指定类型 模板的目的是为了提高复用性，将类型参数化 注意事项： 自动类型推导，必须推导出一致的数据类型T，才可以使用 模板必须要确定出T的数据类型，才可以使用 普通函数与函数模板的区别： 普通函数调用时可以发生自动类型转换
使用C++模板判断类型的两种情形
clever101的专栏
03-02 1万+
作者：朱金灿来源：http://blog.csdn.net/clever101  在使用模板时经常会碰到两种需求：一种是判断输入的两个模板类型是否一样，另一种情况是判断输入的模板类型是否为指定的类型。从网上找了些资料，实现了这两种需求。  首先是实现判断输入的两个模板类型是否一样，代码很简单：//利用 c++模板 类型 推导思想，实现最简单的 判断两个类型 是否一样的 方法 template&lt...
c++ 判断模板参数类型
shenmingyi.blog.csdn.net
08-16 2382
c++ 判断模板参数类型
C++11 is_same＜T, U＞::value 模板类（用来判断两个类型是否相同）
Dontla的博客
05-24 3713
可以用于类型判断和类型推导，它可以帮助我们编写更加通用和灵活的代码。是 C++11 引入的类型判断工具，它定义在。可以用来判断两个类型是否相同，如果相同则返回。，用来表示两个类型是否相同。，表示两个类型不相同。在特化版本中，我们将。在上面的代码中，我们定义了一个模板类。相同，所以输出结果为 1；不相同，所以输出结果为 0。，并且有一个静态成员变量。在上面的代码中，我们使用。，表示两个类型相同。
C++ 模板判断类型
weixin_34348111的博客
03-03 1631
2019独角兽企业重金招聘Python工程师标准>>> ...
C++中模板类型(下)
超级霸霸强的博客
11-14 1134
C++中模板类型(下) 类模板的继承 类模板成员函数类内实现 在类模板的继承中，我们必须像如下程序一样，在子类中给予父类模板数据类型，使得当定义子类对象时，从父类继承过来的拿一部分可以给予确定的内存空间。 #include<iostream> #include<string> usingnamespacestd; template<classT1> classPerson { public: T1age;...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

尘中远

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值