类型推导

auto

auto只是一个类型声明的“占位符”，通过变量的初始化表达式推导出变量具有的类型
使用auto声明的变量必须马上初始化，在编译时将auto替换为真正的类型

	// auto
	auto x = 5; // int
	auto pi = new auto(1); // pi被推导为*int
	const auto* v = &x, u = 6; // v:const int * ,u:const int (u必须初始化为一个int,不然推导产生二义性)
	static auto y = 0.0; // double

	// auto只能是一个类型声明的“占位符”
	// 使用auto声明的变量必须马上初始化，在编译时将auto替换为真正的类型
	// auto s;

当不声明为指针或引用时
推导结果 = 初始化表达式抛弃引用和抛弃cv限定符后结果
当声明为指针或引用时
推导结果 = 初始化表达式的cv限定符

	int x = 0;
	auto *a = &x; // a -> int*   auto -> int
	auto  b = &x; // b -> int*   auto -> int*
	auto &c = x;  // c -> int&   auto -> int
	auto  d = c;  // d -> int    auto -> int  抛弃引用类型

	const auto e = x; // const int
	auto f = e; // int  表达式带有const时，会抛弃const

	const auto& g = x; // const int&
	auto& h = g; // const int&

auto的限制

void fun(auto a = 1)  // error 不能用于函数参数
struct Foo {
	auto var1 = 0; // error 不能用与非静态成员变量，
	static const auto var2 = 0; // ok 
};
template <typename T>
struct Bar{};
int main(void) {
	int arr[10] = {0};
	auto aa = arr; // ok , aa -> int *,arr本来就是个数组首地址
	auto rr[10] = arr;  // error, 不能定义数组

	Bar<int> bar;
	Bar<auto> bb = bar; // error 无法推导出模板参数
 }

什么时候用auto

迭代器

auto it = resultMap.begin();....

std::unordered_multimap<int, int> map;
auto range = map.equal_range(key); // 在unordered_multimap中查找一个范围，返回值是一个pair

无法知道变量会被定义成什么类型时候 P8

decltype

decltype(表达式)，用来推导表达式的类型，在编译器完成，不会真正计算表达式的值

	int x = 0;
	decltype(x) y; // y -> int
	decltype(x + y) z; // z -> int

	const int& i = x;
	decltype(i) j = y; // j -> const int&

	const decltype(z) *p = &z; // p -> const int*
	decltype(z) *pi = &z; // pi -> int *
	decltype(pi)* pp = &pi; // pp -> int **

推导规则

exp	decltype(exp)
1.标识符，类访问表达式	和exp类型一致
2.函数调用	和函数返回值一致
3.左值	exp类型的左值引用
4.其他	和exp类型一致

struct Foo{ int x }; 
const Foo foo = Foo();

deltype(foo.x) a = 0;  // a -> int   推导规则1
deltype((foo.x)) b = a;  // b -> const int &   推导规则3 ，括号表达式是左值，推导出左值引用

int n = 0, m = 0;
decltype (n + m) c; // c -> int  推导规则4, n+m 返回是右值
decltype (n += m) d; // d -> int & 推导规则3， n+=m 返回一个左值

用处

解决不必要的模板特化
通过变量表达式抽取变量类型上

vector<int> v;
decltype(v)::value_type i = 0;

返回类型后置语法，auto和decltype结合

为了解决返回值类型依赖于参数，导致难以确定返回值类型的问题

template<typename T, typename U>
auto add(T a, U b) -> decltype(a + b) {
	return a + b;
}

int& foo(int &i);
float foo(float &x);

template<typename T>
auto func(T& val) -> deltype(foo(val)) {
	return foo(val); // 自动推导出foo(val)可能出现的类型
}

PS

C++14之后，返回值可以自动推导了，后置返回值也不需要写了

template<typename T, typename U>
auto add(T a, U b) {
	return a + b;
}

模板的细节改进

using

重新定义一个类型（别名语法）
声明命名空间
子类中声明使用父类函数

class A {
public:
	A() { cout << "aaa" << endl; }
	void funA(int a) {
		cout << "funcA" << endl;
	}
};
class B : public A {
public:
	using A::A;
	using A::funA;
};

int main()
{
	A* a = new A; // aaa
	B* b = new B; // aaa
}

using的别名语法
覆盖了typedef的全部功能，且可以直接定义模板别名

template<typename T>
using func_t = void(*)(T, T);
func_t<int> fun;

函数模板的默认模板参数

函数模板，当所有模板参数都有默认参数时，函数调用如同一个普通函数。
模板参数填充的方式为从左到右。
可以采用自动推导和默认模板混一起的方式。优先级：自动推导》默认参数
类模板，使用时必须跟着<>来实例化

template<typename T = int> 
void fun(T a) {
	cout << a;
}

// 一部分模板参数采用默认模板，一部分自动推导
// 优先级：自动推导 》 默认参数
template<typename R = int, typename T> 
R fun2(T a) {
	return a;
}

template<typename T = char>
class A {
	T a;
};
int main()
{
	fun(123); // 函数模板，当所有模板参数都有默认参数时，函数调用如同一个普通函数

	auto retVal = fun2(123); // 自动推导T -> int, retVal->int

	auto retVal2 = fun2<long>(12); // 模板参数填充的方式为从左到右，R -> long   T -> int   retVal2 -> long

	// A a; // error
	A<int> a; // ok 类模板，使用时必须跟着<>来实例化
}

来源：CSDN

作者：amy260231120

链接：https://blog.csdn.net/amy260231120/article/details/104088110

标签

auto

初始化

深入应用C++11（第一章）——auto,decltype,using,默认模板参数

类型推导

auto

decltype

返回类型后置语法，auto和decltype结合

PS

模板的细节改进

using

函数模板的默认模板参数