问题描述
所以我一直很期待metaclasses。然后我听说它不会出现在 c++23 中,因为他们认为我们首先需要在语言中进行反思和具体化,然后才能添加元类。
查看 c++23 反射,似乎有具体化功能。它们是否足以解决元类会做什么?即,元类只是语法糖吗?
使用 current proposal,我们可以复制某人编写如下类型:
interface bob {
void eat_apple();
};
并生成如下类型:
struct bob {
virtual void eat_apple() = 0;
virtual ~bob() = default;
};
更进一步,采取类似于
vtable bob {
void eat_apple();
~bob();
};
poly_value bob_value:bob {};
并且能够生成
// This part is optional,but here we are adding
// a ADL helper outside the class.
template<class T>
void eat_apple(T* t) {
t->eat_apple();
}
struct bob_vtable {
// for each method in the prototype,make
// a function pointer that also takes a void ptr:
void(*method_eat_apple)(void*) = 0;
// no method_ to guarantee lack of name collision with
// a prototype method called destroy:
void(*destroy)(void*) = 0;
template<class T>
static constexpr bob_vtable create() {
return {
[](void* pbob) {
eat_apple( static_cast<T*>(pbob) );
},[](void* pbob) {
delete static_cast<T*>(pbob);
}
};
}
template<class T>
static bob_vtable const* get() {
static constexpr auto vtable = create<T>();
return &vtable;
}
};
struct bob_value {
// these should probably be private
bob_vtable const* vtable = 0;
void* pvoid = 0;
// type erase create the object
template<class T> requires (!std::is_base_of_v< bob_value,std::decay_t<T> >)
bob_value( T&& t ):
vtable( bob_vtable::get<std::decay_t<T>>() ),pvoid( static_cast<void*>(new std::decay_t<T>(std::forward<T>(t))) )
{}
~bob_value() {
if (vtable) vtable->destroy(pvoid);
}
// expose the prototype's signature,dispatch to manual vtable
// (do this for each method in the prototype)
void eat_apple() {
vtable->method_eat_apple(pvoid);
}
// the prototype doesn't have copy/move,so delete it
bob_value& operator=(bob_value const&)=delete;
bob_value(bob_value const&)=delete;
};
Live example,这两个例子都是我对元类感到兴奋的例子。
我不太担心语法(能够编写库并创建 poly 值或接口只是有用的,确切的语法不是),因为我担心它能够做到这一点。>
解决方法
查看 c++23 反射,似乎有具体化功能。它们是否足以解决元类会做什么?即,元类只是语法糖吗?
将其称为 C++23 反射是……乐观的。但答案是肯定的。引用P2237:
元类只是[前面]描述的功能之上的语法糖
正如论文所指出的,元类语法:
template<typename T,typename U>
struct(regular) pair{
T first;
U second;
};
意味着:
namespace __hidden {
template<typename T,typename U>
struct pair {
T first;
U second;
};
}
template <typename T,typename U>
struct pair {
T first;
U second;
consteval {
regular(reflexpr(pair),reflexpr(__hidden::pair<T,U>));
}
};
其中 regular
是一些注入一堆代码的 consteval
函数。但是为了让它完全发挥作用,我们需要有一种语言工具来支持 consteval
函数,该函数可以注入一堆代码。元类只是在此基础上提供了一个很好的接口,但这只是我们希望通过代码注入能够做的事情的一部分。