Brown Bag #3Return of the C++

Topics

Common C++ “Gotchas” Polymorphism Best Practices Useful Titbits

Common C++ “Gotchas”

Circular dependencies Slicing Rule of Three

Circular Dependencies

Problem: Two classes that depend on each other Can’t use #include in both headers

// file: A.h

#include “B.h”class A { B _b; };

// file: B.h

#include "A.h”class B { A _a; };

// file: A.h

class B; class A { B& _b; };

// file: B.h

class A;class B { A& _a; };

Solution: Use forward declarations! Use (smart) pointers / references for members Limit includes in headers (helps compilation)

Rule of Three If you define one of these, define all

three: Destructor Copy constructor Assignment operator

MyClass& MyClass::operator= (const MyClass& other){ if (this != &other) { // Do stuff }

return *this;}

Otherwise implicitly generated Latter 2 copy all class members

Copies pointers not objects Want move/swap semantics?

Call base version from derived classes Rule of Two: RAII destructors

Slicing

Problem: Loss of derived class functionality Occurs when derived class copied into base

class Especially when passing by value

void Foo( BaseClass baseParam );

...

DerivedClass myDerived;Foo( myDerived );

Solution: Pass by reference or pointer! Avoid concrete base classes

Polymorphism

‘virtual’ Implicit Override Explicit Override ‘final’ Abstract Classes Interfaces Multiple Inheritance Virtual Class Inheritance

‘virtual’

Used to declare virtual functions. Virtual functions can have functionality overwritten in child classes.class Animal{ virtual int GetNumLegs();};

class Dog : public Animal{ virtual int GetNumLegs();};

class Octopus : public Animal{ virtual int GetNumLegs();};

int Animal::GetNumLegs(){ return 0;}

int Dog::GetNumLegs(){ return 4;}

int Octopus::GetNumLegs(){ return 8;}

Implicit Override

C++ traditionally does not require use of the ‘override’ keyword.

class Parent{ virtual void Foo(int i);};

class Child : public Parent{ virtual void Foo(float i);};

Child::Foo does not override Parent::Foo as they have different signatures.

Compiler will not raise an error over this – this is valid declaration.

Explicit Override

C++11 introduces the ‘override’ keyword to ensure virtual functions are overwritten.

class Parent{ virtual void Foo(int i);};

class Child : public Parent{ virtual void Foo(float i) override;};

If the base class does not contain a virtual function with the same signature, the compiler will throw an error.

Useful to ensure functions are overwritten correctly.

‘final’

C++11 also introduces the ‘final’ keyword. This ensures that a virtual function cannot be overwritten in child

classes.class Parent{ virtual void Foo() final;};

class Child : public Parent{ virtual void Foo() override;};

Attempting to override a virtual function declared as final will cause the compiler to throw an error.

Abstract Classes

An abstract class is one which you cannot instantiate. Contains virtual function(s) which must be overwritten in the child

class. A class is abstract if it contains at least pure virtual function.class Parent{ virtual void Foo() = 0;};

class Child : public Parent{ virtual void Foo();};

Parent parentObject; // ERRORChild childObject; // OK

Interfaces

Similar to an abstract class whose functions are all pure virtual. Defines certain functionality that a class must implement. Implementation of functions is individual to each class.__interface IDancer{ void Dance();};

class Fireman : public IDancer{ virtual void Dance();};

class Butcher : public IDancer{ virtual void Dance();};

Interfaces (cont.)

Objects that implement an interface can be cast to their interface type.

Allows for easy communication between otherwise unrelated object types.

Easier manipulation of objects.std::vector<IDancer> dancers;Fireman fireman;Butcher butcher;

dancers.push_back(fireman);dancers.push_back(butcher);

std::for_each(dancers.begin(), dancers.end(), [](IDancer dancer){ dancer.Dance();});

Multiple Inheritance

Consider the following example:

Animal

Mammal WingedAnimal

Bat

class Animal{ virtual void Eat();};

class Mammal : public Animal{ …};

class WingedAnimal : public Animal{ …};

class Bat : public Mammal, public WingedAnimal{ …};

Multiple Inheritance (cont).

If we call Bat::Eat(), which function do we call?

It is an ambiguous function call. This is because we have two

Animal base classes. Static cast to Animal is also

ambiguous.

Virtual Class Inheritance

We can use the ‘virtual’ keyword when inheriting from a class:class Animal{ virtual void Eat();};

class Mammal : public virtual Animal{ …};

class WingedAnimal : public virtual Animal{ …};

class Bat : public Mammal, public WingedAnimal{ …};

Virtual Class Inheritance (cont.)

The ‘virtual’ keyword will ensure that when a Bat object is created, the Animal instance used by Mammal and WingedAnimal will be the same.

This will remove any ambiguity from calls to Bat::Eat(). Will also allow direct casting of Bat to Animal.

Best Practices

Const WTF Const FTW Preprocessor FTL Enums FTW

Const WTF1. const Thing* a = new Thing();2. Thing const * b = new Thing();3. Thing* const c = new Thing();

4. const Thing* const d = new Thing();

1. Pointer to constant object - Pointer cannot change object

2. Same as 1.3. Constant pointer to object - Pointer itself

cannot change4. All the const -

Neither pointe or pointed can change

Const FTW

Prefer pass-by-reference-to-const to pass-by-value (item #20) Avoids unnecessary constructors/destructor calls Still guarantee to caller that object won’t be changed

void Foo( const Thing& input );void Foo( Thing const & input );

Thing GetData() const;

const member functions (getters)

void Foo( Thing input );void Foo( Thing input );

Preprocessor FTL Avoid #define literals

Not type-safe Not scoped Use initialized constant instead

#define SuperImportant = 42;#define SuperImportant = 42;const int SuperImportant = 42;

Avoid #define pseudo-functions Look like function calls, aren’t Same type/scope problems Use initialized constant instead

#define MAX(a, b) ((a < b) ? b : a);#define MAX(a, b) ((a < b) ? b : a);

inline int MAX(int a, int b){ return (a < b) ? b : a;}

Enums FTW

struct MyEnum{ enum Enum { MAX };};

enum class MyEnum { MAX};

Nicer and safer than preprocessor definitions Enum classes/structs (C++ 11)

Old: Wrap Enums in struct Now type-safe in C++ 11

Useful Titbits

Type Inference Range-Based For Loop Singleton Design Pattern Treat Warnings as Errors Visual Assist X

Type Inference (decltype)

C++11 introduces ‘decltype’ which can be used to infer the type of an object based on the declared value of another.

Useful in conjunction with ‘auto’ when heavy operator overloading and casting is required.

char Foo();int i = 0;

decltype(i) a; // a is an intdecltype(0) b; // b is an intdecltype(Foo()) c; // c is a char

Ranged-Based For Loop

An easier way to iterate through all the elements in a sequence of objects.

Supported by: C-style arrays Initializer lists Types that implement begin() and end() iterators (STL Containers).

int myArray[6] = {1, 2, 3, 4, 5, 6};int arrayTotal = 0;

for (int &i : myArray){ arrayTotal += i;}

std::cout << “The sum of all values is “ << arrayTotal << “.\n”; // 21

Singleton Pattern

Limit to one class instance No public constructors Single static instance Semi-controversial design

pattern Don’t overuse it

class S{public: static S& getInstance() { static S instance; return instance; }

private: S(S const&);

// Don't implement void operator=(S const&);};

Stolen from: http://stackoverflow.com/questions/1008019/c-singleton-design-pattern

Treat Warnings as Errors

Visual Assist X

Intellisense++ Refactoring Improved syntax highlighting Keyboard shortcuts

Jump between header/source £30 for students

Further Reading Microsoft Developers Network (MSDN) CPlusPlus.com