Question

我想要实现的目标：我想要一个类来保存我的程序的配置，类似于boost :: options，但是无升级。它应该像这样使用：

auto port = Config.Get<int>(Options::Port);
Config.Set<Options::Port>(12345);

为了保持确切的值，我在Any类中使用了类型擦除模式（它是一个模式吗？）（是的，像boost :: variant / any，但是boostless）。所以我的课程看起来像这样：

#include <memory>
#include <map>
#include <mutex>

enum class Options {
  kListenPort = 0,
  kUdsPath,
  kConfigFile,
};

class AnyData;
class AnyDataBase;
class Any {
 public:
  template <typename T> Any(const T& any) : data_{any} {}
  Any(const Any& any) : data_{std::make_unique<AnyDataBase>(any.data_.get())} {}; // THIS IS WHERE I GOT DESPERATE
  ~Any(){}
  template <typename T> inline const T& As() const {
    if (typeid(T) != data_->type_info()){
      throw std::runtime_error("Type mismatch.");
    }else{
      return static_cast<std::unique_ptr<AnyData<T>>>(data_)->data_;
    }
  }

 private:
  struct AnyDataBase {
    virtual ~AnyDataBase(){}
    virtual const std::type_info& type_info() const = 0;
  };

  template <typename T> struct AnyData : public AnyDataBase {
    AnyData(const T& any_data) : data_{any_data} {}
    const inline std::type_info& type_info() const {
      return typeid(T);
    }
    T data_;
  };

  std::unique_ptr<AnyDataBase> data_;
};

class Option {
 private:
  Option(Any& value) : value_{value} {}
  Option() = delete; // we want the user to provide default value.
  ~Option(){};
  template <typename T> inline const T& Get() const {
    return value_.As<T>();
  }

 private:
  bool is_mandatory_;
  bool is_cmdline_;
  //TODO: add notifier
  Any value_;
};

using OptionsPair = std::pair<Options, std::shared_ptr<Option>>;
using OptionsData = std::map<Options, std::shared_ptr<Option>>;

class IConfig {
 public:
  virtual void Load(const std::string& filename) = 0;
};

class Config : public IConfig {
 public:
  Config(int argc, char** argv);
  ~Config() {};
  void Load(const std::string& filename);
  template <Options O> void Set(const Any& value);
  template <typename T> const T& Get(Options option);

 private:
  std::unique_ptr<OptionsData> data_;
  mutable std::mutex mutex_;
};

当我像那样使用它时......

template <Options O> void Config::Set(const Any& value) {
  std::lock_guard<std::mutex> lock(mutex_);

  if (data_->find(O) == data_->end()) {
    data_->insert(std::pair<Options, std::shared_ptr<Option>>(O, value));
    // TODO: i don't get in why it doesn't work this way:
    data_->insert(OptionsData {O, std::make_shared<Option>(value)});
  } else {
    data_->at(O) = std::make_shared<Option>(value);
  }
}

...我需要Any类来拥有一个复制构造函数（我希望有人能说明我可以避免这种情况）。

而且，正如您从复制构造函数的评论中可以看到的，我不知道如何制作它，因为它不是模板化的。我不知道如何在不知道值的类型的情况下创建新的unique_ptr，这在源unique_ptr中有帮助，我想从中复制值。

错误是：

In file included from /usr/lib/gcc/x86_64-pc-linux-gnu/4.9.3/include/g++-v4/memory:81:0,
                 from Config.h:5,
                 from Config.cpp:2:
/usr/lib/gcc/x86_64-pc-linux-gnu/4.9.3/include/g++-v4/bits/unique_ptr.h: In instantiation of ‘typename std::_MakeUniq<_Tp>::__single_object std::make_unique(_Args&& ...) [with _Tp = Any::AnyDataBase; _Args = {Any::AnyDataBase*}; typename std::_MakeUniq<_Tp>::__single_object = std::unique_ptr<Any::AnyDataBase>]’:
Config.h:23:76:   required from here
/usr/lib/gcc/x86_64-pc-linux-gnu/4.9.3/include/g++-v4/bits/unique_ptr.h:765:69: error: invalid new-expression of abstract class type ‘Any::AnyDataBase’
     { return unique_ptr<_Tp>(new _Tp(std::forward<_Args>(__args)...)); }
                                                                     ^
In file included from Config.cpp:2:0:
Config.h:36:10: note:   because the following virtual functions are pure within ‘Any::AnyDataBase’:
   struct AnyDataBase {
          ^
Config.h:38:35: note:   virtual const std::type_info& Any::AnyDataBase::type_info() const
     virtual const std::type_info& type_info() const = 0;

更新以防任何人发现这个主题有趣或有用。如果我做对了，就不能简单地投出一个像这样的unique_ptr：

static_cast<std::unique_ptr<AnyData<T>>>(data_)->data_;

到目前为止我发现的最明确的解决方案 https://stackoverflow.com/a/21174979/2598608 结果代码如下：

return static_unique_ptr_cast<AnyData<T>, AnyDataBase>(std::move(data_))->data_;

你必须使unique_ptr成员可变或从Get（）方法中删除const限定符，因为static_unique_cast＆lt;＆gt;（）从源unique_ptr中提取原始删除器，因此修改它。

Answer 1

基本上Any类需要知道如何创建已擦除类型AnyDataBase的深层副本。由于AnyDataBase是抽象的，因此它无法真正实现。它需要AnyDataBase的帮助才能做到这一点。

一种技术是在AnyDataBase中实现“克隆”方法。此功能可以使用各种签名，但由于您已经在使用std::unique，因此最简单的方法是继续使用它，如下所示;

std::unique_ptr<AnyDataBase> clone() const;

Any类中的示例实现;

class Any {
 public:
  template <typename T> Any(const T& any) : data_{std::make_unique<AnyData<T>>(any)} {}
  Any(const Any& any) : data_{any.data_->clone()} {}; // use the clone
  ~Any(){}
  template <typename T> inline const T& As() const {
    if (typeid(T) != data_->type_info()){
      throw std::runtime_error("Type mismatch.");
    }else{
      return static_cast<std::unique_ptr<AnyData<T>>>(data_)->data_;
    }
  }
 private:
  struct AnyDataBase {
    virtual ~AnyDataBase(){}
    virtual std::unique_ptr<AnyDataBase> clone() const = 0; // clone already as std::unique
    virtual const std::type_info& type_info() const = 0;
  };
  template <typename T> struct AnyData : public AnyDataBase {
    AnyData(const T& any_data) : data_{any_data} {}
    std::unique_ptr<AnyDataBase> clone() const override { return std::make_unique<AnyData<T>>(data_); }
    const inline std::type_info& type_info() const override { return typeid(T); }
    T data_;
  };
  std::unique_ptr<AnyDataBase> data_;
};

尝试复制Any课程时，会依次调用clone()上的AnyDataBase，然后AnyData创建data_的完整副本成员（类型为T）并返回所需的std::unique。

Here is a sample of it

注意：std::unique_ptr<AnyDataBase> clone() const override { return std::make_unique<AnyData<T>>(data_); }按预期工作，由于an available constructor allowing the implicit conversion of the unique_ptr<>::pointer types而构建的unique_ptr<AnyData<T>>转换为返回类型unique_ptr<AnyDataBase>。

此技术也称为virtual constructors，通常依赖于covariant return types;虽然上面的例子中没有使用协方差。可以轻松更改代码以使用std::unique上的协变返回。

有关此问题的详细讨论，请参阅this answer和this one。

如何为具有类型擦除数据成员的类实现复制构造函数？

1 个答案: