C++11 - A Change in Style - v2.0

Yaser Zhian
Fanafzar Game Studio
IGDI, Workshop 01, August 2nd, 2012

If you write C-style code, you’ll end
up with C-style bugs.
-- Bjarne Stroustrup

If you write Java-style code, you’ll
have Java-level performance.

http://yaserzt.com/ 1

 C++98: First Standard
 C++03: minor changes, mostly the standard
 TR1
 C++11
 Larger and more complex
 Leaner and meaner at the same time


 C++ has no replacement if you want
 total control
 best performance/$
 to take advantage of hardware (multicore, GPU, …)
 to program the way you want
 zero-overhead abstractions


 Mixed-paradigm, statically-typed, compiled,
widespread, many libraries, YDPFWYDU,
works everywhere and with everything.
 No ABI, tooling very complex.
 Libraries don’t work together, complex and
vast, bad teachers, intimidating for beginners,
seems too verbose and low-level.


 “Don’t break people’s code”
 Oriented towards library-developers
 Lower-cost abstractions
 Easier for beginners (a little)
 “If it can go into the Standard Library, do not
put it in the language”


 What is the type of a + b?
 Even if you don’t know, the compiler always does.
 decltype(a + b) c;
 Instead of double c;
 auto instructs the compiler to infer type from
initializing expression, e.g.
 auto foo = a * b + c * d;
 auto bar =
new std::map<std::string, bool>;

 Not always a convenience feature.
 What’s the return type of
template <typename T, typename U>
??? Add (T const & a, U const & b)
{
return a + b;
}
 One answer is decltype(T() + U())
▪ (not entirely correct)
 The correct answer is decltype(a + b)
 But that won’t compile.


 That’s the motivation behind the new
function declaration syntax:
 auto Fun (type1 p1, type2 p2, ...)
-> returntype;
 The previous function then becomes:
 template <typename T, typename U>
auto Add (T const & a, U const & b)
-> decltype(a + b);

 Think of them as unnamed functions, written in the middle of
your code, plus much more.
 [] (int a, int b) -> int {return a + b;}
 Lambdas are far-reaching and far more complicated under
the hood, with many more features.
 auto g =
[] (int a, int b) -> int {return a + b;};
int c = g(43, -1);
 std::function<int (int, int)> h =
[] (int a, int b) -> int {return a + b;};
int d = h(41, 1);


 std::for_each (v.begin(), v.end(),
[](float f) {std::cout << f << std::endl;}
);

 int x = 7;
std::for_each (v.begin(), v.end(),
[x](float & f) {f += x;}
);

 float sum = 0.0f;
std::for_each (v.begin(), v.end(),
[&sum](float f) {sum += f;}
);


class StupidCollection
{
std::vector<int> m_data;
public:
void apply (std::function<int (int)> f)
{
for (auto i = m_data.begin(), e = m_data.end(); i != e; ++i)
*i = f (*i);
}

template <typename Func>
void apply (Func f)
{
for (auto i = m_data.begin(), e = m_data.end(); i != e; ++i)
*i = f (*i);
}
};


 C++ used to have a tendency to copy stuff around if
you weren’t paying attention!
 What happens when we call this function?
 vector<string> GenerateNames ()
{
return
vector<string>(50, string(100, '*'));
}
 A whole lot of useless stuff are created and copied around.
 All sorts of techniques and tricks to avoid those copies.
 Hold that thought for a minute.

 string s = string("Hello") + " " + "world.";
1. string (char const * that)
2. operator + (char const * that)
3. operator + (char const * that)
4. this ultimately called the copy c’tor string (string const &
that).
5. (Unrelated note) Allocations can be avoided with “Expression
Templates”.
 C++11 introduces “rvalue references” to let you work with (kinda)
temporary objects.
 Rvalue references are denoted with &&.
 e.g. int && p = 3;


 In situations where you used to copy the data
from an object into another object, if your first
object is an rvalue (i.e. temporary) now you can
“move” the data from that to this.
 Two important usages of rvalue references are
“move construction” and “move assignment”.
 e.g. string (string && that);// move c'tor
 and string & operator = (string && that);
// move assignment

template <typename T>
class Matrix
{
private:
T * m_data;
unsigned m_rows, m_columns;
public:
Matrix (unsigned rows, unsigned columns);
~Matrix ();
Matrix (Matrix<T> const & that);
template <typename U> Matrix (Matrix<U> const & that);
Matrix<T> & operator = (Matrix<T> const & that);
Matrix (Matrix<T> && that);
Matrix<T> & operator = (Matrix<T> && that);
...
};


