C++ 11 auto(自动类型推导) 和 decltype(获取表达式类型)

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