Protected Member Functions
mbed::NonCopyable< T > Class Template Reference

#include <NonCopyable.h>

Protected Member Functions

 NonCopyable ()
 
 ~NonCopyable ()
 

Detailed Description

template<typename T>
class mbed::NonCopyable< T >

Inheriting from this class autogeneration of copy construction and copy assignement operations.

Classes which are not value type should inherit privately from this class to avoid generation of invalid copy constructor or copy assignement operator which can lead to unoticeable programming errors.

As an example consider the following signature:

class Resource;
class Foo {
public:
Foo() : _resource(new Resource()) { }
~Foo() { delete _resource; }
private:
Resource* _resource;
}
Foo get_foo();
Foo foo = get_foo();

There is a bug in this function, it returns a temporary value which will be byte copied into foo then destroyed. Unfortunately, internaly the Foo class manage a pointer to a Resource object. This pointer will be released when the temporary is destroyed and foo will manage a pointer to an already released Resource.

Two issues has to be fixed in the example above:

// return a reference to an already managed Foo instance
Foo& get_foo();
Foo& foo = get_foo();
// create a new Foo instance
Foo* make_foo();
Foo* m = make_foo();
class Foo {
public:
Foo() : _resource(new Resource()) { }
~Foo() { delete _resource; }
private:
// disallow copy operations
Foo(const Foo&);
Foo& operator=(const Foo&);
// data members
Resource* _resource;
}

Another solution is to inherit privately from the NonCopyable class. It reduces the boiler plate needed to avoid copy operations but more importantly it clarifies the programer intent and the object semantic.

class Foo : private NonCopyable<Foo> { public: Foo() : _resource(new Resource()) { } ~Foo() { delete _resource; } private: Resource* _resource; }

Template Parameters
TThe type that should be made non copyable. It prevent cases where the empty base optimization cannot be applied and therefore ensure that the cost of this semantic sugar is null.

As an example, the empty base optimization is prohibited if one of the empty base class is also a base type of the first non static data member:

struct A { };
struct B : A {
int foo;
};
// thanks to empty base optimization, sizeof(B) == sizeof(int)
struct C : A {
B b;
};
// empty base optimization cannot be applied here because A from C and A from
// B shall have a different address. In that case, with the alignement
// sizeof(C) == 2* sizeof(int)

The solution to that problem is to templatize the empty class to makes it unique to the type it is applied to:

template<typename T>
struct A<T> { };
struct B : A<B> {
int foo;
};
struct C : A<C> {
B b;
};
// empty base optimization can be applied B and C does not refer to the same
// kind of A. sizeof(C) == sizeof(B) == sizeof(int).

Constructor & Destructor Documentation

template<typename T>
mbed::NonCopyable< T >::NonCopyable ( )
inlineprotected

Disalow construction of NonCopyable objects from outside of its hierarchy.

template<typename T>
mbed::NonCopyable< T >::~NonCopyable ( )
inlineprotected

Disalow destruction of NonCopyable objects from outside of its hierarchy.


The documentation for this class was generated from the following file: