C++11---类型推导auto

1. auto使用

auto是一个占位符  定义的变量  可以根据初始化的值 在编译的时候推导出变量名的类型

int main()
{
    auto x = 10;
    auto dx = 12.23;
    auto fx = 12.23f;
    auto ch = 'a';
    return 0;
}

int main()
{
    auto x = 5;              //x   int
    const auto* xp = &x;     //xp  const int*       auto   const int
    auto ip = &x;           //ip   int*              auto   int*
    auto* sp = &x;           //sp   int*             auto    int
}

1.1 auto和引用

int main()
{
    //int a = 10;
    const int a = 10;  //常变量
    auto b = a;       //b的改变并不影响a的改变      b    int     auto   int
    auto& c = a;      //c是a的引用，c改变影响a    以前c  int&   auto int    现在c  const int&   auto   const  int

}

1.2 auto和指针

int main()
{
    const int a = 10;
    auto* p = &a;     //p    const int*       auto  const int
    //*p = 100;
}

总结：
当auto和const进行结合时，一定要注意指针和引用
本来auto是简单引用，原始是普通变量，可以改变原始值，但如果原始是常变量，就不能改变
如果原始是普通变量，auto是普通指针，可以进行改变指向或者解引用，但如果原始是常变量，auto变成常量指针，不能进行解引用

1.3 auto可以推导函数的返回值类型

template<class T>
T my_add(T a, T b)
{
    return a + b;
}
int main()
{
    auto x = my_add(12, 23);
    return 0;
}

1.4 auto作为函数的形参类型        auto进行类型推导很像函数模板

void func(auto x)
{
    cout << "x type: " << typeid(x).name() << endl;
}
int main()
{
    func(12);
    func(12.23);
    func('a');
    int x = 10;
    func(&x);
    const int y = 20;
    func(&y);

    return 0;
}

//
void func(auto x)
{
    cout << sizeof(x) << endl;
    cout << typeid(x).name() << endl;
}
void funcr(auto &x)     //void funcr(int(&x)[10])
{
    cout << sizeof(x) << endl;
    cout << typeid(x).name() << endl;
}
int main()
{
    int arr[10] = { 1,2,3 };
    //int(&br)[10] = arr;//引用arr的时候

    func(arr);//函数名  首元素地址   指针类型   4个字节  int*
    funcr(arr);//x是arr的别名  x是数组  auto推导出来的类型是数组类型   40个字节   int[10]
    return 0;

}

2. auto的限制

2.1 auto无法定义数组

int main()
{
    int ar[10] = { 1,2,3,4 };
    auto br = ar;   //br=>int*
    auto& cr = ar;  //br=>int[10]

    //auto dr[10] = { 1,2,3,4,5.5 };//error 无法推导出数组的类型
    //auto dr[10] = ar;  // error    ar=>int*  dr是数组类型
}

2.2 结构体设计或类型设计auto不能用于非静态成员变量

struct Foo
{
    //auto val;//不允许，因为只有我们定义了Foo时，才知道里面的具体类型
    static const auto num = 0;//静态常变量   auto只能推导出short、char、int、long long
    //static const auto num1 = 0.0;//error
};
int main()
{
    //Foo a = { 1 };//结构体初始化使用花括号  由于花括号不能对数组进行，那也不能对结构体进行
    return 0;
}

2.3 auto不能作为函数参数

int func(auto a,auto b)
{
    cout << a << " " << b << endl;
}
int main()
{
    func(12, 23);
}

2.4 实例化模板时，不能使用auto作为模板参数

template <class T>
struct Test
{
};
int func()
{
    Test<double> t;
    Test<auto> t1 = t;//error,无法推导模板类型
    return 0;
}