欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

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

程序员文章站 2022-03-24 22:22:22
问题提出:有一个模板函数,函数在处理int型和double型时需要进行特殊的处理,那么怎么在编译期知道传入的参数的数据类型是int型还是double型呢? 如: #include templ...

问题提出:有一个模板函数,函数在处理int型和double型时需要进行特殊的处理,那么怎么在编译期知道传入的参数的数据类型是int型还是double型呢?

如:

#include 
template
void typecheck(type data)
{
    //do something check data type
    //std::cout<< out put the type
}

这里就需要用到c++11的type_traits头文件了,type_traits头文件定义了很多类型检查相关的方法,上面的例子具体用到了其中两个结构:

std::is_same 判断类型是否一致

位于头文件

这个结构体作用很简单,就是两个一样的类型会返回true

bool isint = std::is_same::value; //为true

下面是官方的例子:

#include 
#include 
#include 

void print_separator()
{
    std::cout << "-----\n";
}

int main()
{
    std::cout << std::boolalpha;

    std::cout << std::is_same::value << '\n';   // true
    std::cout << std::is_same::value << '\n';   // false
    std::cout << std::is_same::value << '\n'; // false

    print_separator();

    std::cout << std::is_same::value << "\n";          // true
    std::cout << std::is_same::value << "\n"; // false
    std::cout << std::is_same::value << "\n";   // true

    print_separator();

    // unlike other types 'char' is not 'unsigned' and not 'signed'
    std::cout << std::is_same::value << "\n";          // true
    std::cout << std::is_same::value << "\n"; // false
    std::cout << std::is_same::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 
template
typecheck(type data)
{
    if(std::is_same::value)
    {
        std::cout<<"int type";
        //do something int 
    }
    else
    {
        //.........
    }
}

视乎很美好,再看一个示例:

// is_same example
#include 
#include 
#include 

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::value << std::endl;//false
      std::cout << "int, int&: " << std::is_same::value << std::endl;//false
      std::cout << "int, const int&: " << std::is_same::value << std::endl;//false
      std::cout << "int, integer_type: " << std::is_same::value << std::endl;//true
      std::cout << "a, b: " << std::is_same::value << std::endl;//false
      std::cout << "a, c: " << std::is_same::value << std::endl;//true
      std::cout << "signed char, std::int8_t: " << std::is_same::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 
#include 
#include 


template
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
void typecheck(type data)
{
    if(std::is_same::value)
    {
        std::cout<<"int type"<::value)
    {
        std::cout<<"string type"<

输出:

int type
int type
int type
int type
int type
int type

测试后发现,虽然变量b,c使用引用,但std::is_same还是能识别出来的,但是!!
如果我显示的指定模板参数类型时情况有不一样了:

#include 
#include 
#include 

template
void typecheck(type data);

int _tmain(int argc, _tchar* argv[])
{
    int a = 1;
    const int& b = a;
    int& c = a;
    int d[12];

    typecheck(a);        //int type
    typecheck(b);//other type
    typecheck(c);        //other type
    typecheck(d[7]);//other type
    typecheck(8);                //int type
    system("pause");
    return 0;
}

template
void typecheck(type data)
{
    if(std::is_same::value)
    {
        std::cout<<"int type"<::value)
    {
        std::cout<<"string 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::type u;
public:
    typedef typename std::conditional< 
        std::is_array::value,
        typename std::remove_extent::type*,
        typename std::conditional< 
            std::is_function::value,
            typename std::add_pointer::type,
            typename std::remove_cv::type
        >::type
    >::type type;
};

看着比较抽象,其实就是把各种引用啊什么的修饰去掉,把cosnt int&退化为int,这样就能通过std::is_same正确识别出加了引用的类型了
上面的例子改为:

#include "stdafx.h"
#include 

#include 
#include 


template
void typecheck(type data);

int _tmain(int argc, _tchar* argv[])
{
    int a = 1;
    const int& b = a;
    int& c = a;
    int d[12];

    typecheck(a);//int type
    typecheck(b);//int type
    typecheck(c);//int type
    typecheck(d[7]);//int type
    typecheck(8);//int type
    system("pause");
    return 0;
}

template
void typecheck(type data)
{
    if(std::is_same::type,int>::value)
    {
        std::cout<<"int type"<

在cppref有个更加详细的例子:

#include 
#include 

template 
struct decay_equiv : 
    std::is_same::type, u>::type 
{};

int main()
{
    std::cout << std::boolalpha
              << decay_equiv::value << '\n'
              << decay_equiv::value << '\n'
              << decay_equiv::value << '\n'
              << decay_equiv::value << '\n'
              << decay_equiv::value << '\n'
              << decay_equiv::value << '\n';
}

输出:

true
true
true
true
true
true
;><:endl else="" other="" pre="">

总结:

在模板里可以通过std::is_same判断模板的类型,从而实现对不同类型的区别对待 在堆类型要求不是非常严格的情况下,可以使用std::decay把类型退化为基本形态,结合std::is_same用,可以判断出更多的情况 ;>
<:endl else="" other="" pre="">;>
;>;>,int>
;>;>,int>