class Matrix
{
...
unsigned rows () const;
unsigned columns () const;
unsigned size () const;
T & operator () (unsigned row, unsigned col); // m(5, 7) = 0;
T const & operator () (unsigned row, unsigned col) const;

template <typename U>
auto operator + (Matrix<U> const & rhs) const
-> Matrix<decltype(T() + U())>;

template <typename U>
auto operator * (Matrix<U> const & rhs) const
-> Matrix<decltype(T() * U() + T() * U())>;
};


Matrix (unsigned rows, unsigned columns)
: m_rows (rows), m_columns (columns)
, m_data (new T [rows * columns])
{
}

~Matrix ()
{
delete[] m_data;
}

Matrix (Matrix<T> const & that)
: m_rows (that.m_rows), m_columns (that.m_columns)
, m_data (new T [that.m_rows * that.m_columns])
{
std::copy (
that.m_data, that.m_data + (m_rows * m_columns), m_data
);
}

Matrix<T> & operator = (Matrix<T> const & that)
{
if (this != &that)
{
m_rows = that.m_rows;
m_columns = that.m_columns;
T * new_data = new T [m_rows * m_columns];
std::copy (
that.m_data, that.m_data + (m_rows * m_columns), new_data
);
delete[] m_data;
m_data = new_data;
}
return *this;
}


Matrix (Matrix<T> && that)
: m_rows (that.m_rows), m_columns (that.m_columns)
, m_data (that.m_data)
{
that.m_rows = that.m_columns = 0;
that.m_data = nullptr;
}


Matrix<T> & operator = (Matrix<T> && that)
{
if (this != &that)
{
T * old_data = m_data;
m_rows = that.m_rows;
m_columns = that.m_columns;
m_data = that.data;
that.m_rows = rhs.m_columns = 0;
that.m_data = nullptr;
delete[] old_data;
}
return *this;
}


struct SomeClass
{
string s;
vector<int> v;

// WRONG! WRONG! WRONG!
// Doesn’t move, just copies.
SomeClass (SomeClass && that)
: s (that.s), v (that.v)
{}

SomeClass (SomeClass && that)
: s (std::move(that.s)), v (std::move(that.v))
{}
};


 In principle, std::move should look like this:
??? move (??? something)
{
return something;
}
 What should the argument type be?
 T&& ?
 T& ?
 Both? Neither?
 We need to be able to pass in both lvalues and rvalues.


 We can overload move() like this:
 move (T && something)
 move (T & something)
 But that will lead to exponential explosion of overloads if the
function has more arguments.
 “Reference collapse” rule in C++98:
 int& & is collapsed to int&.
 In C++11, the rules are: (in addition to the above)
 int&& & is collapsed to int&.
 int& && is collapsed to int&.
 int&& && is collapsed to int&&.


 Therefore, only the T&& version should be enough.
 If you pass in an lvalue to our move, the actual argument
type will collapse into T&, which is what we want
(probably.)
 So, move looks like this thus far:
??? move (T && something)
{
return something;
}

 Now, what is the return type?
 T&& ?
 It should be T&& in the end.
 But if we declare it so, and move() is called on an
lvalue,
▪ then T will be SomeType&
▪ then T&& will be SomeType& &&
▪ then it will collapse into SomeType&
▪ then we will be returning an lvalue reference from move(),
which will prevent any moving at all.
 We need a way to remove the & if T already has one.


 We need a mechanism to map one type to another
 In this case, to map T& and T&& to T, and T to T.
 There is no simple way to describe the process, but
this is how it’s done:
 template<typename T> struct RemoveReference
{
typedef T type;
};
 With that, RemoveReference<int>::type will be
equivalent to int.
 But we are not done.

 Now we specialize:
template<typename T>
struct RemoveReference<T&>
{
typedef T type;
};
 template<typename T>
struct RemoveReference<T &&>
{
typedef T type;
};
 Now, RemoveReference<int &>::type will be int too.


 Our move now has the correct signature:
typename RemoveReference<T>::type &&
move (T && something)
{
return something;
}
 But it’s not correct. That “something” in there is
an lvalue, remember?


 …so we cast it to an rvalue reference:
