C++ TALKThe short version! :D

OVERVIEW

You’ll hopefully know the basics, so this talk covers:

► C++ templates

► C++11 cool things

C++ TEMPLATES

► Conceptually similar to Java generics

► More powerful though

C++ TEMPLATE EXAMPLES

C++ TEMPLATE EXAMPLES

C++ TEMPLATE EXAMPLES

C++ TEMPLATE THOUGHTS

► Generated granularly on-demand

► “Granularly” explained in a minnit.

► Can be inlined

► Fast at runtime

This part intentionally left blank.

C++11 COOL THINGS

► Static_assert

► STL threading (with a new memory model!)

► ALL THE RRID

► Lambdas

► Why you shouldn’t use normal arrays

► Move semantics (the important part)

STATIC_ASSERT

STATIC_ASSERT CONTINUED

FIRST OFF, LAMBDAS!

LAMBDAS – CAPTURE GROUP

(‘i’ is read-only in this context. So we can’t do ++i)

LAMBDAS – ARGUMENT/RETURN

THREADING

THREADING – NATIVE_HANDLE()

THREADING – ATOMIC DATA TYPES

► Under <atomic>

► Everything from atomic_float to atomic_uint_fast32_t

RRID STUFFS

► Std::shared_ptr<T>

► Std::unique_ptr<T>

► Std::weak_ptr<T>

► …

STD::SHARED_PTR

STD::UNIQUE_PTR

STD::WEAK_PTR

STD::VECTOR/STD::ARRAY

► (std::vector | std::array) > raw arrays

► Checked STL

► [] guarantees 0 bounds checking with unchecked STL

► Iterator support

► Support for .size()/.max_size()

STD::ARRAY

STD::VECTOR

MOVE SEMANTICS

► Allow for no-fail moving from one variable to another

► Really low overhead

► Can be used in place of copying somewhat often

► I like to move it, move it.

WHAT ARE MOVE SEMANTICS?

► Denoted by && ‘double-ref/ref-ref’

► Basically:

► One variable, A, kills another, b.

► A steals b’s innards

► A places b’s innards in itself

WHY DO WE CARE?

► Example of strings using copy vs move constructors:

► By doing copy = primary, invoke string copy constructor

► Allocate new char[]

► Copy from primary to copy…

► By doing move = primary, invoke string move constructor

► Steal char[] pointer from primary

► “Primary” is no longer useable after this.

WHY DO WE CARE?

► This code used to be bad:

► It would call string::string(const string&) once or twice

► Now it calls string::string(string&&) once or twice

► Now just a maximum of six assignments

► As opposed to 2 allocs, 6 assignments, 2 memcpys

SUMMARY

► Std::thread provides for easy threading

► Templates are extremely flexible

► Also generated on demand

► Lambdas are great for one-off functions

► Use std::unique_ptr and std::shared_ptr in place of raw pointers

► Use std::array/std::vector instead of raw arrays