Reference to abstract class as a class member

[defunct]

Hi, all!
I have the following question: suppose i have abstract class base Base and its complete implementation ImplBase (several of them); I want to use implementations of Base in some other class User as a class member. How can i do it using references (not pointers)? In particular, how can i initialize reference in constructor?

The code describing the situation is given below:

class Base{
public:
   virtual void someVirtualFunction() = 0
};

class ImplBase: public Base
public:
   void someVirtualFunction(){
      cout << "ImplBase ";
   }
};

class User
{
public:
   User();
private:
   Base &_ref;
};

User::User(){
//this does not work and i end up with initialized reference
   _ref = ImplBase();
}

[Moschops]

Edited because I didn't like my code. :(

[KRAkatau]

I see several problems with your code.
First, is that the reference variable has to be initialized and not assigned. So I would expect a compiler error in line 23. This should be written as:

User::User():
_ref(ImplBase())
{
}

Which brings me to the second problem.

In order to use the reference to base class you need to have the actual object somewhere in memory - be it on stack or dynamically allocated. What happens in line 23 of your code is that a temporary variable is created on stack and then _ref points to it. However, this temporary variable is destroyed when constructor exits.

I am a bit confused about why do you even want to use the Base& in this case when you know exactly which implementation you will use. In this case you can just use a member variable ImplBase _impl; instead of Base& _ref;.

If you really want to have a base-class reference, then you have two options. First, is

class User
{
public:
   User();
private:
   Base &_ref;
};

User::User()
: _ref(*(new ImplBase()));
{
   
}

which will create an instance of ImplBase in dynamic memory. However, don't forget to destroy the object in destructor (delete &_ref;). Also to ensure correct destruction of the derived object through a pointer to the base object you need to make the destructor virtual.

The second option is to have the instance of ImplBase in your class:

class User
{
public:
   User();
private:
   Base &_ref;
   ImplBase _impl;
};

User::User() :
_ref(_impl)
{
}

However, again, before using the base-class reference you need to decide whether and why do you need a reference in this case.

[JLBorges]

> How can i do it using references (not pointers)?

Use a thin wrapper to convert a pointer to a reference, perhaps? For instance:

struct base // base.h
{
    virtual ~base() {}
    virtual void some_operation() const = 0 ;

    static std::shared_ptr<base> default_implementation() ;
};

std::shared_ptr<base> base::default_implementation() // base.cc
{
    struct derived : base
    {
        virtual void some_operation() const override { /* whatever */ }
    };
    return std::make_shared<derived>() ;
}

#include "base.h" // user.cc

struct user
{
    user() : pointer( base::default_implementation() ) {}
    explicit user( std::shared_ptr<base> use_this ) : pointer(use_this) {}

    void some_function() { ref().some_operation() ; /* ... */ }

    private:
        std::shared_ptr<base> pointer ;
        inline base& ref() { return *pointer ; }
        inline const base& ref() const { return *pointer ; }
};

[defunct]

Thanks a lot! Now it is clear