move (T && something)
{
return static_cast<
>
(something);
}
 Hopefully, this is correct now!


 Templates with variable number of arguments
 For example
template <typename... Ts>
size_t log (int severity, char const * msg,
Ts&&... vs);
 Remember the old way?
 size_t log (int severity, char const * msg, ...);
 Using va_list, va_start, va_arg and va_end in <cstdarg>
 Or
 #define LOG_ERROR(msg, ...)
log (SevError, msg, __VA_ARGS__)

 Almost the same for classes:
template <typename... Ts>
class ManyParents
: Ts...
{
ManyParents ()
: Ts ()...
{}
};
 Now these are valid:
ManyParents<A> a;
ManyParents<A, B> b;

 template <typename T, typename... PTs>
T * Create (T * parent, PTs&&... ps)
{
T* ret = new T;
ret->create (parent, ps...);
return ret;
}
 PTs and ps are not types, values, arrays, tuples or
initializer lists.
 They are new “things”.


 Rules of expansion are very interesting:
 Ts... → T1,T2,…,Tn
 Ts&&... → T1&&,…,Tn&&
 A<Ts,U>... → A<T1,U>,…,A<Tn,U>
 A<Ts,Us>... → A<T1,U1>,…,A<Tn,Un>
 f(42, vs...) → f(42,v1,…,vn)
 f(42, vs)... → f(42,v1),…,f(42,vn)
 One more operation you can do:
size_t items = sizeof...(Ts); // or vs

 Let’s implement the sizeof... operator as an example.
template <typename... Ts> struct CountOf;

template <> struct CountOf<>
{
enum { value = 0 };
};

template <typename T, typename... Ts>
struct CountOf
{
enum { value = CountOf<Ts...>::value + 1 };
};
 Use CountOf like this:
size_t items = CountOf<Ts>::value;

#include <future>
string flip (string s) {
reverse (s.begin(), s.end());
return s;
}
int main () {
vector<future<string>> v;
v.push_back (async ([] {return flip( " ,olleH");}));
v.push_back (async ([] {return flip(" weN evarB");}));
v.push_back (async ([] {return flip( "!dlroW");}));
for (auto& i : v)
cout << i.get();
cout << endl;
return 0;
}

 Initializer lists (std::initializer_list<T>)
 static_assert (expr, "message");
 Delegating constructors
 Member initialization in class declaration
 Explicitly overriding inherited methods
 Explicitly using or not using default methods


 Functions, constructors and class members as
constexprs.
 UTF8, UTF16, UTF32 and raw string literals
 User-defined literals
 Libraries for regular expressions, shared
pointers, threads , tuples, atomic operations,
working with the file system,… (mostly from
TR1 and Boost.)


 Wikipedia article on C++11 at
http://en.wikipedia.org/wiki/C%2B%2B11
 Scott Meyers, Herb Sutter and Andrei Alexandrescu –
C++ and Beyond (lectures and presentations)
 Presentations by Bjarne Stroustrup and Stephan T.
Lavavej from Going Native 2012
 Microsoft’s implementation of the C++11 Standard
Library (accompanying VC11 Beta)
 C++11 published standard: ISO/IEC 14882:2011
 A draft (similar to the published standard) is available at
http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3337.pdf


If you have a shotgun, you don’t have to use it to kill mosquitoes.
But it’s a lot of fun!

Contact us at http://fanafzar.com/
And me at y@yaserzt.com

 Hardware is the platform – everything else is
just cruft
 Abstractions are necessary (d’oh!)
 Good abstractions let you express more
 Good abstractions let you declare intent
 Good abstractions can increase performance
 memcpy() vs. std::copy()
 qsort()vs. std::sort()


class thread
{
public:
class id;

thread ();

template <class F, class... Args>
explicit thread (F&& f, Args&&... args);

~thread();
bool joinable() const;
void join();
void detach();

id get_id() const;

static unsigned int hardware_concurrency();
};


namespace this_thread
{
thread::id get_id();
void yield ();
void sleep_until (abs_time);
void sleep_for (rel_time);
}


 enable_if
 Type traits
 Sample std::copy


C++11 - A Change in Style - v2.0

Recommandé

Recommandé

Contenu connexe

Tendances

Tendances (20)

Similaire à C++11 - A Change in Style - v2.0

Similaire à C++11 - A Change in Style - v2.0 (20)

Dernier

Dernier (20)

C++11 - A Change in Style - v2.0