C++(2)
auto 占位符 自动类型推导
auto 能够实现类型的自我推导，并不代表一个实际的类型声明。auto 只是一个
类型声明的占位符。
auto 声明的变量，必须马上初始化，以让编译器推断出它的实际类型，并在编译
时将 auto 占位符替换为真正的类型。
注意: C++ 11中 auto 不能用于函数参数 C++ 14 可以
//todo auto 关键字
#include <iostream>
#include <vector>
using namespace std;
void func(){
cout<<"void func(){~~~~}"<<endl;
}
typedef void (*FUNC)();
//C++ 11中 auto 不能用于函数参数 C++ 14 可以
void func2(auto a){
cout<<"void func2(auto a){~~~~} : a="<<a<<endl;
}
int main()
{
auto a = 10; // 自动类型推导
cout<<sizeof(a)<<endl; // 4
auto b = 2.5; // 自动类型推导
cout<<sizeof(b)<<endl; // 8
auto c = "hello"; // 自动类型推导
cout<<sizeof(c)<<endl; // 8
auto d = true; // 自动类型推导
cout<<sizeof(d)<<endl; // 1
auto v={1, 2, 3, 4, 5};
cout<<sizeof(v)<<endl; //16
cout<<v.size()*sizeof(int)<<endl; // 20
auto e = vector<int>{1, 2, 3, 4, 5}; // 自动类型推导
cout<<sizeof(e)<<endl; // 24
cout<<e.size()*sizeof(int)<<endl; // 20
//sizeof运算符返回的是给定类型或对象在内存中所占的字节数。
// 对于标准库中的容器（如std::vector），
// sizeof返回的是容器本身的大小，而不是容器中元素的总大小。
//std::vector是一个模板类，
// 它包含几个指针（通常是三个指针：指向动态数组的指针、指向数组末尾的指针和指向容量末尾的指针），
// 以及一些其他成员变量。
// 在大多数现代系统中，指针的大小通常是8字节（64位系统），因此三个指针总共占用24字节。
const auto f = 10; // 常量表达式，自动类型推导
cout<<f<<endl; // 10
const int m=3;
auto n = m; // 常量表达式，自动类型推导
cout<<n<<endl; // 3
n+=5; // n是常量表达式，就不能修改了
cout<<n<<endl; // 8
static auto g = 10; // 静态局部变量，自动类型推导
cout<<g<<endl; // 10
g+=5; // 静态局部变量，可以修改
cout<<g<<endl; // 15
FUNC p = func;
p(); // 输出void func(){~~~~}
auto p2=func; // 自动类型推导
p2(); // 输出void func(){~~~~}
func2(10); // 输出void func2(auto a){~~~~} : a=10
func2(2.5); // 输出void func2(auto a){~~~~} : a=2.5
func2("hello"); // 输出void func2(auto a){~~~~} : a=hello
func2(true); // 输出void func2(auto a){~~~~} : a=1
return 0;
decltype 关键字 获取表达式类型
decltype(expr);
所推导出来的类型，完全与 expr 类型一致。同 auto 一样，在编译期间完成，并
不会真正计算表达式的值，即上面的推导数并不会导致函数打印的。expr 不可对类型
推导。
//todo decltype 关键字 获取表达式类型
#include <iostream>
#include <vector>
using namespace std;
void func(){
cout<<"void func(){~~~~}"<<endl;
}
typedef void (*FUNC)();
int main(){
int a=10;
decltype(a) b; // b的类型是int
cout<<sizeof(b)<<endl; // 4
decltype("qqqq") p="aaaa"; // const char (&)[5] p的类型是const char*
cout<<sizeof(p)<<endl; // 5
cout<<p<<endl; // aaaa
char *pp="hello";
decltype(pp) ps; // 类型是char*
cout<<sizeof(ps)<<endl; // 8
FUNC func1;
decltype(func1) f=func;
cout<<sizeof(f)<<endl; // 8
f(); // 输出void func(){~~~~}
return 0;
}
推导类型(decltype) 重定义 typedef
//todo 推导类型(decltype) 重定义 typedef
#include <iostream>
#include <map>
using namespace std;
int main(){
map<int, string> mis;
mis.insert(map<int, string>::value_type(1, "apple"));
typedef decltype(map<int, string>::value_type()) my_map;
mis.insert(my_map(2, "banana")); // 推导类型为map<int, string>::value_type()
for(auto i:mis){
cout<<i.first<<" "<<i.second<<endl;
}
return 0;
}
返回类型推导 auto -> decltype
//todo 返回类型推导 auto -> decltype
#include <iostream>
using namespace std;
template<class T1, class T2>
auto sum(T1 a, T2 b)->decltype(a+b){//使用auto关键字表示函数的返回类型将由后面的decltype表达式推导。
return a+b;
}
int main(){
int a=100;
double b=100.2255;
auto i= sum(a,b);
cout<<fixed<<i<<endl;//200.225500
return 0;
}