С++ идиомы

class ScopeGuard
{
public:
  ScopeGuard () 
   : engaged_ (true) 
  { /* Захват ресурса */ }
  
  ~ScopeGuard ()  
  { 
    if (engaged_) 
     { /* Освобождение ресурса */} 
  }
  void release () 
  { 
     engaged_ = false; 
     /* Ресурс не будет освобожден в деструкторе */ 
  }
private:
  bool engaged_;
};
void some_init_function ()
{
  ScopeGuard guard;
  // В случае возникновения исключения ресурс будет освободжен
  // прим. переводчика: в случае каких-то других ошибок мы можем просто выйти из функции, ресурс также будет освобожден
  guard.release (); // При нормальном завершении ресурс освобождать не нужно
}

T& operator= (const T& that)
{
    if (this == &that)
        return *this;
 
    // handle assignment here
 
    return *this;
}

T& operator= (T that)
{
    // that создан конструктором копий
 
    mem1.swap (that.mem1);
    mem2.swap (that.mem2);
 
    ...
 
    memN.swap (that.memN);
 
    // теперь то, что изначально было  this->mem1, this->mem2, etc. разрушается
    // при разрушении объекта that 
    // новые данные лежат в *this 
 
    return *this;
}

std::vector<int> v;
//v будет обменен с временной копией, которая оптимально использует запас памяти
std::vector<int>(v).swap(v);

std::vector<int> v;
//v будет обменен с временной копией, которая оптимально использует запас памяти
std::vector<int>(v.begin(), v.end()).swap(v);

////////////////////
// File: deleter.hpp
////////////////////
// Объявляем Object, но не определяем его
struct Object;
void delete_object(Object* p);

////////////////////
// File: deleter.cpp
////////////////////
#include "deleter.hpp"
 
// Удаляем объект типа Object, не имея его определения
void delete_object(Object* p) { delete p; }

////////////////////
// File: object.hpp
////////////////////
struct Object
{
  //Этот деструктор не будет вызван при удалении, 
  //если не будет определения типа при вызове delete
  ~Object() {
     // ...
  }
};

////////////////////
// File: main.cpp
////////////////////
#include "deleter.hpp"
#include "object.hpp"
 
int main() {
  Object* p = new Object;
  delete_object(p);
}

template<class T> 
inline void checked_delete(T * x)
{
    typedef char type_must_be_complete[ sizeof(T)? 1: -1 ];
    (void) sizeof(type_must_be_complete);
    delete x;
}
template<class T> 
struct checked_deleter : std::unary_function <T *, void>
{
    void operator()(T * x) const
    {
        boost::checked_delete(x);
    }
};

class Book
{
public:
  void print();
private:
  std::string  m_Contents;
}

class Book
{
public:
  void print();
private:
  std::string  m_Contents;
  std::string  m_Title;
}

/* public.h */
class Book
{
public:
  Book();
  ~Book();
  void print();
private:
  class BookImpl;
  BookImpl* m_p;
}

/* private.h */
#include "public.h"
#include <iostream>
class Book::BookImpl
{
public:
  void print();
private:
  std::string  m_Contents;
  std::string  m_Title;
}

Book::Book()
{
  m_p = new BookImpl();
}
 
Book::~Book()
{
  delete m_p;
}
 
void Book::print()
{
  m_p->print();
}
 
/* функции BookImpl */
 
void Book::BookImpl::print()
{
  std::cout << "print from BookImpl" << std::endl;
}

int main()
{
  Book *b = new Book();
  b->print();
  delete b;
}

class nonaddressable 
{
public:
    typedef double useless_type;
private:
    useless_type operator&() const;
};
 
int main()
{
  nonaddressable na;
  nonaddressable * naptr = &na; // Здесь ошибка компиляции
}

template <class T>
T * addressof(T & v)
{
  return reinterpret_cast<T *>(& const_cast<char&>(reinterpret_cast<const volatile char &>(v)));
}
int main()
{
  nonaddressable na;
  nonaddressable * naptr = addressof(na); // ошибки больше нет
}

// Если бы мы попробовали определить NULL в C++, вот так
#define NULL ((void *)0)
 
// То тогда...
 
char * str = NULL; // Ошибка: Нельзя автоматически привести тип void * к char *
 
void (C::*pmf) () = &C::func;
 
if (pmf == NULL) {} // Ошибка: Нельзя автоматически привести тип void * к типу указателя на функцию-член

#define NULL 0

#define NULL 0L

#include <iostream>
 
#define NULL 0
 
void func(int var) { std::cout << "Int" << std::endl; };
void func(double * ptr) { std::cout << "Double *" << std::endl; };
 
