Render::Molecule::Molecule(const Render::Molecule& chemistryMolecule) :
    atomsList_(chemistryMolecule.atomsList_),
    bondsList_(chemistryMolecule.bondsList_),
    incidenceMatrix_(chemistryMolecule.incidenceMatrix_),
    charge_(chemistryMolecule.charge_)
{
  for (quint16 i = 0; i < atomsCount(); ++i)
  {
    atomsList_[i].molecule_ = this;
  }
  for (quint16 i = 0; i < bondsCount(); ++i)
  {
    bondsList_[i].molecule_ = this;
  }
}

Render::Molecule& Render::Molecule::operator=(const Render::Molecule& molecule)
{
  if (this != &molecule)
  {
    atomsList_ = QList<Render::Atom>(molecule.atomsList_);
    bondsList_ = QList<Render::Bond>(molecule.bondsList_);
    incidenceMatrix_ = IncidenceMatrix(molecule.incidenceMatrix_);
    charge_ = molecule.charge_;
  }
  for (quint16 i = 0; i < atomsCount(); ++i)
  {
    atomsList_[i].molecule_ = this;
  }
  for (quint16 i = 0; i < bondsCount(); ++i)
  {
    bondsList_[i].molecule_ = this;
  }
  return *this;
}

//
// Стоит проверять index на предмет выхода за пределы списка
//

const Render::Atom& Render::Molecule::atom(quint16 index) const
{
  Q_ASSERT( index < atomsList_.size() );
  return atomsList_.at(index);
}

const Render::Bond& Render::Molecule::bond(quint16 index) const
{
  Q_ASSERT( index < boundsList_.size() );
  return bondsList_.at(index);
}

template <typename key, class base>
class factory
{
public:

    typedef boost::shared_ptr<base> base_ptr;

    template <class derived>
    void reg( const key& name )
    {
        factories[ name ] = base_type_ptr( new derived_type<derived> );
    }

    base_ptr create( const key& name )
    {
        if( !factories.count( name ) )
            throw std::out_of_range( "factory: key not found" );
        return factories[ name ]->create();
    }

private:

    class base_type
    {
    public:

        virtual ~base_type() {}

        virtual base_ptr create() const = 0;
    };

    typedef boost::shared_ptr<base_type> base_type_ptr;

    template <class T>
    class derived_type : public base_type
    {
    public:

        virtual base_ptr create() const
        {
            return base_ptr( new T );
        }
    };

    typedef std::map<key, base_type_ptr> factory_container;
    factory_container factories;
};

// Виртуальный базовый класс
class Loader
{
public:
    virtual    bool load() = 0;
};

// Загружает карту земли
class EarthMapLoader : public Loader
{
public:
    virtual    bool load();
};

// Загружает карту моря
class SeaMapLoader : public Loader
{
public:
    virtual    bool load();
};

void func()
{
    typedef factory<int, Loader> LoaderFactory;
    typedef LoaderFactory::base_ptr LoaderPtr;

    LoaderFactory loaders;

    // Регистрируем загрузчики
    loaders.reg<EarthMapLoader>( 0 );
    loaders.reg<SeaMapLoader>( 1 );

    // Использование 
    int index = 1;        // index тип карты 
    
    // В зависимости от index создаем нужный объект загрузчика
    LoaderPtr loader = loaders.create( index );

    // loader - указывает на объект SeaMapLoader
    // Вызываем метод load
    loader->load();
}

#include <boost/function.hpp>
#include <boost/bind.hpp>
#include <iostream>

class Base
{
public:
    typedef boost::function<bool (int)> SetFunc;
    typedef boost::function<int ()> GetFunc;

    Base() : m_value( 0 ) {}

    bool set( int val )
    {
    std::cout << "set=" << val << std::endl;
    m_value = val;
    return true;
    }

    int get()
    {
    return m_value;
    }

private:
    int    m_value;
};

int main( int, char ** )
{
    Base b;

    Base::SetFunc sf = boost::bind( &Base::set, &b, _1 );
    Base::GetFunc gf = boost::bind( &Base::get, &b );

    std::cout << "get=" << gf() << std::endl;
    sf( 100 );
    std::cout << "get=" << gf() << std::endl;
    
    return 0;
}