C++11 中的 decltype(auto) - 推导返回类型

Question

auto deduction of return types is possible in C++14 but I am trying to write something similar in C++11 ie

If I were to write in C++14, it would be

struct MyTypeA{
    std::vector<int> _d;
};

struct MyTypeB{
    int _id;
    std::string _name;
    MyTypeA _data;
};

decltype(auto) MakeObject(const MyTypeA& obj) {
    return std::make_tuple(obj._vec);
}

decltype(auto) MakeObject(const MyTypeB& obj) {
    return std::make_tuple(obj._id, obj._name, std::make_tuple(MakeObject(obj._data)));
}

The above is C++14 and I can rewrite MakeObject something similar in C++11 as below,

auto MakeObject (const MyTypeA& obj) -> decltype( std::make_tuple(obj._d)){
    return std::make_tuple(obj._d);
};

auto MakeObject (const MyTypeB& obj) -> decltype( std::make_tuple(obj._id, obj._name, std::make_tuple(MakeObject(obj._data)))){
    return std::make_tuple(obj._id, obj._name, std::make_tuple(MakeObject(obj._data)));
};

And as you can see I have a bunch of overloaded non-member functions. Though this works, it seems very verbose and redundant code. Is there a better way to do this in C++11?

Answer 1

Is there a better way to do this in C++11?

While return type of a regular function cannot be deduced prior to C++14, the return type of lambda can. And a non-capturing lambda behaves much like a function. So, in C++11 you could do

auto MakeObject = [](const MyTypeA& obj) {
     return std::make_tuple(obj._vec);
}

However, this doesn't allow for overloading, which you use. If you need overloading, then the trailing decltype may be a better choice.

Answer 2

#define RETURNS(...) decltype(__VA_ARGS__) { return __VA_ARGS__; }

Then you get

auto MakeObject(const MyTypeA& obj)
->RETURNS(std::make_tuple(obj._vec))

This may or may not be considered better. But it does remove the DRY violation.