跟踪对象类型
跟踪对象类型
提问于 2019-03-14 11:12:02
我试图实现的是跟踪我们创建的从基类继承的对象的类型。如果一个类继承自基类，但没有在对象中实例化，那么我对跟踪它就不太感兴趣了(这个条件可以包含，也可以不包括，这取决于实现是否简单)
虚构的例子：
template <typename T>
class Person
{
public:
Person() {
T* x;
container.push_back(x);
}
virtual ~Person() {}
private:
static heterogeneous_container container;
};
class Employee : public Person <Employee>
{
};
class Employee2 : public Employee
{
};此外，我希望这个工作的链式继承。当我实例化一个Employee2时，基类Person会在容器中添加一个Employee2类型指针吗？
至于异构容器，我认为可以使用链接。
回答 3
Stack Overflow用户
回答已采纳
发布于 2019-03-14 16:22:46
或多或少，我有个地方像这样工作：
#include <iostream>
#include <functional>
#include <vector>
struct ClassEntry {
size_t id = 0;
const char* label;
};
class BaseClass {
public:
protected:
static void RegisterType(size_t id, const char * label) {
ClassEntry entry;
entry.id = id;
entry.label = label;
mRegisteredTypes.emplace_back(entry);
std::cout << "Registered type " << id << " label " << label << std::endl;
}
static size_t createId() {
static size_t id = 0;
return id++;
}
static std::vector<ClassEntry> mRegisteredTypes;
};
std::vector<ClassEntry> BaseClass::mRegisteredTypes;
class OneTimeCall {
public:
OneTimeCall(std::function<void(void)>&& func) {
func();
}
virtual ~OneTimeCall() {
}
};
template<typename T>
class MyClass : public BaseClass {
public:
MyClass() {
static OneTimeCall one_time {
[this]{
BaseClass::RegisterType(GetId(), T::GetType());
}
};
}
private:
protected:
static size_t GetId() {
static size_t id = BaseClass::createId();
return id;
}
};
class A : public MyClass<A> {
public:
A() {
}
static const char *GetType() {
return "ClassA";
}
};
class B : public MyClass<B> {
public:
B() {
}
static const char *GetType() {
return "ClassB";
}
};
int main() {
A a;
B b;
A a2;
B b2;
return 0;
}产出如下：
Registered type 0 label ClassA
Registered type 1 label ClassB其主要思想是在构造中使用CRTP和静态初始化，每种类型只注册一次。它在linux中没有问题，在windows编译器上，静态BaseClass ID在每个DLL上都是新的，所以您需要调优一些以便在外部库中使用。
使用这种方法，您不需要任何外部库，并且可以在没有rtti的情况下编译。
对于继承，可以创建一个新类：
template<typename Current, typename Base>
class Mix : public MyClass<Current>, public Base {};因此，如果将“类型C”作为当前类型(CRTP)和作为基类的类型A传递，则可以工作。
class C : public Mix<C, A> {
public:
C() {
}
static const char *GetType() {
return "ClassC";
}
};使用这种方法，如果您以前注册了"A“，它将不再注册，如果您没有"A”，它将注册在"C“之后。
Stack Overflow用户
发布于 2019-03-14 11:27:21
我觉得你想要的更像是：
class Person
{
public:
Person() {
objects.push_back(this);
}
virtual ~Person() {
objects.erase(this);
}
private:
static std::set<const Person*> objects;
};
class Employee : public Person
{
};
class Employee2 : public Employee
{
};使用这种方法，您可以查询容器中每个指针所指向的派生最多的对象的动态类型。
注意，objects集必须包含指针，而不是每个对象的type_info。问题是，在Employee2对象的Employee2子对象的构造函数中，最派生的*this类型将是Person，而不是Employee2 (在执行进入Employee2构造函数之前，它不会变成Employee2 )。
Stack Overflow用户
发布于 2019-03-14 11:40:41
跟踪对象的一种方法是存储入侵列表，并将链接节点嵌入到对象中。这为跟踪器操作提供了noexcept保证，并且在将元素插入跟踪器容器时不需要额外的内存分配，因为每个跟踪对象中有一个嵌入式列表节点(两个指针)的代价：
#include <iostream>
#include <boost/intrusive/list.hpp>
namespace bi = boost::intrusive;
template<class T>
class Tracker : public bi::list_base_hook<bi::link_mode<bi::auto_unlink>>
{
protected:
static bi::list<Tracker, bi::constant_time_size<false>> objects_;
Tracker() noexcept { objects_.push_back(*this); }
Tracker(Tracker const&) noexcept { objects_.push_back(*this); }
public:
static auto count() noexcept { return objects_.size(); }
};
template<class T>
bi::list<Tracker<T>, bi::constant_time_size<false>> Tracker<T>::objects_;
struct Employee : Tracker<Employee> {};
struct Employee2 : Employee {};
int main() {
std::cout << Tracker<Employee>::count() << '\n';
{
Employee e0;
Employee2 e1;
std::cout << Tracker<Employee>::count() << '\n';
}
std::cout << Tracker<Employee>::count() << '\n';
}产出：
0
2
0没有Boost库的Tracker：
struct AutoListNode {
AutoListNode *next_ = this, *prev_ = this;
AutoListNode() noexcept = default;
AutoListNode(AutoListNode const&) = delete;
AutoListNode& operator=(AutoListNode const&) = delete;
~AutoListNode() noexcept { this->erase(); }
void push_back(AutoListNode* node) noexcept {
auto prev = prev_;
node->prev_ = prev;
node->next_ = this;
prev->next_ = node;
prev_ = node;
}
void erase() noexcept {
auto next = next_;
auto prev = prev_;
prev->next_ = next;
next->prev_ = prev;
}
size_t size() const noexcept {
size_t count = 0;
for(auto node = next_; node != this; node = node->next_)
++count;
return count;
}
};
template<class T>
class Tracker : private AutoListNode
{
protected:
static AutoListNode objects_;
Tracker() noexcept { objects_.push_back(this); }
Tracker(Tracker const&) noexcept { objects_.push_back(this); }
public:
static auto count() noexcept { return objects_.size(); }
};
template<class T>
AutoListNode Tracker<T>::objects_;页面原文内容由Stack Overflow提供。腾讯云小微IT领域专用引擎提供翻译支持
原文链接：
https://stackoverflow.com/questions/55161026
复制相关文章
相似问题
腾讯云开发者
