修改基于对象的对象，但返回指向派生类的指针

-1

我有一种可以注册对象的对象注册表。这应该在初始化阶段完成。例如。修改基于对象的对象，但返回指向派生类的指针

class ObjectBase { 
protected: 
    bool active; 

public: 
    void activate() { active = true; } 
}; 

template<typename T> 
class Object : public ObjectBase { 
    T value; 
}; 

class Registry { 
public: 
    template<typename T> 
    static std::shared_ptr<Object<T>> registerObject() { 
     return std::make_shared<Object<T>>(); 
    } 

namespace { 
    std::shared_ptr< Object<int> > myObject = Registry::registerObject<int>(); 
}

现在我想active值设置在初始化（和构造函数的参数是不是一种选择，因为这只是众多一个）。什么是整齐的是，如果我能做到以下几点：

namespace { 
    std::shared_ptr< Object<int> > myObject = Registry::registerObject<int>()->activate(); 
}

但是我没有看到激活方式（）返回Object类型的指针（除非我使它成为一个模板，以及和做一个动态的演员，但这看起来很丑陋），以免共享指针。或者有什么方法？或者，你们有没有建议如何处理这个任务（即注册一些东西并设置一些属性）？

编辑：

定名我Object类可能是不幸的。作为一个实际的例子，将Object看作一个属性（保存一个整数）。显然可能有多个整数属性。和想象“活动”作为一个类似于“应该备份” /“应该用远程进程同步”/...

来源

2014-11-20 BillP

是不是有一个原因，你不能在ObjectBase的构造函数中调用'activate（）'？ – 2014-11-20 20:03:22

因为我目前有4个这样的布尔值更可能来。 – BillP 2014-11-20 20:07:41

如果是这种情况，那么需要更多信息才能正确回答问题。例如，有没有一种情况是你不想在构建对象时激活一个对象？ – 2014-11-20 20:11:23

template<typename T> 
std::shared_ptr< Object<T> > RegisterAndActivate() { 
    std::shared_ptr< Object<T> > p = Registry::registerObject<T>(); 
    p->activate(); 
    return p; 
} 

namespace { 
    std::shared_ptr< Object<int> > myObject = RegisterAndActivate<int>(); 
}

来源

2014-11-20 20:02:21

这种方法的问题是，目前有4个这样的布尔值有更多的未来。有一个特定的寄存器函数为每一个他们（和每个组合）是我真的想避免的:-) – BillP 2014-11-20 20:08:33

有一个寄存器函数采用四个布尔变量作为参数（或一个位集，或任何你想要的结构用来表示对象的期望状态）。 – 2014-11-20 20:09:38

当我有20个变量？这不会缩放。 – BillP 2014-11-20 20:10:40

关于独立功能（S）什么：

template <typename T> 
std::shared_ptr<Object<T>> activate(std::shared_ptr<Object<T>> ptr) { 
    ptr->activate(); 
    return ptr; 
}

然后

auto x = activate(Registry::registerObject<int>());

来源

2014-11-20 20:20:40

如果其他风格不可行，这可能是一个选项，是的。 – BillP 2014-11-20 21:08:27

@BillP有了你可能会变得复杂，让registerObject返回一个代理转换为'std :: shared_ptr >'，适用于一些逗号运算符（激活，停用，...） - 也许你的设计是可疑的！ – 2014-11-20 21:23:41

好了，这里就是我想出了：

#include <iostream> 
#include <tuple> 
#include <memory> 


struct Test { 
    bool a; 
    bool b; 
    Test() : a(false),b(false) {}; 
}; 


template<typename T, bool T::* ... props> 
std::shared_ptr<T> activate(std::shared_ptr<T> inst) { 
    std::tie((inst.get()->*props)...) = std::make_tuple((props,true)...); 
    return inst; 
} 

int main() 
{ 
    auto t1 = activate<Test,&Test::a>(std::make_shared<Test>()); 
    auto t2 = activate<Test,&Test::a,&Test::b>(std::make_shared<Test>()); 
    std::cout << "t1: a = " << t1->a << ", b = " << t1->b << std::endl; 
    std::cout << "t2: a = " << t2->a << ", b = " << t2->b << std::endl; 
}

基本上，无论您指定为模板参数的bool成员的指针如何，这些函数都将通过activate函数设置为true。这样，您不必编写许多激活函数，但由于所有的表达式都是大量写入的。工作示例here。

来源

2014-11-20 20:33:07 Oguk

修改基于对象的对象，但返回指向派生类的指针

回答

相关问题