Здравствуйте, c_beginner, Вы писали:

_>Рассматривал как вариант, но проблемки следующего плана. В any придется хранить ссылку на переменную, скажем, boost::reference_wrapper<T>.

Я невнимательно прочитал задание. Действительно, мороки много будет.

_>Каким образом я могу определить тип, который удерживает boost::any — используя boost::any_cast, для всех возможных типов переменных контейнера, а это — не решение.

Перебирать не обязательно, см. пример ниже. Можно заглянуть в файл «boost/any.hpp» и действовать по аналогии. Кстати, ваша реализация так же хороша, как и в Бусте. Только они дополнительно спрятали классы реализации (вашим классам AbstractProperty и Property<> соответствуют бустовские placeholder и holder<>). Т. е. вы могли бы скрыть от класса VariableContainer абстрактный и шаблонный классы, предоставив самый обычный. При этом улучшилась бы инкапсуляция, но раздулся бы код. Так что ваш вариант всё таки лучше, чем мой:

#include <boost/any.hpp>
#include <boost/lexical_cast.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/ref.hpp>

#include <cassert>
#include <iostream>
#include <string>
#include <hash_map>
#include <utility>

class Property
{
private:
  class Placeholder {
  public:
    virtual void Set(boost::any a, std::string const& value) const = 0;
    virtual ~Placeholder() {}
  };
  template <typename T> class Holder : public Placeholder {
  public:
    void Set(boost::any a, std::string const& value) const {
      T::type& ref( boost::any_cast<T>(a) );
      ref = boost::lexical_cast<T::type>(value);
    }
  };
public:
  Property() : setter_() {}
  template <typename T> Property(T const& value) : setter_(new Holder<T>), a_(value) {}
  void Set(std::string const& value) { if (setter_) { setter_->Set(a_, value); } }
private:
  boost::any a_;
  boost::shared_ptr<Placeholder> setter_;
};

class VariableContainer
{
public:
  template <typename T>
  void Register(std::string const& name, T& var)
  {
    map_.insert( std::make_pair(name, boost::ref(var)) );
  }
  void Set(const std::string &name, const std::string &value)
  {
    map_[name].Set(value);
  }
private:
  stdext::hash_map<std::string, Property> map_;
};

int main()
{
  VariableContainer c;

  int i(0);
  std::string str("");

  c.Register("int", i);
  c.Register("str", str);

  c.Set("int", "12");
  c.Set("str", "hello");

  std::cout << i << std::endl;
  std::cout << str << std::endl;

  assert(i == 12);
  assert(str == "hello");
  
  return 0;
}

_>virtual ~AbstractProperty() = 0 {};

Оказывается, это нестандартно: «A function declaration cannot provide both a pure-specifier and a definition», пункт 10.4.2. Т. е. определение чисто-виртуальной функции должно быть вынесено из объявления класса. Но все компиляторы такой код поддерживают, потому синтаксическому анализатору это вовсе не сложно, так что я тоже изредка забиваю на Стандарт.

Недавно делал онлайн тесты для одной компании...
Собсвтвенно сабж:

/*
   Implement as simple a class as possible to pass the test case below.
   If possible,
   - use only a single container
   - do not use a void pointer
   - use any stl/boost/mpl algorithms that are of use
*/

class VariableContainer
{
public:
    template <class T>
    void Register(const std::string &name, T &var)
    {
    }

public:
    void Set(const std::string &name, const std::string &value)
    {
    }
};

int main()
{
    VariableContainer c;

    int i(0);
    std::string str("");

    c.Register("int", i);
    c.Register("str", str);

    c.Set("int", "12");
    c.Set("str", "hello");

    std::cout << i << std::endl;
    std::cout << str << std::endl;

    assert(i == 12);
    assert(str == "hello");
    return 0;
}

заимплементировал след образом:

struct AbstractProperty
{
    virtual ~AbstractProperty() = 0 {};
    virtual void Set(const std::string &value) = 0;
};

template <typename T>
class Property : public AbstractProperty
{
public:
    Property(T &value) :
      _value(value)
      { }

      /*virtual*/ void Set(const std::string &value)
      {
          _value = boost::lexical_cast<T>(value);
      }

private:
    T &_value;
};

class VariableContainer
{
    typedef boost::shared_ptr<AbstractProperty> PropertyPtr;
    typedef stdext::hash_map<std::string, PropertyPtr> NameToPropertyMap;

public:
    template <class T>
    void Register(const std::string &name, T &var)
    {
        _map[name] = PropertyPtr(new Property<T>(var));
    }

    void Set(const std::string &name, const std::string &value)
    {
        _map[name]->Set(value);
    }
private:
    NameToPropertyMap _map;
};

Хотелось бы видеть более красивое, правильное решение. Покопался в сторону boost::mpl, пока не нашел красивого/работающего решения.

Здравствуйте, c_beginner, Вы писали:

_>Хотелось бы видеть более красивое, правильное решение. Покопался в сторону boost::mpl, пока не нашел красивого/работающего решения.
Хорошо у тебя сделано. А MPL тут ни при чем.

Вот если бы использование выглядело так:

c.set("foo", "42");
int const x = c.get<int>("foo");

можно было бы сделать проще и красивее. А у тебя тип искомой переменной определяется только во время выполнения, поэтому полиморфизм обязателен.

Здравствуйте, c_beginner, Вы писали:

_>Хотелось бы видеть более красивое, правильное решение. Покопался в сторону boost::mpl, пока не нашел красивого/работающего решения.

Возможно, вам подошёл бы map из std::string в boost::any.

_>

_>    std::cout << i << std::endl;
_>    std::cout << str << std::endl;
_>

А это можно было бы сделать, используя StreamableAny.

Здравствуйте, Qbit86, Вы писали:

Q>Здравствуйте, c_beginner, Вы писали:
Q>Возможно, вам подошёл бы map из std::string в boost::any.

Рассматривал как вариант, но проблемки следующего плана. В any придется хранить ссылку на переменную, скажем, boost::reference_wrapper<T>. Каким образом я могу определить тип, который удерживает boost::any — используя boost::any_cast, для всех возможных типов переменных контейнера, а это — не решение.

Здравствуйте, Qbit86, Вы писали:

_>>virtual ~AbstractProperty() = 0 {};

Q>Оказывается, это нестандартно: «A function declaration cannot provide both a pure-specifier and a definition», пункт 10.4.2. Т. е. определение чисто-виртуальной функции должно быть вынесено из объявления класса. Но все компиляторы такой код поддерживают, потому синтаксическому анализатору это вовсе не сложно, так что я тоже изредка забиваю на Стандарт.

А я думал что это очередной загон борланда...

скажите, можно ли доделать сабжевый пример и добавить в него метод Get() ? загвоздка в том, что непонятно, какой возвращаемый тип прописать у данного метода у класса AbstractProperty.