2

我正在尝试声明许多Derived<T>继承自 的模板化对象Base，并将它们推回std::vector<Base*>.

struct Base { ... };
template<typename T> struct Derived : Base { /* ctor(const string&) */ ... }

Derived<bool> online{"online"};
Derived<bool> official{"official"};
Derived<bool> noRotation{"no_rotation"};
Derived<bool> noBackground{"no_background"};
Derived<int> noSound{"no_sound"};
Derived<string> noMusic{"no_music"};
Derived<bool> blackAndWhite{"black_and_white"};

vector<Base*> configValues{&online, 
                           &official, 
                           &noRotation, 
                           &noBackground, 
                           &noSound, 
                           &noMusic, 
                           &blackAndWhite};

如您所见，代码很糟糕。有没有办法在不将vectoras a传递const&给Derived<T>::Derived<T>(...)构造函数的情况下自动执行此操作？

通过自动化，我的意思是避免对象名称的重复。我想std::vector用我所有的Derived<T>对象填充 a 而不必手动列出它们。

（宏已接受，但希望有更好的解决方案）

4

4 回答 4

1

因此，生命周期将是您面临的问题之一，而在您的程序中如何使用这种模式是对解决方案的另一个影响。

因此，假设您的 Derived<> 实例不属于向量，那么您需要确保它们的寿命更长。有三种基本方法，在某些情况下可以组合使用。

第一个：创建一个存储和填充向量的类。如果您复制了相同的一组 Derived<> 类型或参数，这至少可以“删除”您的常见结构。然后你可以给这些成员函数返回或填充向量。

第二种是使用std::tuple。如果有许多参数列表变体并且您希望一个实例存储所有这些 Derived 实例，同时有一种方法可以创建通用例程（例如填充向量），则元组可能很有用：

typedef std::tuple<
    Derived<bool>,
    Derived<bool>,
    Derived<bool>,
    Derived<bool>,
    Derived<bool>,
    Derived<int>,
    Derived<std::string>,
    Derived<bool>
> atuple;

atuple t{
    "online",
    "official",
    "no_rotation",
    "no_background",
    "no_sound",
    "no_music",
    "black_and_white"
};
const size_t size(std::tuple_size<atuple>::value);
/* or you could use std::array because the size is constant. */
std::vector<Base*>configValues;
configValues.reserve(size);
push(t,configValues);

push()看起来像：

template<std::size_t I = 0, typename V, typename... Tp>
inline typename std::enable_if<I == sizeof...(Tp), void>::type
push(std::tuple<Tp...>& t, V&)
{ }

template<std::size_t I = 0, typename V, typename... Tp>
inline typename std::enable_if<I < sizeof...(Tp), void>::type
push(std::tuple<Tp...>& t, V& vec)
{
 vec.push_back(&std::get<I>(t));
 push<I + 1, V, Tp...>(t, vec);
}

（借自迭代元组）。

如果您在程序的多个部分都没有遇到这个问题，那么这些解决方案对您来说不会那么有用。

第三个 - 使用数组：

 std::array<Derived<bool>,5> a{{{"online"},{"official"},{"no_rotation"},{"no_background"},{"black_and_white"}}};
 Derived<int> noSound{"no_sound"};
 Derived<string> noMusic{"no_music"};
 vector<Base*> configValues{&noSound,&noMusic};
 for (Derived<bool>& b:a) configValues.push_back(&b); // original order not retained
于 2013-06-22T23:19:38.090 回答
1

这里似乎有两个不同的问题......

第一个问题似乎是您不想将常量传递std::string给Derived<T>. Derived<T>我能想到这样做的唯一原因是在构造对象时是否需要修改字符串。如果您不需要修改字符串，我建议const您像当前所做的那样通过引用来获取它。

如果您确实需要在构造函数中修改字符串，您可以更改参数以通过右值引用或按值传递字符串。

Derived(std::string&& str) { /*...*/ } // Pass by r-value reference
Derived(std::string str) { /*...*/ }   // Pass by value

