使用基类指针查找派生类对象的大小

Question

当您不知道派生类型时，是否可以使用基类指针找到派生类对象的大小。

谢谢。

Answer 1

没有直接的方法，但是您可以编写子类可以实现的虚拟size()方法。 中介模板类可以自动执行腿部工作。

struct base {
  virtual size_t size() const =0;
  virtual ~base() { }
};

template<typename T> 
struct intermediate : base {
  virtual size_t size() const { return sizeof(T); }
};

struct derived : intermediate<derived> 
{ };

这确实要求您的层次结构是多态的……但是，基于对象的动态类型而不是其静态类型来请求行为是多态行为定义的一部分。 因此，这不会在平均用例中添加v表，因为至少您可能已经具有虚拟析构函数。

这个特定的实现确实将您的继承树限制为一个级别，而没有涉及到多个继承[即，派生自derived的类型将不会获得其自身的size覆盖]。 有一个稍微复杂的变体可以解决这个问题。

struct base { /*as before */ };

template<typename Derived, typename Base>
struct intermediate : Base {
  virtual size_t size() const { return sizeof(Derived); }
};

struct derived : intermediate<derived, base>
{ };

struct further_derived : intermediate<further_derived, derived>
{ };

基本上，这插入一个intermediate层次结构中的，每一个覆盖的每个实际层之间size与适当的行为，并从实际的基本类型导出。 重复广告恶心。

//what you want
base >> derived 
     >> more_deriveder
     >> most_derivedest

//what you get
base >> intermediate<derived, base> 
     >> derived >> intermediate<more_deriveder, derived> 
     >> more_deriveder >> intermediate<most_derivedest, more_deriveder> 
     >> most_derivedest

几个mixin类型的库使用这种方案，以便可以将mixins添加到现有层次结构中而不会引入多重继承。 就个人而言，我很少使用超过一个级别的继承，因此我不必担心增加的复杂性，但是您的工作量可能会有所不同。

Answer 2

我不认为这是可以做到的，因为sizeof适用于编译时间类型。 您可以在基类中定义一个虚拟Size函数，并为每个派生类覆盖它。

Answer 3

考虑到@Dennis Zickefoose的好回答，在某些情况下，您可以实现多个继承级别，这既不需要虚函数，也不需要在继承的每一层和增加的复杂性之间使用中间类。

那时继承层次结构中的所有中间（非叶子）类都是抽象类，也就是说，它们没有被实例化。

如果是这样，您可以（再次）在派生的具体类型上编写模板化的非叶子抽象类。

下面的示例演示了这一点：

template <class TDerived>
class Shape     // Base
{
public:
    float centerX;
    float centerY;

    int getSize()
    { return sizeof(TDerived); }

    void demo()
    {
        std::cout
            << static_cast<TDerived*>(this)->getSize()
            << std::endl;
    }
};

class Circle : public Shape<Circle>
{
public:
    float radius;
};

class Square : public Shape<Square>
{
    // other data...
};

template <class TDerived>
class Shape3D : public Shape<TDerived>
    // Note that this class provides the underlying class the template argument
    //   it receives itself, and note that Shape3D is (at least conceptually)
    //   abstract because we can't directly instantiate it without providing it
    //   the concrete type we want, and because we shouldn't.
{
public:
    float centerZ;
};

class Cube : public Shape3D<Cube>
{
    // other data...
};

class Polyhedron : public Shape3D<Polyhedron>
{
public:
    typedef float Point3D[3];

    int numPoints;
    Point3D points[MAX_POINTS];

    int getSize()   // override the polymorphic function
    { return sizeof(numPoints) + numPoints * sizeof(Point3D); }
    // This is for demonstration only. In real cases, care must be taken about memory alignment issues to correctly determine the size of Polyhedron.
};

用法示例：

Circle c;
c.demo();

Polyhedron p;
p.numPoints = 4;
p.demo();

Answer 4

由于C ++中缺少反射，因此一时兴起地使用任意类通常是不可能的。 但是，有一些解决方法。 您可以按照其他人的建议编写虚拟size（）方法。 您还可以使用“好奇地重复使用的模板模式”，也可以从Register<T>继承，但我不建议这样做，vtable每个对象花费4个字节，T的子类报告大小不正确，并且更正它会导致多重继承。

最好的方法是使用一个类来注册，存储和查询动态尺寸信息，而无需修改要查询的类：

编辑 ：事实证明，由于typeid语义不一致，它仍然需要带有vtables的类，请参见注释。

#include <cstddef>
#include <exception>
#include <iostream>
#include <map>
#include <typeinfo>

using namespace std;

class ClassNotFoundException
: public exception
{};

class Register
{

    public:

        template <class T>
        static void reg (T* = NULL)
        {
            //  could add other qualifiers
            v[&typeid(T)] = sizeof(T);
            v[&typeid(const T)] = sizeof(T);
            v[&typeid(T*)] = sizeof(T);
            v[&typeid(const T*)] = sizeof(T);
        }

        template <class T>
        static int getSize (const T& x)
        {
            const type_info* id = &typeid(x);
            if( v.find(id) == v.end() ){
                throw ClassNotFoundException();
            }
            return v[id];
        }

        template <class T>
        static int getSize (T* x)
        {
            return getSize(*x);
        }

        template <class T>
        static int getSize (const T* x)
        {
            return getSize(*x);
        }

    protected:

        static map<const type_info*, int> v;

};

map<const type_info*, int> Register::v;

class A
{
    public:
        A () : x () {}
        virtual ~A () {}
    protected:
        int x;
};

class B
: public A
{
    public:
        B() : y () {}
        virtual ~B () {}
    protected:
        int y;
};

int main ()
{
    Register::reg<A>();
    Register::reg<B>();

    A* a = new B();
    const A* b = new B();

    cout << Register::getSize(a) << endl;
    cout << Register::getSize(b) << endl;
}