{"id":4523,"date":"2009-04-22T13:06:00","date_gmt":"2009-04-22T13:06:00","guid":{"rendered":"https:\/\/blogs.msdn.microsoft.com\/vcblog\/2009\/04\/22\/decltype-c0x-features-in-vc10-part-3\/"},"modified":"2019-02-18T18:45:56","modified_gmt":"2019-02-18T18:45:56","slug":"decltype-c0x-features-in-vc10-part-3","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/cppblog\/decltype-c0x-features-in-vc10-part-3\/","title":{"rendered":"decltype: C++0x Features in VC10, Part 3"},"content":{"rendered":"

Part 1<\/font><\/a> of this series covered lambdas<\/b>, auto<\/b>, and static_assert<\/b>.<\/p>\n

<\/span><\/p>\n

<\/p>\n

 <\/p>\n

<\/span><\/p>\n

Part 2<\/font><\/a> of this series covered rvalue references<\/b>, which enable move semantics<\/b> and perfect forwarding<\/b>.<\/p>\n

<\/span><\/p>\n

<\/p>\n

 <\/p>\n

<\/span><\/p>\n

Today, I’m going to talk about decltype<\/b>, which allows perfect forwarding functions to have arbitrary return types.  It’s of interest to people who are writing highly generic code.<\/p>\n

<\/span><\/p>\n

<\/p>\n

 <\/p>\n

<\/span><\/p>\n

<\/p>\n

 <\/p>\n

<\/span><\/p>\n

the return type problem<\/p>\n

<\/span><\/b><\/p>\n

<\/p>\n

 <\/p>\n

<\/span><\/p>\n

C++98\/03 has an interesting blind spot – given an expression like <\/span>x * y<\/span>, where <\/span>x<\/span> and <\/span>y<\/span> have arbitrary types, there’s no way to say “the type of <\/span>x * y<\/span>“.  If <\/span>x<\/span> is of type <\/span>Watts<\/span> and <\/span>y<\/span> is of type <\/span>Seconds<\/span>, then <\/span>x * y<\/span> might be of type <\/span>Joules<\/span>.  Given <\/span>print(const T& t)<\/span>, you can call <\/span>print(x * y)<\/span>, and <\/span>T<\/span> will be deduced to be <\/span>Joules<\/span>, but this doesn’t work in reverse: when writing <\/span>multiply(const A& a, const B& b)<\/span>, you can’t name its return type while preserving full generality.  Even though when <\/span>multiply<A, B>()<\/span> is instantiated, the compiler knows the type of <\/span>x * y<\/span>, that information is unavailable to you here.  The C++0x keyword <\/span>decltype<\/span> removes this blind spot, allowing you to say “<\/span>multiply()<\/span> returns the type of <\/span>x * y<\/span>“.  (<\/span>decltype<\/span> is an abbreviation of “declared type”; I pronounce it as rhyming with “speckle type”.)<\/p>\n

<\/span><\/p>\n

<\/p>\n

 <\/p>\n

<\/span><\/p>\n

<\/p>\n

 <\/p>\n

<\/span><\/p>\n

decltype: the pattern<\/p>\n

<\/span><\/b><\/p>\n

<\/p>\n

 <\/p>\n

<\/span><\/p>\n

Here’s how to write a completely generic functor that wraps <\/span>operator+()<\/span>.  This <\/span>Plus<\/span> functor is not a template, but it has a templated function call operator that takes two arguments of arbitrary (and possibly different) types, adds them together, and returns the result, which can be of arbitrary (and possibly different from both of the arguments) type.<\/p>\n

<\/span><\/p>\n

<\/p>\n

 <\/p>\n

<\/span><\/p>\n

C:Temp>type plus.cpp<\/p>\n

<\/span><\/p>\n

#include <algorithm><\/p>\n

<\/span><\/p>\n

#include <iostream><\/p>\n

<\/span><\/p>\n

#include <iterator><\/p>\n

<\/span><\/p>\n

#include <ostream><\/p>\n

<\/span><\/p>\n

#include <s\ntring><\/p>\n

<\/span><\/p>\n

#include <utility><\/p>\n

<\/span><\/p>\n

#include <vector><\/p>\n

<\/span><\/p>\n

using namespace std;<\/p>\n

<\/span><\/p>\n

<\/p>\n

 <\/p>\n

<\/span><\/p>\n

struct Plus {<\/p>\n

<\/span><\/p>\n

    template <typename T, typename U><\/p>\n

<\/span><\/p>\n

    auto<\/b> operator()(T&& t, U&& u) const<\/p>\n

<\/span><\/p>\n

    -> decltype(forward<T>(t) + forward<U>(u))<\/b> {<\/p>\n

<\/span><\/p>\n

        return forward<T>(t) + forward<U>(u);<\/p>\n

<\/span><\/p>\n

    }<\/p>\n

<\/span><\/p>\n

};<\/p>\n

<\/span><\/p>\n

<\/p>\n

 <\/p>\n

<\/span><\/p>\n

int main() {<\/p>\n

<\/span><\/p>\n

    vector<int> i;<\/p>\n

<\/span><\/p>\n

    i.push_back(1);<\/p>\n

<\/span><\/p>\n

    i.push_back(2);<\/p>\n

<\/span><\/p>\n

    i.push_back(3);<\/p>\n

<\/span><\/p>\n

<\/p>\n

 <\/p>\n

<\/span><\/p>\n

    vector<int> j;<\/p>\n

<\/span><\/p>\n

    j.push_back(40);<\/p>\n

<\/span><\/p>\n

    j.push_back(50);<\/p>\n

<\/span><\/p>\n

    j.push_back(60);<\/p>\n

<\/span><\/p>\n

<\/p>\n

 <\/p>\n

<\/span><\/p>\n

    vector<int> k;<\/p>\n

<\/span><\/p>\n

<\/p>\n

 <\/p>\n

<\/span><\/p>\n

    vector<string> s;<\/p>\n

<\/span><\/p>\n

    s.push_back(“cut”);<\/p>\n

<\/span><\/p>\n

    s.push_back(“flu”);<\/p>\n

<\/span><\/p>\n

    s.push_back(“kit”);<\/p>\n

<\/span><\/p>\n

<\/p>\n

 <\/p>\n

<\/span><\/p>\n

    vector<string> t;<\/p>\n

<\/span><\/p>\n

    t.push_back(“e”);<\/p>\n

<\/span><\/p>\n

    t.push_back(“ffy”);<\/p>\n

<\/span><\/p>\n

    t.push_back(“tens”);<\/p>\n

<\/span><\/p>\n

<\/p>\n

 <\/p>\n

<\/span><\/p>\n

    vector<string> u;<\/p>\n

<\/span><\/p>\n

<\/p>\n

 <\/p>\n

<\/span><\/p>\n

    transform(i.begin(), i.end(), j.begin(), back_inserter(k), Plus());<\/p>\n

<\/span><\/p>\n

    transform(s.begin(), s.end(), t.begin(), back_inserter(u), Plus());<\/p>\n

<\/span><\/p>\n

<\/p>\n

 <\/p>\n

<\/span><\/p>\n

    for_each(k.begin(), k.end(), [](int n) { cout << n << ” “; });<\/p>\n

<\/span><\/p>\n

    cout << endl;<\/p>\n

<\/span><\/p>\n

<\/p>\n

 <\/p>\n

<\/span><\/p>\n

    for_each(u.begin(), u.end(), [](const string& r) { cout << r << ” “; });<\/p>\n

<\/span><\/p>\n

    cout << endl;<\/p>\n

<\/span><\/p>\n

}<\/p>\n

<\/span><\/p>\n

<\/p>\n

 <\/p>\n

<\/span><\/p>\n

C:Temp>cl \/EHsc \/nologo \/W4 plus.cpp<\/p>\n

<\/span><\/p>\n

plus.cpp<\/p>\n

<\/span><\/p>\n

<\/p>\n

 <\/p>\n

<\/span><\/p>\n

C:Temp>plus<\/p>\n

<\/span><\/p>\n

41 52 63<\/p>\n

<\/span><\/p>\n

cute fluffy kittens<\/p>\n

<\/span><\/p>\n

<\/p>\n

 <\/p>\n

<\/span><\/p>\n

Compare this to C++98\/03 <functional>’s <\/span>std::plus<T><\/span> (which is unchanged in C++0x).  Because it’s a class template, you’d have to pass <\/span>plus<int>()<\/span> and <\/span>plus<string>()<\/span>, repeating the element types.  Its non-templated function call operator has the form <\/span>T operator()(const T& x, const T& y) const<\/span>, making it unable to deal with 2 different types, much less 3 different types, without resorting to implicit conversions.  (You can feed <\/span>plus<string>()<\/span> a <\/span>string<\/span> and a <\/span>const char *<\/span>.  That will construct a temporary <\/span>string<\/span> from the second argument, before concatenating the two <\/span>string<\/span>s.  The performance of this is not especially desirable.)  Finally, because it takes <\/span>const T&<\/span>, it can’t take advantage of C++0x move semantics.  <\/span>Plus<\/span> avoids all of this: <\/span>Plus()<\/span> doesn’t repeat the element type, it deals with the “3 different types” case, and because it uses perfect forwarding, it respects move semantics.<\/p>\n

<\/span><\/p>\n

<\/p>\n

 <\/p>\n

<\/span><\/p>\n

<\/p>\n

 <\/p>\n

<\/span><\/p>\n

trailing return types<\/p>\n

<\/span><\/b><\/p>\n

<\/p>\n

 <\/p>\n

<\/span><\/p>\n

Now, let’s look at that templated function call operator again:<\/p>\n

<\/span><\/p>\n

<\/p>\n

 <\/p>\n

<\/span><\/p>\n

template <typename T, typename U><\/p>\n

<\/span><\/p>\n

auto<\/span><\/b> operator()(T&& t, U&& u) const<\/p>\n

<\/span><\/p>\n

-> decltype(forward<T>(t) + forward<U>(u))<\/span><\/b> {<\/p>\n

<\/span><\/p>\n

    return forward<T>(t) + forward<U>(u);<\/p>\n

<\/span><\/p>\n

}<\/p>\n

<\/span><\/p>\n

<\/p>\n

 <\/p>\n

<\/span><\/p>\n

Here, <\/span>auto<\/span> has a different meaning from <\/span>for (auto i = v.begin(); i != v.end(); ++i)<\/span>, where it says “make the type of this thing the same as the type of whatever initializes it”.  When used as a return type, <\/span>auto<\/span> says “this function has a trailing-return-type<\/i>; after I declare its parameters, I’ll tell you what its return type is”.  (The C++0x Working Draft N2857<\/font><\/a> calls this a late-specified return type<\/i>, but this is being renamed to trailing-return-type<\/i>; see paper N2859<\/font><\/a>.)  If this seems suspiciously similar to how lambdas are given explicit return types, that’s because it is.  A lambda’s return type has to go on the right in order for its lambda-introducer<\/i> <\/span>[]<\/span> to appear first.  Here, the <\/span>decltype<\/span>-powered return type has to go on the right in order for the function parameters <\/span>t<\/span> and <\/span>u<\/span> to be declared first.  Where the <\/span>auto<\/span> appears on the left, the template parameters <\/span>T<\/span> and <\/span>U<\/span> are visible, but the function parameters <\/span>t<\/span> and <\/span>u<\/span> are not yet visible, and that’s what <\/span>decltype<\/span> needs.  (Technically, <\/span>decltype(forward<T>(*static_cast<T *>(0)) + forward<U>(*static_cast<U *>(0)))<\/span> could go on the left, but that’s an abomina\ntion.)<\/p>\n

<\/span><\/p>\n

<\/p>\n

 <\/p>\n

<\/span><\/p>\n

As for the expression given to <\/span>decltype<\/span>, giving it the same expression as the <\/span>return<\/span> statement ensures correctness in all cases.  (Pop quiz: why would <\/span>decltype(t + u)<\/span> be wrong?)  The repetition here is unavoidable but centralized – it appears exactly once, on adjacent lines, so it is not dangerous.<\/p>\n

<\/span><\/p>\n

<\/p>\n

 <\/p>\n

<\/span><\/p>\n

<\/p>\n

 <\/p>\n

<\/span><\/p>\n

another example<\/p>\n

<\/span><\/b><\/p>\n

<\/p>\n

 <\/p>\n

<\/span><\/p>\n

For completeness, here’s that “3 different types” example:<\/p>\n

<\/span><\/p>\n

<\/p>\n

 <\/p>\n

<\/span><\/p>\n

C:Temp>type mult.cpp<\/p>\n

<\/span><\/p>\n

#include <algorithm><\/p>\n

<\/span><\/p>\n

#include <iostream><\/p>\n

<\/span><\/p>\n

#include <iterator><\/p>\n

<\/span><\/p>\n

#include <ostream><\/p>\n

<\/span><\/p>\n

#include <utility><\/p>\n

<\/span><\/p>\n

#include <vector><\/p>\n

<\/span><\/p>\n

using namespace std;<\/p>\n

<\/span><\/p>\n

<\/p>\n

 <\/p>\n

<\/span><\/p>\n

struct Multiplies {<\/p>\n

<\/span><\/p>\n

    template <typename T, typename U><\/p>\n

<\/span><\/p>\n

    auto operator()(T&& t, U&& u) const<\/p>\n

<\/span><\/p>\n

    -> decltype(forward<T>(t) * forward<U>(u)) {<\/p>\n

<\/span><\/p>\n

        return forward<T>(t) * forward<U>(u);<\/p>\n

<\/span><\/p>\n

    }<\/p>\n

<\/span><\/p>\n

};<\/p>\n

<\/span><\/p>\n

<\/p>\n

 <\/p>\n

<\/span><\/p>\n

class Watts {<\/p>\n

<\/span><\/p>\n

public:<\/p>\n

<\/span><\/p>\n

    explicit Watts(const int n) : m_n(n) { }<\/p>\n

<\/span><\/p>\n

    int get() const { return m_n; }<\/p>\n

<\/span><\/p>\n

private:<\/p>\n

<\/span><\/p>\n

    int m_n;<\/p>\n

<\/span><\/p>\n

};<\/p>\n

<\/span><\/p>\n

<\/p>\n

 <\/p>\n

<\/span><\/p>\n

class Seconds {<\/p>\n

<\/span><\/p>\n

public:<\/p>\n

<\/span><\/p>\n

    explicit Seconds(const int n) : m_n(n) { }<\/p>\n

<\/span><\/p>\n

    int get() const { return m_n; }<\/p>\n

<\/span><\/p>\n

private:<\/p>\n

<\/span><\/p>\n

    int m_n;<\/p>\n

<\/span><\/p>\n

};<\/p>\n

<\/span><\/p>\n

<\/p>\n

 <\/p>\n

<\/span><\/p>\n

class Joules {<\/p>\n

<\/span><\/p>\n

public:<\/p>\n

<\/span><\/p>\n

    explicit Joules(const int n) : m_<\/span><\/p><\/p>\n","protected":false},"excerpt":{"rendered":"

Part 1 of this series covered lambdas, auto, and static_assert.   Part 2 of this series covered rvalue references, which enable move semantics and perfect forwarding.   Today, I’m going to talk about decltype, which allows perfect forwarding functions to have arbitrary return types.  It’s of interest to people who are writing highly generic code. […]<\/p>\n","protected":false},"author":289,"featured_media":35994,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[1],"tags":[],"class_list":["post-4523","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-cplusplus"],"acf":[],"blog_post_summary":"

Part 1 of this series covered lambdas, auto, and static_assert.   Part 2 of this series covered rvalue references, which enable move semantics and perfect forwarding.   Today, I’m going to talk about decltype, which allows perfect forwarding functions to have arbitrary return types.  It’s of interest to people who are writing highly generic code. […]<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/posts\/4523","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/users\/289"}],"replies":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/comments?post=4523"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/posts\/4523\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/media\/35994"}],"wp:attachment":[{"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/media?parent=4523"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/categories?post=4523"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/tags?post=4523"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}