新手笔记：返回值类型后置

在学习返回值类型后置前需要学会auto与decltype

---

auto

auto可以根据变量自动推导出对应的数据类型，auto修饰的变量必须要初始化

auto a = 10; //成int

auto b = 1145.14; //成double

auto c = 'c'; //成char


class test
{
public:
    int tec;
}

auto tone = test(); //成test类


vector<int> v;
auto it = v.begin(); //成迭代器vector<int>::iterator

以下是auto不能运用的场景

auto a;  //不能，没初始化

class test
{
public:
    auto b=0;  //不能，因为这是非静态成员，非静态成员不属于类是属于对象的
    static auto c=0; //不能，因为必须是非静态常量才行
    static const d=0; //可以
}


auto add(auto num1, auto num2)  //不能，没初始化
{
    return num1+num2;
}


int array[]={1,2,3,4,5,6,7,8,9,10};
auto arr=array; //可以，赋值array的地址，auto成int*
auto arr[]=array; //no
auto arr[]={1,2,3,4,5,6,7,8,9,10}; //不能用auto定义数组


template <class T>
class test
{
    T draingang;
}

int main()
{
    test<auto>t; //不能，auto无法推导出模板参数
}

---

decltype

decltype其实是declare type(声明类型)，语法是decltype (表达式) 变量名;

decltype可以不用初始化，它可以根据表达式里的数据类型来推导出对应的数据类型

int a = 10;
decltype(a) b= 10; //decltype(a) int
const decltype(b) c = 20; //decltype(b) int
decltype(c) d = 50; //decltype(c) const int
int& e = a;
decltype(e) f = b //decltype(e) int&
int&& g = 40; //int&& 右值引用
decltype(g) h = 50; //decltype(g) int&&

-------------------------------------------

int func_int(){}
int& func_int_r() {}
int&& func_int_rr() {}
const int func_int_c() {}
const int& func_int_cc(){}
const int&& func_int_ccc(){}
const test& fun_test_cccc(){}

void test1()
{
	decltype(func_int())a = 20; //int
	decltype(func_int_r())b = a;  //int&
	decltype(func_int_rr())c = 20; //int&&
	decltype(func_int_c())d = 20; //这里不一样，函数的返回类型const int返回的是纯右值，纯右值的情况下，decltype会成int类型
	decltype(func_int_cc())e = d; //const int&
	decltype(func_int_ccc())f = 20; //const int&&
	test p(10); //一个类对象
	decltype(fun_test_cccc())g = p; //const test&
}

需要纪录一个例子

#include <iostream>
using namespace std;
#include <vector>
#include <algorithm>

template <class T>
class callofduty    //伪函数
{
public:
    void operator()(T val)
    {
        cout<<val<<" ";
    }
};

template <class T>
class Display
{
private:
    decltype(T().begin()) it1; //decltype推导出vector<int>::iterator类型
    decltype(T().end()) it2; //decltype推导出vector<int>::iterator类型
public:
    void display(T& v)
    {
        it1=v.begin();
        it2=v.end();
        for_each(it1,it2,callofduty<int>()); //for_each遍历算法，第一个参数为开头，第二个参数为结尾，第三个是对遍历的每个元素通过函数的调用处理，调用在底层大概是 匿名类对象(*it1);
    }
};

void test()
{
    vector<int> v;
    for(int i=0;i<10;i++)
    {
        v.push_back(i); //push_back尾插法把元素放进容器
    }
    Display<vector<int>> p; //不能忘模板的参数列表
    p.display(v);
}

int main()
{
    test();
    cin.get();
    return 0;
}

---

返回值类型后置

代码

template <class T1,class T2>
auto add(T1 a,T2 b) -> decltype(a+b) //auto需要初始化，后边的箭头和decltype(a+b)则是给auto初始化的值
{
    return a+b;
}

void test()
{
    int a=10;
    double b=1145.14;
    auto sum = add(a,b); //函数的模板参数列表可加可不加auto sum<int,double> = add(a,b)
    cout << sum << endl; //1155.14
}

int main()
{
    test();
    cin.get();
    return 0;
}