Design patterns C++14

  

gcc 4.9 / clang 3.6: 

MSVC 2015: 

Coverage: 

This is a header-only library with some of the most common design patterns implemmented in C++11/14.

Design guidelines in design-patterns-cpp14

* Can assume variadic templates supported by your compiler.
* Use perfect forwarding and new features from C++11/14 when possible.
* Prefer header only code, but it is not a must.
* Allocations and deallocations of memory are centralized in a allocator selectable by client. (TODO: now allocator is FSBAllocator, and require some change.)

Quality assurance

* Code tested in travis on gcc (4.7, 4.8, 4.9), clang (3.3, 3.4 and 3.6) and Visual Studio (2013).
* Test cases relationated with problems crossing boundaries of dynamic libraries.
* Side dark is optional (no macros, no singletons).

License

design-patterns-cpp14 by Ricardo Marmolejo García is licensed under a Creative Commons Reconocimiento 4.0 Internacional License.

Contributing

The source for design-patterns-cpp14 is held at design-patterns-cpp14 github.com site.

To report an issue, use the design-patterns-cpp14 issue tracker at github.com.

Using design-patterns-cpp14

$3

It's a header-only library. Only need an include.

$3

You will need cmake (and a compiler).
``bash
$ git clone --recursive https://github.com/makiolo/design-patterns-cpp14.git dp14
$ cd dp14
$ ./cmaki/run.sh
`

$3

option 1*: use DEFINE_KEY(classname or anything) within the class
option 2*: use DEFINE_HASH(classname well qualified) outside of class
option 3*: specialization of std::hash. This is equivalent to option 2 but without use macros:
`CPP
namespace std {
template <>
struct hash
{
size_t operator()() const
{
return std::hash()("MyClass");
}
};
}
`

$3

`CPP
#include
#include
#include

class Base
{
public:
using factory = dp14::factory;

explicit Base(const std::string& name, int q)
: _name(name)
, _q(q)
{
std::cout << "constructor " << _name << " - " << _q << std::endl;
}
virtual ~Base() { std::cout << "destruction" << std::endl; }

protected:
std::string _name;
int _q;
};

class A : public Base
{
public:
DEFINE_KEY(A)
explicit A(const std::string& name, int q) : Base(name, q) { ; }
virtual ~A() = default;
};
DEFINE_HASH(A)

// if you dont like macro DEFINE_KEY(class), can use this:
class B : public Base
{
public:
explicit B(const std::string& name, int q) : Base(name, q) { ; }
virtual ~B() = default;
};

namespace std {
template <>
struct hash
{
size_t operator()() const
{
return std::hash()("B");
}
};
}

int main()
{
Base::factory factory;
Base::factory::registrator reg1(factory);
Base::factory::registrator reg2(factory);

{
// equivalent ways of create A
std::shared_ptr a1 = factory.create("first parameter", 2);
std::shared_ptr a2 = factory.create("first parameter", 2);
std::shared_ptr a3 = factory.create("A", "first parameter", 2);

// equivalent ways of create B
std::shared_ptr b1 = factory.create("first parameter", 2);
std::shared_ptr b2 = factory.create("first parameter", 2);
std::shared_ptr b3 = factory.create("B", "first parameter", 2);

assert(a1 != a2);
assert(a3 != b1);
assert(b1 != b2);
}

return(0);
}
`

$3

`CPP
#include
#include
#include
#include

class Base
{
public:
using memoize = dp14::memoize;

explicit Base(const std::string& name, int q)
: _name(name)
, _q(q)
{
std::cout << "constructor " << _name << " - " << _q << std::endl;
}
virtual ~Base() { std::cout << "destruction" << std::endl; }

protected:
std::string _name;
int _q;
};

class A : public Base
{
public:
DEFINE_KEY(A)
explicit A(const std::string& name, int q) : Base(name, q) { ; }
virtual ~A() = default;
};

class B : public Base
{
public:
DEFINE_KEY(B)
explicit B(const std::string& name, int q) : Base(name, q) { ; }
virtual ~B() = default;
};

int main()
{
Base::memoize m;
Base::memoize::registrator reg1(m);
Base::memoize::registrator reg2(m);

{
std::shared_ptr a1 = m.get("first parameter", 2);
assert( m.exists("first parameter", 2) == true );
}
assert( m.exists("first parameter", 2) == false );

{
std::shared_ptr a1 = m.get("first parameter", 2);
std::shared_ptr a2 = m.get("first parameter", 2);
assert(a1 == a2);

std::shared_ptr a3 = m.get("A", "first parameter", 4);
assert(a2 != a3);

std::shared_ptr b1 = m.get("first parameter", 2);
std::shared_ptr b2 = m.get("first parameter", 2);
assert(b1 == b2);

std::shared_ptr b3 = m.get("B", "first parameter", 4);
assert(b2 != b3);

assert( m.exists("first parameter", 2) == true );
}
assert( m.exists("first parameter", 2) == false );

return(0);
}
``