sizeof(*this) in header only constructor implementation

Question

The title says it all, and whilst the 'standards' are to prefer a sizeof(typename), are there any instances where the sizeof(*this) is more error-prone or somehow undesirable?

I cannot see any at the first glance, but if yes, why with a short explanation would be helpful.

Thanks.

Answer 1

I prefer sizeof(variable) over sizeof(type) wherever possible since it's less error prone, in case your variable changes type.

Answer 2

The only reason I can think of to avoid sizeof(*this) is that it could be misunderstood as the size of the actual object (e.g., a derived class).

Answer 3

My view is that sizeof( type ) is preferable to sizeof( variable ) in order to preclude ambiguity. The following example shows an instance of a derived class referenced through a base class pointer. The size method returns sizeof( Derived ) so sz1 == sz3 == sz4. The caller could reasonably expect sizeof( Base ) if they have no insight into the implementation.

class Base
{
  public:
    virtual size_t size( void )
    {
        return sizeof( *this ) ;
    }
  private:
    int    a ;
    double b ;
} ;

class Derived : public Base
{
  public:
    virtual size_t size( void )
    {
        return sizeof( *this ) ;
    }
  private:
    long c ;
  } ;

int main( int argc , char * argv[] )
{
    Base    b ;
    Derived d ;

    size_t sz0 = sizeof( Base ) ;
    size_t sz1 = sizeof( Derived ) ;
    size_t sz2 = b.size() ;
    size_t sz3 = d.size() ;

    Base * pb = &d ;
    size_t sz4 = pb->size() ;
}