COMP6771

Advanced C++ Programming

Week 8.2

Advanced Types

decltype

decltype(e)

  • Semantic equivalent of a "typeof" function for C++
  • Rule 1:
    • If expression e is any of:
      • variable in local scope
      • variable in namespace scope
      • static member variable
      • function parameters
    • then result is variable/parameters type T
  • Rule 2: if e is an lvalue, result is T&
  • Rule 3: if e is an xvalue, result is T&&
  • Rule 4: if e is a prvalue, result is T

 

Non-simplified set of rules can be found here.

decltype

Examples include:

int i;
int j& = i;

decltype(i) x; // int - variable
decltype((i)) z; // int - lvalue
decltype(j) y; // int& - variable
decltype(5);   // int - prvalue

Determining return types

Iterator used over templated collection and returns a reference to an item at a particular index

template <typename It>
??? find(It beg, It end, int index) {
  for (auto it = beg, int i = 0; beg != end; ++it; ++i) {
    if (i == index) {
      return *it;
    }
  }
  return end;
}

We know the return type should be decltype(*beg), since we know the type of what is returned is of type *beg

Determining return types

This will not work, as beg is not declared until after the reference to beg

template <typename It>
decltype(*beg) find(It beg, It end, int index) {
	for (auto it = beg, int i = 0; beg != end; ++it; ++i) {
		if (i == index) {
			return *it;
		}
	}
	return end;
}

Introduction of C++11 Trailing Return Types solves this problem for us

template <typename It>
auto find(It beg, It end, int index) -> decltype(*beg) {
	for (auto it = beg, int i = 0; beg != end; ++it; ++i) {
		if (i == index) {
			return *it;
		}
	}
	return end;
}

Type Transformations

A number of add, remove, and make functions exist as part of type traits that provide an ability to transform types

Type Transformations

A number of add, remove, and make functions exist as part of type traits that provide an ability to transform types

#include <iostream>
#include <type_traits>

template<typename T1, typename T2>
auto print_is_same() -> void {
	std::cout << std::is_same<T1, T2>() << "\n";
}

auto main() -> int {
	std::cout << std::boolalpha;
	print_is_same<int, int>();
	// true
	print_is_same<int, int &>(); // false
	print_is_same<int, int &&>(); // false
	print_is_same<int, std::remove_reference<int>::type>();
	// true
	print_is_same<int, std::remove_reference<int &>::type>(); // true
	print_is_same<int, std::remove_reference<int &&>::type>(); // true
	print_is_same<const int, std::remove_reference<const int &&>::type>(); // true
}

demo850-transform.cpp

Type Transformations

A number of add, remove, and make functions exist as part of type traits that provide an ability to transform types

#include <iostream>
#include <type_traits>

auto main() -> int {
	using A = std::add_rvalue_reference<int>::type;
	using B = std::add_rvalue_reference<int&>::type;
	using C = std::add_rvalue_reference<int&&>::type;
	using D = std::add_rvalue_reference<int*>::type;

	std::cout << std::boolalpha
	std::cout << "typedefs of int&&:" << "\n";
	std::cout << "A: " << std::is_same<int&&, A>>::value << "\n";
	std::cout << "B: " << std::is_same<int&&, B>>::value << "\n";
	std::cout << "C: " << std::is_same<int&&, C>>::value << "\n";
	std::cout << "D: " << std::is_same<int&&, D>>::value << "\n";
}

Shortened Type Trait Names

Since C++14/C++17 you can use shortened type trait names.

#include <iostream>
#include <type_traits>

auto main() -> int {
	using A = std::add_rvalue_reference<int>;
    using B = std::add_rvalue_reference<int>;
	
	std::cout << std::boolalpha
	std::cout << "typedefs of int&&:" << "\n";
	std::cout << "A: " << std::is_same<int&&, A>>::value << "\n";
	std::cout << "B: " << std::is_same<int&&, B>>::value << "\n";
}

Binding

lvalue const lvalue rvalue const rvalue
template T&& Yes Yes Yes Yes
T& Yes
const T& Yes Yes Yes Yes
T&& Yes

Note:

  • const T& binds to everything!
  • template T&& represents everything!
    • template <typename T> void foo(T&& a);

Arguments

Parameters

Examples

#include <iostream>

auto print(const std::string& a) -> void{
	std::cout << a << "\n";
}

auto goo() -> std::string const {
	return "C++";
}

auto main() -> int {
	std::string j = "C++";
	std::string const& k = "C++";
	print("C++");     // rvalue
	print(goo());     // rvalue
	print(j);         // lvalue
	print(k);         // const lvalue
}
#include <iostream>

template <typename T>
auto print(T&& a) -> void {
	std::cout << a << "\n";
}

auto goo() -> int const {
	return 5;
}

