Brown Bag #2Advanced C++

Topics

Templates

Standard Template Library (STL)

Pointers and Smart Pointers

Exceptions

Lambda Expressions

Tips and Tricks!

Templates

Generic code that works with many data types

Encourages code reuse

Turing-complete

Template metaprogramming (not covered)

Beware scary compiler/linker errors

Function Templates

A family of functions

Uses a generic type

On demand compilation

Compiler can deduce types

Type-safe

int Square(int num){ return num * num;}

template<typename T>T Square(T num){ return num * num;}float result =

Square(5.0f);int result = Square(2);

Class Templates

Explicit type specification

Declaration + implementation in same file

Can template methods not just whole classes

Great for containers

template<class T>class Thing{public: Thing(T data) : m_data(data) {}

T GetData() const { return m_data; }

private: T m_data;};

Thing<int> myThing = Thing<int>(50);int data = myThing.GetData();

class and typename are interchangeable

Standard Template Library (STL)

Containers

vector

list

map

string

Algorithms for_each

find

sort

Iterators auto keyword (not directly relevant, but handy)

vector

Dynamic array

Access item at index = constant time

Iterate over all elements = linear time

for ( auto iter = myVector.begin(); iter != myVector.end(); ++iter ){ iter->foo();}

std::vector<Thing> myVector;

std::vector<Thing>::iterator myVector[0].foo();

for_each#include <algorithm> #include <vector>

using namespace std;

void myFunction (int i) { cout << " " << i; }

int main() { vector<int> myVector; myVector.push_back(10); myVector.push_back(20);

for_each (myVector.begin(), myVector.end(), myFunction); }

string

Special container type – sequence of characters.

Contains useful functions and common STL container functionality.

#include <string>

