Curious case of C++ Object slicing behaviour on Base class static reference data member

Question

I am experiencing a curious case of Object slicing. I am working on project where I need singleton classes so my Base and derived class both are singleton. Following sample case describes my situation.

This is my Base class

// Base.h
class Base
{
    public:

        static Base& base;

        virtual void doSomething(){ cout<<"Base Do Something"<<endl; }

    protected:

        Base();
        virtual ~Base();
        static Base& getBaseInstance();

    private:
};

//Base.cpp
Base::Base()
{
    //ctor
}

Base::~Base()
{
    //dtor
}

Base& Base::getBaseInstance()
{
    static Base object;
    return object;
}
Base& Base::base=Base::getBaseInstance();

This is my Derived Class

class Derived: public Base
{
    public:

    static Derived& derived;
    virtual void doSomething(){ cout<<"Derive Do Something"<<endl; }

  static Derived& getDerivedInstance();
    protected:
        Derived();
        virtual ~Derived();

    private:
};

Derived::Derived()
{
    //ctor
}

Derived::~Derived()
{
    //dtor
}

Derived& Derived::derived=Derived::getDerivedInstance();

Derived& Derived::getDerivedInstance()
{
    static Derived object;
    return object;
}

And finally this is my main Function

int main()
{
    cout << "Hello world!" << endl;
    Base::base.doSomething();
    Derived::derived.doSomething();

    Base::base=Derived::derived;

    Base::base.doSomething();

    Base::base=Derived::getDerivedInstance();

    Base::base.doSomething();

    Base& r = Derived::derived;

    r.doSomething();

    Base::base=Derived::getDerivedInstance();
    Base::base.doSomething();
    return 0;
}

And I am getting following output for this

Hello world!
Base Do Something
Derive Do Something
Base Do Something
Base Do Something
Derive Do Something
Base Do Something

So my question is since object slicing should not work on references, then why I am not able to overwrite Base::base reference I created as static data member of Base class with Derived object? While this works fine on Base& r = Derived::derived;

I mean when I call do something with r.doSomething() I get doSomething of Derived class. But this is not so with

    Base::base=Derived::derived;    
    Base::base.doSomething();

or

    Base::base=Derived::getDerivedInstance();    
    Base::base.doSomething();

Any sort of clarification will be appreciated. Thank You.

Answer 1

When you do

Base::base=Derived::derived;

You are not setting the base reference to refer to the derived class. This is the assignment operator and all it does is asign the Base part of derived to base.

base is still of type Base and can never change as references can only ever be initialized once and you do that with

Base& Base::base=Base::getBaseInstance();

If you want this reassignment behavior you are going to need to use a pointer type.

Answer 2

A reference is for all purposes the object referred to. Assigning to the reference is to assign to the object referred to. In your case the objects have no data members, so there's no effect.

In particular there's no detectable slicing.

The declaration

Base& r = Derived::derived;

… is a very different case: an initialization, not an assignment.

An initialization makes the reference refer to the specified object.

The reference can't be changed after that.

---

In other news:

• The globals (the references) run the risk of static initialization order fiasco. They only serve to nullify the advantage of the singleton getter functions. With the globals the functions are just no-purpose added verbosity.

• Mutable singletons with data members allow communication between widely separate and seemingly unconnected parts of the code. This makes it hard to rely on any assumptions about current state and about what influences what. That's also why global variables are regarded as Evil™ in every programming language, so use singletons with caution.

Answer 3

Base::base is a static reference. You intialize it here:

Base& Base::base=Base::getBaseInstance();

From this point onwards (i.e. before your code using base is executed), base refers to the base instance (i.e. the static instance declared in Base::getBaseInstance()).

When you then do the assignment, you will not change the reference anymore, but you will copy the object into the object referred by base (which is of type base, hence the slicing !).

A workaround could be to make Base::base a pointer. In this way, you'd be able to change it and point to the derived object. However does this fit with our approach of singleton (because then you'll have the base object somewhere AND the derived object).