int main()
{
    func(static_cast <double *>(NULL)); // вызывается func(double *), как мы и хотели
 
    func(NULL); // запись интерпретируется, как func(0) - вызывается func(int).
                // но программист, скорее всего, хотел вызвать func(double *),
                // потому что NULL является константой нулевого УКАЗАТЕЛЯ,
                // которую мы определили ранее.
 
    return 0;
}

func(static_cast <double *>(0));
 
func(0);
 
return 0;

const // Объект константный...
class nullptr_t 
{
  public:
    template<class T>
    inline operator T*() const // Может быть приведен к любому типу нулевого указателя (не на член класса)
    { return 0; }
 
    template<class C, class T>
    inline operator T C::*() const   // или любому типу нулевого указателя на член
    { return 0; }
 
  private:
    void operator&() const;  // мы не можем взять адрес nullptr
 
} nullptr = {};

#include <typeinfo>
//#include "nullptr_t"
struct C
{
    void func();
};
 
template<typename T>
void g(T* t) {}
 
template<typename T>
void h(T t) {}
 
void func(double *) {}
void func(int) {}
 
int main(void)
{
    char * ch = nullptr;        // Ок
    func(nullptr);             // Вызывает func(double *)
    func(0);                   // Вызывает func(int)
    void (C::*pmf2)() = 0;      // Ок
    void (C::*pmf)() = nullptr; // Ок
    nullptr_t n1, n2;
    n1 = n2;
    nullptr_t *null = &n1;    // Адрес мы взять не можем
    if (nullptr == ch) {}       // Ок
    if (nullptr == pmf) {}      // Это тоже работает, но не на g++ 4.1.1-4.5 из-за бага #33990
                                // для GCC 4: if ((typeof(pmf))nullptr == pmf) {}
    const int n = 0;
    if (nullptr == n) {}        // Не должно компилироваться, но только Comeau показывает ошибку
 
    int p = 0;
    if (nullptr == p) {}      // Не работает
    g (nullptr);              // Не возможно вывести тип T
 
    int expr = 0;
    char* ch3 = expr ? nullptr : nullptr; // ch3 - нулевой указатель
 
    char* ch4 = expr ? 0 : nullptr;     // ошибка, типы не совместимы
    int n3 = expr ? nullptr : nullptr;  // ошибка, нельзя преобразовать nullptr в int
    int n4 = expr ? 0 : nullptr;        // ошибка, типы не совместимы
 
    h(0);                // Выводит T = int
    h(nullptr);          // Выводит T = nullptr_t
    h((float*) nullptr); // Выводит T = float*
 
    sizeof(nullptr);     // Ок
    typeid(nullptr);     // Ок
    throw nullptr;       // Ок
}

template <class T>
class vector
{
  public:
    vector (const vector<T> &); // конструктор копии
    template <class U>
    vector (const vector<U> &); // конструктор, использующий Coercion by Member Template.
};

template <class T>
class vector
{
  public:
    vector (const list<T> &); 
    // конструктор должен знать интерфейс list<T> (не обязательно std::list)
    vector (const set<T> &); 
    // конструктор должен знать интерфейс set<T> (не обязательно std::set)
    vector (const T * pod_array);
    // а этот конструктор не знает где заканчивается массив pod_array – слишком негибко!
};

template <class T>
class vector
{
    T * mem;
  public:
    template <class InputIterator>
    vector (InputIterator begin, InputIterator end) // конструктор, использующий итераторную пару
    {
      // запрос достаточного количества памяти и сохранение в mem
      mem=new T[std::distance(begin, end)];
      for (int i = 0; begin != end; ++i)
      {
        mem[i] = *begin;
        ++begin;
      }
    }
};
 
int main (void)
{
  std::list<int> l(4);
  std::fill(l.begin(),l.end(), 10);    // заполнение списка с использованием пары итераторов
  std::set<int> s(4);
  std::fill(s.begin(),s.end(), 20);    // заполнение множества с использованием пары итераторов
 
  std::vector<int> v1(l.begin(), l.end());  // создание вектора с использованием пары итераторов
  std::vector<int> v2(s.begin(), s.end());  // создание ещё одного вектора
}

char buf[] = { 'A', 'B', 0, 'C', 0, 'D'};
std::string str1 (buf); // only creates "AB"
std::string str2 (buf, buf + sizeof (buf) / sizeof (*buf)); // Использование итераторной пары. Создаёт "AB_C_D"
// buf – это начало диапазона, а buf + sizeof (buf) / sizeof (*buf) – конец диапазона.
 
