auto类型推断

auto类型常规推断：用于变量的自动类型推断。

  • 声明变量的时候初始化的类型自动为此选择匹配的类型，不需要程序员显示的指定类型

auto的特点：

  • auto的自动类型推断发生在编译期间

  • auto定义变量必须立即初始化，这样编译器才能推断出它的实际类型，编译器才能确定auto类型以及整个变量的类型然后再编译期间才可以用真正的类型替换掉auto这个类型占位符

  • auto的使用比较灵活，可以和指针、引用、const等限定符结合使用

  • auto推断出来会代表一个具体的类型，auto相当于函数模板类型推断中的参数T

1
2
auto x = 27;//auto代表一个类型，x也有一个类型。
            //x=int auto=int

传值方式(非指针，非引用)

auto后面直接接变量名，这叫传值方式

1
2
3
4
5
6
7
8
9
10
11
12
13
auto x = 27;
const auto x2 = x;//估计x2 = const int ,auto int
const auto& xy = x;//这个auto并不是传值方式,估计xy=const int &,auto =int
auto xy2 = xy;//估计xy2=int,auto = int

using boost::typeindex::type_id_with_cvr;
cout << "x2=" << type_id_with_cvr<decltype(x2)>().pretty_name() << endl;  //xy=const int

using boost::typeindex::type_id_with_cvr;
cout << "xy=" << type_id_with_cvr<decltype(xy2)>().pretty_name() << endl;  //xy=const int &

using boost::typeindex::type_id_with_cvr;
cout << "xy2=" << type_id_with_cvr<decltype(xy2)>().pretty_name() << endl;  //xy2=int

总结传值方式对auto类型：会抛弃引用、const等修饰符

指针或引用类型但不是万能引用

auto后面接一个&

1
2
3
4
5
6
7
8
auto x = 27;    
const auto& xy = x;

auto& xy3 = xy;             //xy3 = int const &
auto y = new auto(100);     //y = int*
const auto* xp = &x;        //xp = int const *
auto* xp2 = &x;             //xp2= int*
auto xp3 = &x;              //xp3= int*

可以利用函数模板测

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
#include <iostream>
#include<boost/type_index.hpp>
using namespace std;

template<typename T>
void myfunc(T& tmprv) {
    cout << "-----------------begin------------------" << endl;
    using boost::typeindex::type_id_with_cvr;
    cout << "T=" << type_id_with_cvr<T>().pretty_name() << endl;
    cout << "tmprv=" << type_id_with_cvr<decltype(tmprv)>().pretty_name() << endl;
    cout << "-------------------end----------------------" << endl;
}
template<typename T>
void myfunc2(T tmprv) {
    cout << "-----------------begin------------------" << endl;
    using boost::typeindex::type_id_with_cvr;
    cout << "T=" << type_id_with_cvr<T>().pretty_name() << endl;
    cout << "tmprv=" << type_id_with_cvr<decltype(tmprv)>().pretty_name() << endl;
    cout << "-------------------end----------------------" << endl;
}
template<typename T>
void myfunc3(const T* tmprv) {
    cout << "-----------------begin------------------" << endl;
    using boost::typeindex::type_id_with_cvr;
    cout << "T=" << type_id_with_cvr<T>().pretty_name() << endl;
    cout << "tmprv=" << type_id_with_cvr<decltype(tmprv)>().pretty_name() << endl;
    cout << "-------------------end----------------------" << endl;
}
template<typename T>
void myfunc4( T* tmprv) {
    cout << "-----------------begin------------------" << endl;
    using boost::typeindex::type_id_with_cvr;
    cout << "T=" << type_id_with_cvr<T>().pretty_name() << endl;
    cout << "tmprv=" << type_id_with_cvr<decltype(tmprv)>().pretty_name() << endl;
    cout << "-------------------end----------------------" << endl;
}

template<typename T>
void myfunc5(T tmprv) {
    cout << "-----------------begin------------------" << endl;
    using boost::typeindex::type_id_with_cvr;
    cout << "T=" << type_id_with_cvr<T>().pretty_name() << endl;
    cout << "tmprv=" << type_id_with_cvr<decltype(tmprv)>().pretty_name() << endl;
    cout << "-------------------end----------------------" << endl;
}
int main()
{
    int x = 27;
    const int& xy = x;

    myfunc(xy);             //T=int const   tmprv=int const &
    myfunc2(new int(100));  //T=int *       tmprv=int *
    myfunc3(&x);            //T=int         tmprv=int const *
    myfunc4(&x);            //T=int         tmprv=int *
    myfunc5(&x);            //T=int *       tmprv=int *
}

万能引用类型

与讲解函数模板类型推断万能引用的情形

1
2
3
4
5
6
7
8
9
int x=1;
const int x2 = x;

auto&& mnyy0 = 222;//222是右值，auto = int，mnyy0= int &&(右值引用)
cout << "mnyy0 =" << type_id_with_cvr<decltype(mnyy0)>().pretty_name() << endl; //mnyy0 =int &&


auto&& mnyy1 = x;   //auto = int&  mnyy1 = int&
auto&& mnyy2 = x2;  //auto = int const& mnyy2 = int const &