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;
}