auto main() -> int {
	int j = 1;
	int const& k = 1;

	print(1);         // rvalue,       foo(int&&)
	print(goo());     // rvalue        foo(const int&&)
	print(j);         // lvalue        foo(int&)
	print(k);         // const lvalue  foo(const int&)
}

demo851-bind1.cpp

demo852-bind2.cpp

Forwarding references

int n;
int& lvalue = n; // Lvalue reference
int&& rvalue = std::move(n); // Rvalue reference

template <typename T> T&& universal = n;  // This is a universal reference.
auto&& universal_auto = n; // This is the same as the above line.
 
template<typename T>
void f(T&& param); // Universal reference

template<typename T>
void f(std::vector<T>&& param);  // Rvalue reference (read the rules carefully).

If a variable or parameter is declared to have type T&& for some deduced type T, that variable or parameter is a forwarding reference (AKA universal reference in some older texts).

For more details on forwarding references, see this blog post

Forwarding functions

Attempt 1: Take in a value

What's wrong with this?

  • What if we pass in a non-copyable type?
  • What happens if we pass in a type that's expensive to copy
template <typename T>
auto wrapper(T value) {
  return fn(value);
}

Forwarding functions

template <typename T>
auto wrapper(T const& value) {
  return fn(value);
}

Attempt 2: Take in a const reference

What's wrong with this?

What happens if we pass in an rvalue?

// Calls fn(x)
// Should call fn(std::move(x))
wrapper(std::move(x));

What happens if wrapper needs to modify value?

Code fails to compile

Forwarding functions

template <typename T>
auto wrapper(T& value) {
  return fn(value);
}

Attempt 3: Take in a mutable reference

What's wrong with this?

What happens if we pass in a const object?

What happens if we pass in an rvalue?

const int n = 1;
wrapper(n);
wrapper(1)

Interlude: Reference collapsing

  • An rvalue reference to an rvalue reference becomes (“collapses into”) an rvalue reference.
  • All other references to references (i.e., all combinations involving an lvalue reference) collapse into an lvalue reference.
  • T& & -> T&
  • T&& & -> T&
  • T& && -> T&
  • T&& && -> T&&

Forwarding functions

template <typename T>
auto wrapper(T&& value) {
  return fn(value);
}

Attempt 4: Forwarding references

What's wrong with this?

// Instantiation generated
template <>
auto wrapper<int&>((int&)&& value) {
  return fn(value);
}

// Collapses to
template <>
auto wrapper<int&>(int& value) {
  return fn(value);
}

int i;
wrapper(i);
// Instantiation generated
auto wrapper<int&&>((int&&)&& value) {
  return fn(value);
}

// Collapses to
auto wrapper<int&&>(int&& value) {
  return fn(value);
}

int i;
wrapper(std::move(i));

Calls fn(i)

Also calls fn(i)

The parameter is an rvalue, but inside the function, value is an lvalue

Forwarding functions

Attempt 4: Forwarding references

We want to generate this

// We want to generate this.
auto wrapper<int&>(int& value) {
  return fn(static_cast<int&>(value));
}
// We want to generate this
auto wrapper<int&&>(int&& value) {
  return fn(static_cast<int&&>(value));
}

It turns out there's a function for this already

template <typename T>
auto wrapper(T&& value) {
  return fn(std::forward<T>(value));
  // Equivelantly (don't do this, forward is easier to read).
  return fn(static_cast<T&&>(value));
}

std::forward and variadic templates

template <typename T, typename... Args>
auto make_unique(Args&&... args) -> std::unique_ptr<T> {
  // Note that the ... is outside the forward call, and not right next to args.
  // This is because we want to call
  // new T(forward(arg1), forward(arg2), ...)
  // and not
  // new T(forward(arg1, arg2, ...))
  return std::unique_ptr(new T(std::forward<Args>(args)...));
}
  • Often you need to call a function you know nothing about
    • It may have any amount of parameters
    • Each parameter may be a different unknown type
    • Each parameter may be an lvalue or rvalue

 

uses of std::forward

The only real use for std::forward is when you want to wrap a function with a parameterized type. This could be because:​

  • You want to do something else before or after
    • std::make_unique / std::make_shared need to wrap it in the unique/shared_ptr variable
    • A benchmarking library might wrap a function call with timers
  • You want to do something slightly different
    • std::vector::emplace uses uninitialised memory construction
  • You want to add an extra parameter (eg. always call a function with the last parameter as 1)
    • This isn't usually very useful, because it can be achieved with std::bind or lambda functions.

COMP6771 20T2 - 8.2 - Advanced Types

By cs6771

Made with Slides.com

COMP6771 20T2 - 8.2 - Advanced Types

  • 734

More from cs6771

  • COMP6771 21T2 - 1.2 - Intro & Types
    cs6771
    503
  • COMP6771 21T2 - 2.1 - C++ Standard Library
    cs6771
    551