int main() { std::string test(“Hello World!”); std::cout << “Length of string is “ << test.size() << “.\n”; // 12}

map

Associative container that stores values as a <key, value> pair.

An array uses an integer as the key type.

Each element must have a unique key.

Map containers support iterators that return key and value.#include <map>

using namespace std;

int main() { map<string, int> testMap; testMap.insert(map<string, int>::value_type(“Hello”, 5); int myInt = testMap[“Hello”]; cout << “Value contained in element with key ‘Hello’ is “ << myInt << “.\n”; // 5}

Pointers

Pointers are references to memory blocks which contain data (or an instruction).

We access this data using the reference (&) and dereference (*) operators.

Dereference Operator (*)

If a pointer is a memory address, how do we access the object at that location?

Dereference a pointer to obtain the value at the memory address.

Reference Operator (&)

How do we alter a value at a given memory address and not just a copy?

Use the Reference operator to obtain a variable's memory address.

Pointer to a Pointer

It is possible to have a pointer that points to another pointer.

Pointer to a Pointer

Ever seen a DirectX function where you pass in a reference to a pointer? Check the argument list - that's what is happening there!

Class and Struct Pointers

You can create pointers to struct and class objects using the 'new' keyword:

Lets try setting the value of ack::bar to 5:

Class and Struct Pointers

This is C# syntax - doesn't work in C++!

The -> Operator

Like before, we must dereference the pointer before we can access the object!

There's a nicer way:

The -> operator dereferences a class or struct pointer and gives access to its members.

This is known as "syntactic sugar".

‘delete’ and Null Pointers

When you de-allocate a pointer using the 'delete' keyword, it is common to set the pointer's value to 0:

A pointer whose value is 0 is known as a null pointer.

Smart Pointers

These can be found in the Standard Library as part of the <memory> header file.

There are three types:

unique_ptr

shared_ptr

weak_ptr

Smart Pointer Syntax

Pointers declared using template-style syntax:

* and & operators can be utilised as normal:

Memory is de-allocated at the end:

However, de-allocation does not need to be done manually!

Reference Counting

Smart pointers count the number of references to an object in memory.

When a pointer leaves scope, the reference count is decremented.

When the reference count reaches 0, the memory is de-allocated.

unique_ptr

Allows for only one reference to a stored object - it is unique.

This is an invalid operation. However, ownership can be transferred:

When memory is de-allocated:

shared_ptr

shared_ptrs allow for multiple pointers to reference the same memory address.

weak_ptr

To avoid circular references, we use weak_ptrs:

In order to access the shared_ptr, we use weak_ptr::lock():

When the shared_ptr is deallocated, weak_ptr::lock() will return an empty shared_ptr object:

nullptr

Traditionally, a null pointer is defined as NULL, or 0. Consider the following:

How do we distinguish between 0 and a null pointer?

C++11 introduces the nullptr type:

Now we no longer need to worry about confusing null pointers and int values!

Smart Pointers: Summary

Smart pointers allow for all the same functionality of a standard pointer.

Makes use of Reference Counting for automatic de-allocation.

unique_ptr makes it easier to store single references to objects at a time.

shared_ptr allows for multiple pointers to share memory.

weak_ptr allows for accessing shared_ptr objects with easy clean-up.

nullptr helps to clearly distinguish from numeric values.

Simples!

Exceptions

Handle exceptional runtime errors

Unwinds stack (releases local variables, etc.)

Used by standard library / STL

Standard exceptions (bad_alloc, bad_cast, etc.)

Custom exceptions (extend std::exception)

Exception specifications

try { throw 20; } catch (int e) { cout << “Exception:" << e << endl; }

float foo(char param) throw (int);

Exceptions: The Good

Cleaner than error codes

Much nicer for deeply-nested functions

Separates error-handling from program flow

User-definable to carry detailed information

Catch constructor errors

Resource Acquisition Is Initialization (RAII)

Only destructors are guaranteed to run after an exception is hit

Use destructors to prevent resources leaks

Doesn’t require messy try/catch blocks

void foo(void){ std::unique_ptr<Thing> myThing( new Thing() );  myThing->Something();}

Exceptions: The Bad, The Ugly

Multiple program exit points

Changes program flow, maybe harder to debug

Make debugger break on exceptions in Debug

Potential to leak resources if misused

Use smart pointers, etc. to avoid

Exception-safe code can be hard to write

Don’t throw in destructors

Only throw on exceptional errors

Hard to introduce to existing code

Lambda Expressions

[ ] () mutable throw() –> int { }

Related to the concept of anonymous functions.

Helps to solve the problems of function objects and function pointers.

Function pointer has minimal syntactic overhead but does not retain state.

Function object retains state but requires the overhead of a class definition.

Lambdas feature minimal overhead and can retain state within the scope in which they are defined.

Lambda Expressions: Example

void LambdaExample() { auto myLambda = [](int x, int y) -> int { return (x * 2) + y; };

int a = 3; int b = 4;

int c = myLambda(a, b); std::cout << “The value of c is “ << c << “.\n”; // 10

int d = myLambda(c, b); std::cout << “The value of d is “ << d << “.\n”; // 24}

Lambda Expressions: Syntax

Capture Clause: [ ]

Used to access variables from the scope enclosing the lambda.

Can be passed by reference or value (e.g. &x, y).

Default capture mode can be specified using & or = at the beginning for reference or value captures respectively (e.g. [&, x] or [=, y]).

‘this’ pointer provides access to member variables of the enclosing class (e.g. [this]).

Parameter List: ()

Specifies the parameters passed into the function, as with a regular function declaration.

Mutable Specification: mutable

Allows values captured by reference to be modified within the function.

Will not change the original value, only the local copy.

Lambda Expressions: Syntax (cont.)

Throw Specification: throw()

Specifies if the lambda can throw an exception.

throw() specifies no exception can be thrown.

throw(T) specifies an exception of type T can be thrown.

Return Type: -> T

Follows trailing return-type syntax introduced in C++11.

Explicitly specifies the return value of the function.

Can be implicitly implied via a return statement in the function body.

Function Body: { }

Defines the instructions to be performed, as with a standard function.

Lambda Expressions: Example Revisitedvoid LambdaExample() { auto myLambda = [](int x, int y) -> int { return (x * 2) + y; };

int a = 3; int b = 4;

int c = myLambda(a, b); std::cout << “The value of c is “ << c << “.\n”; // 10

int d = myLambda(c, b); std::cout << “The value of d is “ << d << “.\n”; // 24}

Why use Lambda Expressions? Iterator functions:

#include <vector>#include <algorithm>

int main() { std::vector<int> myVector; myVector.push_back(10); myVector.push_back(20);

int totalCount = 0;

for_each (myVector.begin(), myVector.end(), [&totalCount](int x) { totalCount += x; });

std::cout << “The total of all values in myVector is “ << totalCount << “.\n”; // 30}

Why use Lambda Expressions? Asynchronous tasks:

#include <ppltasks.h>

using namespace Concurrency;

int main() { auto doubleNum = [](int x) { return x * 2; }; auto incrementNum = [](int x) { return ++x; };

auto startTask = create_task([]() -> int { return 5; });

int finalNum = startTask.then(doubleNum).then(incrementNum).then(doubleNum).get(); std::cout << “The value of finalNum is “ << finalNum << “.\n”; // 22}

Tips and Tricks

Const FTW

Prefer pass-by-reference-to-const to pass-by-value (item #20)

Avoid unnecessary constructors/destructor calls

Still guarantee to caller that object won’t be changed

void Foo( const Thing& input );

Thing GetData() const;

const member functions (getters)

Enums FTW

struct MyEnum{ enum Enum { MAX };};

enum class MyEnum { MAX};

Nicer and safer than pre-processor definitions

Enum classes/structs (C++ 11)

Old: Wrap Enums in struct

Now type-safe in C++ 11

Further Reading Microsoft Developers Network (MSDN)

CPlusPlus.com