两者都允许您在构建过程中修改字符串。

至于你评论中的第二个问题......

要以评论中描述的方式填充向量，您可以使用统一初始化。唯一需要注意的是，您需要为添加到向量中的对象使用动态存储持续时间。

std::vector<Base*> configValues{
    {
    new Derived<bool>{"online"},
    new Derived<bool>{"official"},
    new Derived<bool>{"no_rotation"},
    new Derived<bool>{"no_background"},
    new Derived<int>{"no_sound"},
    new Derived<std::string>{"no_music"},
    new Derived<bool>{"black_and_white"}
    }
};

我不确定您的目标是什么，因此您决定如何管理这些对象的生命周期取决于您。我强烈建议使用智能指针来管理它们的生命周期和所有权。例如，如果您需要共享所有权，您可以std::shared_ptr像以下示例中那样使用。

std::vector<std::shared_ptr<Base>> configValues{
    {
    std::shared_ptr<Base>(new Derived<bool>{"online"}),
    std::shared_ptr<Base>(new Derived<bool>{"official"}),
    std::shared_ptr<Base>(new Derived<bool>{"no_rotation"}),
    std::shared_ptr<Base>(new Derived<bool>{"no_background"}),
    std::shared_ptr<Base>(new Derived<int>{"no_sound"}),
    std::shared_ptr<Base>(new Derived<std::string>{"no_music"}),
    std::shared_ptr<Base>(new Derived<bool>{"black_and_white"})
    }
};

由于std::initializer_list要求对象是可复制的，因此您不能使用它std::unique_ptr来管理对象的生命周期。

于 2013-06-22T22:41:47.933 回答
1

听起来您正在寻求一种工厂模式类型的实现，其中container所有派生对象都被添加到其中。

这是一个帮助您入门的工作示例（ideone）：

#include <string>
#include <vector>
#include <memory>
#include <algorithm>
#include <iostream>

struct Base
{
    typedef std::shared_ptr<Base> SharedPtr;
    virtual ~Base(){}
    virtual void print(){}
    template<class T>
    static SharedPtr makeDerived(const std::string& name);

    static std::vector<SharedPtr> objs;
};
std::vector<Base::SharedPtr> Base::objs;
template<class T>
struct Derived : public Base
{
    Derived(const std::string& name):name(name){}
    void print(){std::cout<<name<<std::endl;}
    std::string name;
};

template<class T>
Base::SharedPtr Base::makeDerived(const std::string& name)
{
    SharedPtr p = std::make_shared<Derived<T> >(Derived<T>(name));
    objs.push_back(p);
    return p;
}

int main()
{
    Base::makeDerived<bool>("online");
    Base::makeDerived<int>("users");
    std::for_each(Base::objs.begin(),Base::objs.end(),
                  [](Base::SharedPtr p){p->print();}   );
}

shared_ptr应该有助于内存管理。您可以使用静态容器或制作一个对象来容纳所有容器，这没什么大不了的。

于 2013-06-23T01:56:13.567 回答
0

谢谢大家的回答，都投了赞成票。最后，我决定创建一个处理所有权和创建的“助手”类。

从我的 GitHub SSVUtilsJson 存储库中：

class Manager
{
    private:
        ssvu::MemoryManager<Base> memoryManager; 
        // MemoryManager internally has a vector<Base*> of owned pointers

    public:
        template<typename T> Derived<T>& create() { return memoryManager.create<Derived<T>>(); }
        // MemoryManager::create<T> creates and stores a 'new T*' and returns a reference to it
};

用法（来自我的 GitHub SSVOpenHexagon repo）

Manager lvm;

auto& online                    (lvm.create<bool>());
auto& official                  (lvm.create<string>());
auto& noRotation                (lvm.create<int>());
auto& noBackground              (lvm.create<double>());
auto& noSound                   (lvm.create<char>());
auto& noMusic                   (lvm.create<void>());

for(Base* b : lvm.getItems()) { /* do something */ }
于 2013-06-24T14:02:24.663 回答