auto与decltype

auto

语法：

auto 变量名{值} 或 auto 函数名（int a ,int b)

auto 可以声明一个变量，让编译器根据变量的值来推断变量的类型

//例如
auto a{123};
//相当于
int  a{123};

char a;
auto b{a};//此时b的类型等于a的类型 char

利用auto的这一特性我们可以利用auto来创建一个函数

auto ave(int a,int b)
{
    return a+b;
}
//相当于
int ave(int a,int b)
{
    return a+b;
}

注* 以上并非auto的最恰当用法，不管是函数还是变量，都不推荐使用auto来声明

autos 不保留const属性

const int a{100};
auto      b = a;//此时b 为int类型   auto默认会丢弃const

auto会优先推断为值类型而非引用类型

int     c{1500};
int &   c1{c};
auto    d=c1;//此时 d 为int类型    auto会优先推断为值类型而非引用类型

d为int类型 而非 int&

auto 利用函数返回值来确定类型的时候，函数会执行

auto ave(int a,int b)
{
    return a + b;
}

auto x=ave(1,2);//ave（1,2) 会执行x的类型依据ave函数的返回值来确定

decltype

可以得出一个表达式的类型

语法：decltype（表达式）

int a{};
unsigned b{};
decltype(a-b)  x;//相当于 unsigned  x

原则：

   如果decltype 内的表达式没经历任何运算，那么得出的数据类型同表达式内的数据类型，并且decltype可以保留 const和引用

int a;
const int b;
int & la{a};
int * pa{&a};

decltype(a) x;//相当于 int x;
decltype(b) x;//相当于 const int x;
decltype(la)x;//相当于 int & x;
decltype(pa)x;//相当于 int * x;

    如果decltype内的表达式经历了运算，那么得出的数据类型是根据运算结果是否固定的内存地址（左值）来决定，如果有固定的内存地址则得出的类型为该类型的引用类型，如果没有固定的内存地址，则得出的类型为该结果的类型

int  a{100},b{200};
int* pa{&a};

decltype(a+b) x;//相当于 int x;
decltype(*pa) x;//相当于 int& x;
decltype(pa[0]) x;//相当于 int& x;

如果decltype 内的表达式是一个函数，那么得出的数据类型是根据函数的返回类型来确定的；

int ave(int a,int b)
{
   return a+b;
}

decltype (ave(100,200)) x;//相当于 int x

注* decltype 不会真的执行表达式的运算，因此ave函数并未执行。decltype只会根据表达式的运算推算出数据类型。

---

拖尾函数

语法：auto bigger1(int& a,int& b)->类型

int& bigger(int& a,int& b)
{
    return a > b ? a : b;
}
//若只使用auto的话无法编译成功，此时我们可以使用拖尾函数来实现auto
auto bigger1(int& a,int& b)->int&
{
    return a > b ? a : b;
}

int main()
{
    int a{200};
    int b{300};
    bigger(a,b)=500;//此时 b为500
    bigger1(a,b)=500;//此时 bigger1与bigger相同
}

auto->decltype

//不推荐的写法
auto bigger1(int& a,int& b)->decltype(a > b ? a : b)
{
    return a > b ? a : b;
}
//相同与
auto bigger1(int& a,int& b)->int&
{
    return a > b ? a : b;
}

C++14以后的新写法

//常用的写法
decltype(auto) bigger(int& a,int& b)
{
   return a > b ? a : b;
}