std::cout << str1 << " length = " << str1.length() << std::endl; // AB длина = 2
std::cout << str2 << " length = " << str2.length() << std::endl; // AB_C_D длина = 6

class B {};
class D : public B {};
template <class T>
class Helper {};
 
B *bptr;
D *dptr;
bptr = dptr; // OK; разрешено в C++
 
Helper<B> hb;
Helper<D> hd; 
hb = hd; // Не разрешено, но может быть очень полезно

template <class T>
class Ptr
{
  public:
    Ptr () {}
 
    Ptr (Ptr const & p)
      : ptr (p.ptr)
    {
      std::cout << "Copy constructor\n";
    }
 
    // Поддержка приведения типа с использованием шаблонного конструктора.
    // Это не конструктор копирования, но работает аналогично.
    template <class U>
    Ptr (Ptr <U> const & p)
      : ptr (p.ptr) // Требуется неявное преобразование типа из U в T
    {
      std::cout << "Coercing member template constructor\n";
    }
 
    // Копирующий оператор присваивания.
    Ptr & operator = (Ptr const & p)
    {
      ptr = p.ptr;
      std::cout << "Copy assignment operator\n";
      return *this;
    }
 
    // Поддержка приведения типа с использованием шаблонного оператора присваивания.
    // Это не копирующий оператор присваивания, но работает аналогично.
    template <class U>
    Ptr & operator = (Ptr <U> const & p)
    {
      ptr = p.ptr; // Требуется неявное преобразование типа из U в T
      std::cout << "Coercing member template assignment operator\n";
      return *this;
    } 
 
    T *ptr;
};
 
int main (void)
{
   Ptr <D> d_ptr;
   Ptr <B> b_ptr (d_ptr); // Теперь поддерживается
   b_ptr = d_ptr;         // Теперь поддерживается
}

template <class T>
class Array
{
  public:
    Array () {}
    Array (Array const & a)
    {
      std::copy (a.array_, a.array_ + SIZE, array_);
    }
 
    template <class U>
    Array (Array <U *> const & a)
    {
      std::copy (a.array_, a.array_ + SIZE, array_);
    }
 
    template <class U>
    Array & operator = (Array <U *> const & a)
    {
      std::copy (a.array_, a.array_ + SIZE, array_);
    }
 
    enum { SIZE = 10 };
    T array_[SIZE];
};

#include <iostream>
#include <memory>
#include <vector>
 
using namespace std;
 
// Base class has a pure virtual function for cloning
class AbstractShape {
public:
    virtual ~AbstractShape () = default;
    virtual std::unique_ptr<AbstractShape> clone() const = 0;
     virtual double area() const=0;
};
 
// This CRTP class implements clone() for Derived
template <typename Derived>
class Shape : public AbstractShape {
public:
    // This allows obtaining copies of squares, circles or any other shapes by shapePtr->clone()
    std::unique_ptr<AbstractShape> clone() const override {
        return std::make_unique<Derived>(static_cast<Derived const&>(*this));
    }
 
protected:
   // We make clear Shape class needs to be inherited
   Shape() = default;
   Shape(const Shape&) = default;
   Shape(Shape&&) = default;
  
};
 
// Every derived class inherits from CRTP class instead of abstract class
class Square : public Shape<Square>{
    public:
        Square(double a = 1): _a(a) { };     
         virtual double area() const { return _a * _a; };
 
    private:
        double _a;
};
 
class Circle : public Shape<Circle>{
    public:
        Circle(double r = 1): _r(r) { } ;
        virtual double area() const { return _r * _r * 3.14; };
    private:
        double _r;
};
 
class Rectangle : public Shape<Rectangle>{
    public:
        Rectangle(double a = 1, double b=1): _a(a), _b(b)  { };  
         virtual double area() const { return _a * _b; };
 
    private:
        double _a, _b;
};
 
int main(int argc, const char *argv[])
{
    int a=2;
    {
        Shape<Square>* p=new Square(a); 
        Shape<Circle>* pp=new Circle(a);
        Shape<Rectangle>* ppp=new Rectangle(a, 4);
        
        //unique_ptr<AbstractShape>  sh = p->clone();
        //unique_ptr<AbstractShape>  sh2 = pp->clone();
        
       vector<unique_ptr<AbstractShape>>  v;
       v.push_back(p->clone());
       v.push_back(pp->clone());
       v.push_back(ppp->clone());
            
        for(auto&& el : v)  {
            cout << el->area() << '\n'; 
        }
    }
    return 0;
}

        std::unique_ptr<Shape<Square>> p(new Square(a));
        std::unique_ptr<Shape<Circle>> pp(new Circle(a));