获取此对象的原始类型 [英] getting original type of this object
问题描述
我正在尝试使用元编程来防止父子结构中的重复代码.我的工作到了一定程度.
I'm trying to use metaprogramming to prevent duplicate code in a parent-child structure. I got it working up to a certain point.
在底部的编译器中显示的代码可以正确运行,但是注释了某些关系(/*Tree_tag,*/
和/*Parasite_tag*/
).如果未注释,则MSVS2017将显示
The code shown at the bottom compilers and runt correctly, but some relations (/*Tree_tag,*/
and /*Parasite_tag*/
) are commented out. If uncommented, MSVS2017 shows
error C2664: 'void Obj<std::tuple<Human_tag>,std::tuple<>>::removeParent(const Obj<std::tuple<>,std::tuple<Tree_tag,Dog_tag>> *const )': cannot convert argument 1 from 'Obj<std::tuple<>,std::tuple<Dog_tag>> *' to 'const Obj<std::tuple<>,std::tuple<Tree_tag,Dog_tag>> *const '
note: Types pointed to are unrelated; conversion requires reinterpret_cast, C-style cast or function-style cast
和G ++展示
In instantiation of ‘void Obj<std::tuple<>, std::tuple<_El0, _El ...> ::removeAllChildren() [with TChildTag = Dog_tag; TChildTags = {}]’:
Main.cpp:126:1: required from here
Main.cpp:73:43: error: invalid conversion from ‘Obj<std::tuple<>, std::tuple<Dog_tag> >*’ to ‘const TParent* {aka const Obj<std::tuple<>, std::tuple<Tree_tag, Dog_tag> >*}’ [-fpermissive]
for (auto&& child : childrenPtrs) child->removeParent(this);
问题出在this
类型限定符上.因为我反复使用例如剥离模板参数
The problem is with the this
type qualifiers. Because I iteratively strip off template arguments with for instance
class Obj<std::tuple<>, std::tuple<TChildTag, TChildTags...>>
: public Obj<std::tuple<>, std::tuple<TChildTags...>>
所得的基本类型this
与原始类型不匹配.如错误所示:Human
= Obj<std::tuple<>,std::tuple<Tree_tag,Dog_tag>>
的原始类型.但是,由于迭代剥离,基础中this
的类型为Obj<std::tuple<>,std::tuple<Dog_tag>>
.
the resulting this
of the base type does not match the original type. Like the error shows: the original type of Human
= Obj<std::tuple<>,std::tuple<Tree_tag,Dog_tag>>
. However, due to the iterative stripping, the type of this
in the base is Obj<std::tuple<>,std::tuple<Dog_tag>>
.
我尝试按照建议使用reinterpret_cast
:
template<typename T>
void addParent(T* const parentPtr) {
parentsPtrs.push_back(reinterpret_cast<TParent* const>(parentPtr));
}
template<typename T>
void removeParent(T const* const parentPtr) {
auto it = std::find(std::cbegin(parentsPtrs), std::cend(parentsPtrs),
reinterpret_cast<TParent const* const>(parentPtr));
if (it != std::cend(parentsPtrs)) parentsPtrs.erase(it);
}
但是接下来的问题是,所有内容都被强制转换为允许的参数. IE.该代码有效:
But then the problem is that everything is cast to an allowed parameter. I.e. this code works:
int main() {
Human h1;
Parasite p1;
addRelation(&h1, &p1);
}
...这不可能,因为Human
和Parasite
并不直接相关.
...Which should not be possible, as Human
and Parasite
are not related directly.
那么我如何正确地保留顶级(大多数派生类)的this
类型限定符,使其符合Human
,Dog
等类型?
So how can I correctly keep the this
type qualifiers of the top (most derivative) class, complying to Human
, Dog
, etc types?
工作代码(带注释):
#include <tuple>
#include <vector>
template<class T>
using prtVector = std::vector<T*>;
class BaseObject {
public:
virtual prtVector<BaseObject> getAllParents() const = 0;
virtual prtVector<BaseObject> getAllChildren() const = 0;
virtual void removeAllParents() = 0;
virtual void removeAllChildren() = 0;
};
template<typename TParentTuple, typename TChilderenTuple>
class Obj;
template<typename TParentTag, typename... TParentTags, typename... TChildTags>
class Obj<std::tuple<TParentTag, TParentTags...>, std::tuple<TChildTags...>>
: public Obj<std::tuple<TParentTags...>, std::tuple<TChildTags...>>
{
using TParent = typename TParentTag::obj_type;
prtVector<TParent> parentsPtrs;
public:
void addParent(TParent* const parentPtr) { parentsPtrs.push_back(parentPtr); }
void removeParent(TParent const* const parentPtr) {
auto it = std::find(std::cbegin(parentsPtrs), std::cend(parentsPtrs), parentPtr);
if (it != std::cend(parentsPtrs)) parentsPtrs.erase(it);
}
virtual prtVector<BaseObject> getAllParents() const override {
auto result = Obj<std::tuple<TParentTags...>, std::tuple<TChildTags...>>::getAllParents();
result.insert(std::begin(result), std::cbegin(parentsPtrs), std::cend(parentsPtrs));
return result;
}
virtual prtVector<BaseObject> getAllChildren() const override {
return Obj<std::tuple<TParentTags...>, std::tuple<TChildTags...>>::getAllChildren();
}
virtual void removeAllParents() override {
Obj<std::tuple<TParentTags...>, std::tuple<TChildTags...>>::removeAllParents();
for (auto&& parent : parentsPtrs) parent->removeChild(this);
}
virtual void removeAllChildren() override {
Obj<std::tuple<TParentTags...>, std::tuple<TChildTags...>>::removeAllChildren();
}
};
template<typename TChildTag, typename... TChildTags>
class Obj<std::tuple<>, std::tuple<TChildTag, TChildTags...>>
: public Obj<std::tuple<>, std::tuple<TChildTags...>>
{
using TChild = typename TChildTag::obj_type;
prtVector<TChild> childrenPtrs;
public:
void addChild(TChild* const childPtr) { childrenPtrs.push_back(childPtr); }
void removeChild(TChild const* const childPtr) {
auto it = std::find(std::cbegin(childrenPtrs), std::cend(childrenPtrs), childPtr);
if (it != std::cend(childrenPtrs)) childrenPtrs.erase(it);
}
virtual prtVector<BaseObject> getAllParents() const override {
return Obj<std::tuple<>, std::tuple<TChildTags...>>::getAllChildren();
}
virtual prtVector<BaseObject> getAllChildren() const override {
auto result = Obj<std::tuple<>, std::tuple<TChildTags...>>::getAllChildren();
result.insert(std::begin(result), std::cbegin(childrenPtrs), std::cend(childrenPtrs));
return result;
}
virtual void removeAllParents() override {}
virtual void removeAllChildren() override {
Obj<std::tuple<>, std::tuple<TChildTags...>>::removeAllChildren();
for (auto&& child : childrenPtrs) child->removeParent(this);
}
};
template<>
class Obj<std::tuple<>, std::tuple<>> : public BaseObject {
public:
virtual prtVector<BaseObject> getAllParents() const override {
return prtVector<BaseObject>();
}
virtual prtVector<BaseObject> getAllChildren() const override {
return prtVector<BaseObject>();
}
virtual void removeAllParents() override {}
virtual void removeAllChildren() override {}
};
struct Human_tag;
struct Tree_tag;
struct Dog_tag;
struct Parasite_tag;
using Human = Obj<std::tuple<>, std::tuple</*Tree_tag,*/ Dog_tag>>;
using Tree = Obj<std::tuple<Human_tag>, std::tuple<>>;
using Dog = Obj<std::tuple<Human_tag>, std::tuple</*Parasite_tag*/>>;
using Parasite = Obj<std::tuple<Dog_tag>, std::tuple<>>;
struct Human_tag { using obj_type = Human; };
struct Tree_tag { using obj_type = Tree; };
struct Dog_tag { using obj_type = Dog; };
struct Parasite_tag { using obj_type = Parasite; };
template<class A, class B>
void addRelation(A* a, B* b)
{
a->addChild(b);
b->addParent(a);
}
#include <iostream>
int main() {
Human h1;
Dog d1, d2;
addRelation(&h1, &d1);
addRelation(&h1, &d2);
auto result = h1.getAllChildren();
std::cout << result.size() << "\n"; //print 2
d1.removeAllParents();
result = h1.getAllChildren();
std::cout << result.size() << "\n"; //print 1
std::cin.ignore();
}
推荐答案
使用C ++ 17,您可以(无需强制转换)进行操作:
With C++17, you may do (without cast):
template<typename TParentTuple, typename TChilderenTuple>
class Obj;
template<typename... ParentTags,
typename... ChildTags>
class Obj<std::tuple<ParentTags...>, std::tuple<ChildTags...>> : public BaseObject
{
std::tuple<std::vector<typename ParentTags::obj_type*>...> parents;
std::tuple<std::vector<typename ChildTags::obj_type*>...> children;
public:
template <typename T>
void addParent(T* parent) { std::get<std::vector<T*>>(parents).push_back(parent); }
template <typename T>
void removeParent(const T* parent) {
auto& v = std::get<std::vector<T*>>(parents);
auto it = std::find(std::cbegin(v), std::cend(v), parent);
if (it != std::cend(v)) { v.erase(it); }
}
template <typename T>
void addChild(T* child) { std::get<std::vector<T*>>(children).push_back(child); }
template <typename T>
void removeChild(const T* child) {
auto& v = std::get<std::vector<T*>>(children);
auto it = std::find(std::cbegin(v), std::cend(v), child);
if (it != std::cend(v)) { v.erase(it); }
}
std::vector<BaseObject*> getAllParents() const override {
std::vector<BaseObject*> res;
std::apply([&](auto&... v){ (res.insert(res.end(), v.begin(), v.end()), ...); },
parents);
return res;
}
std::vector<BaseObject*> getAllChildren() const override {
std::vector<BaseObject*> res;
std::apply([&](auto&... v){ (res.insert(res.end(), v.begin(), v.end()), ...); },
children);
return res;
}
void removeAllParents() override {
std::apply(
[this](auto&... v)
{
[[maybe_unused]] auto clean = [this](auto& v) {
for (auto* parent : v) {
parent->removeChild(this);
}
v.clear();
};
(clean(v), ...);
},
parents);
}
void removeAllChildren() override {
std::apply(
[this](auto&... v)
{
[[maybe_unused]] auto clean = [this](auto& v) {
for (auto* child : v) {
child->removeParent(this);
}
v.clear();
};
( clean(v), ...);
},
children);
}
};
对于C ++ 14,用std::apply
和折叠表达式替换"for_each_tuple"会更加冗长.
With C++14, it would be more verbose to replace the "for_each_tuple" done with std::apply
and folding expression.
以及在C ++ 11中,std::get<T>(tuple)
甚至更多.
and in C++11, even more with std::get<T>(tuple)
.
这篇关于获取此对象的原始类型的文章就介绍到这了,希望我们推荐的答案对大家有所帮助,也希望大家多多支持IT屋!