• я знаю зачем деструкторы бывают виртуальными
  
• я знаю чем отличается delete от delete [] и почему они оба — зло
  
• я знаю что будет, если вызвать виртуальный метод в конструкторе и в деструкторе
  
• я понимаю чем std::vector отличается от std::list
  
• я в жизни хотя бы три раза писал конструктор копирования и оператор присваивания по памяти (и смогу написать еще раз)

• я смогу сам собрать Qt из исходников под определенные требования (и я проверил, что реально смогу, прежде чем поставить галочку)
  
• я могу, не глядя в гугл, сказать как в Qt принято делать undo/redo
  
• я обрабатывал перетаскивание элементов в дереве на Qt
  
• я знаю что делает qobject_cast
  
• я знаю что такое stylesheet

• а еще я умею юнит-тесты (гугловские)
  
• а еще я умею пользоваться git
  
• у меня нет кошки, которая внезапно заболеет и я пропаду на две недели

#include "boost/shared_ptr.hpp"
#include <vector>
#include <iostream>

class A {
public:
  virtual void sing()=0;
protected:
  virtual ~A() {};
};

class B : public A {
public:
  virtual void sing() {
    std::cout << "Do re mi fa so la";
  }
};

boost::shared_ptr<A> createA() {
  boost::shared_ptr<A> p(new B());
  return p;
}

int main() {
  typedef std::vector<boost::shared_ptr<A> > container_type;
  typedef container_type::iterator iterator;

  container_type container;
  for (int i=0;i<10;++i) {
    container.push_back(createA());
  }

  std::cout << "The choir is gathered: \n";
  iterator end=container.end();
  for (iterator it=container.begin();it!=end;++it) {
    (*it)->sing();
  }
}

class A {
public:
  virtual void sing()=0;
};

class B : public A {
public:
  virtual void sing() {
    std::cout << "Do re mi fa so la";
  }

  ~B(){std::cout << "~B()";}
};

boost::shared_ptr<A> createA() {
  boost::shared_ptr<A> p(new B());
  return p;
}

int main() {
  typedef std::vector<boost::shared_ptr<A> > container_type;
  typedef container_type::iterator iterator;

  container_type container;
  for (int i=0;i<10;++i) {
    container.push_back(createA());
  }

  std::cout << "The choir is gathered: \n";
  iterator end=container.end();
  for (iterator it=container.begin();it!=end;++it) {
    (*it)->sing();
  }
}

template<class T> class shared_ptr
{
private:

    // Borland 5.5.1 specific workaround
    typedef shared_ptr<T> this_type;

public:

    typedef T element_type;
    typedef T value_type;
    typedef T * pointer;
    typedef typename boost::detail::shared_ptr_traits<T>::reference reference;

    shared_ptr(): px(0), pn() // never throws in 1.30+
    {
    }

    template<class Y>
    explicit shared_ptr( Y * p ): px( p ), pn( p ) // Y must be complete
    {
        boost::detail::sp_enable_shared_from_this( this, p, p );
    }

S>    template<class Y>
S>    explicit shared_ptr( Y * p ): px( p ), pn( p ) // Y must be complete
S>    {
S>        boost::detail::sp_enable_shared_from_this( this, p, p );
S>    }
S>

template< class X, class Y, class T > inline void sp_enable_shared_from_this( boost::shared_ptr<X> const * ppx, Y const * py, boost::enable_shared_from_this< T > const * pe )
{
    if( pe != 0 )
    {
        pe->_internal_accept_owner( ppx, const_cast< Y* >( py ) );
    }
}

S>>    template<class Y>
S>>    explicit shared_ptr( Y * p ): px( p ), pn( p ) // Y must be complete
S>>    {
S>>        boost::detail::sp_enable_shared_from_this( this, p, p );
S>>    }
S>>

S>template< class X, class Y, class T > inline void sp_enable_shared_from_this( boost::shared_ptr<X> const * ppx, Y const * py, boost::enable_shared_from_this< T > const * pe )
S>{
S>    if( pe != 0 )
S>    {
        pe->>_internal_accept_owner( ppx, const_cast< Y* >( py ) );
S>    }
S>}
S>

public: // actually private, but avoids compiler template friendship issues

    // Note: invoked automatically by shared_ptr; do not call
    template<class X, class Y> void _internal_accept_owner( shared_ptr<X> const * ppx, Y * py ) const
    {
        if( weak_this_.expired() )
        {
            weak_this_ = shared_ptr<T>( *ppx, py );
        }
    }

private:

    mutable weak_ptr<T> weak_this_;
};

weak_this_ = shared_ptr<T>( *ppx, py );

у меня нет кошки, которая внезапно заболеет и я пропаду на две недели