Brown Bag #2
description
Transcript of Brown Bag #2
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