Base class pointer: where to use new and delete - c++

Question

I wonder where I should use the new and delete in the following class structure:
#include <iostream>
class StateBase {
public:
StateBase( int val ) : m_stateInfo(val) {}
virtual ~StateBase() {}
virtual int getState() = 0;
protected:
int m_stateInfo;
};
class StateImpl1 : public StateBase {
public:
StateImpl1() : StateBase( 1 ) {}
~StateImpl1() {}
int getState() {
//std::cout << "stateimpl:" << m_stateInfo << std::endl;
return m_stateInfo;
}
};
class DeviceBase {
public:
DeviceBase( StateBase* pState ) : mp_state( pState ) {}
~DeviceBase() {} // TODO or delete here? but then it's a bit asymmetric...
virtual void work() = 0;
protected:
StateBase* mp_state;
};
class DeviceImpl1 : public DeviceBase {
public:
DeviceImpl1() : DeviceBase( new StateImpl1() ) {}
// TODO d'tor here? but then base is left without valid ptr to "mp_state"
~DeviceImpl1() { delete mp_state; }
void work() {
std::cout << "DeviceImpl1 work: state = " << mp_state->getState() << std::endl;
}
};
int main() {
DeviceImpl1 impl1;
impl1.work();
return 0;
}
Having the delete in the base class is asymmetric and less readable, I guess.
Using delete in the derived class (where the new is invoked) leaves the base class with a invalid pointer (if only shortly, but it's not clean).
using it in derived class, setting ptr to NULL and and checking pointer for NULL in the base class could be an option
maybe the whole design is flawed? if so: what's an alternative?
Update:
I can not use modern C++ because it will have to be compiled with a cross compiler < C++11.

Answer 1

Use unique_ptr to manage ownership/lifetime/memory:
#include <iostream>
#include <memory>
#include <utility>
class StateBase {
public:
StateBase( int val ) : m_stateInfo(val) {}
virtual ~StateBase() {}
virtual int getState() = 0;
protected:
int m_stateInfo;
};
class StateImpl1 : public StateBase {
public:
StateImpl1() : StateBase( 1 ) {}
~StateImpl1() {}
int getState() {
return m_stateInfo;
}
};
class DeviceBase {
public:
DeviceBase( std::unique_ptr<StateBase> ) : mp_state( std::move(pState) ) {}
virtual ~DeviceBase() {}
virtual void work() = 0;
protected:
std::unique_ptr<StateBase> mp_state;
};
class DeviceImpl1 : DeviceBase {
public:
DeviceImpl1() : DeviceBase( std::make_unique<StateImpl1>() ) {}
~DeviceImpl1() = default;
void work() {
std::cout << "DeviceImpl1 work: state = " << mp_state->getState() << std::endl;
}
};
int main() {
DeviceImpl1 impl1;
impl1.work();
return 0;
}

Answer 2

In modern C++, you would 1. figure out the desired ownership semantics and then 2. express them using appropriate memory management tools, such as smart pointers. Notably, you never manually do memory management. That's effort that should be encapsulated in a class whose sole responsibility is memory management (see single responsibility principle).
#include <iostream>
#include <memory>
class StateBase {
public:
StateBase( int val ) : m_stateInfo(val) {}
virtual ~StateBase() {}
virtual int getState() = 0;
protected:
int m_stateInfo;
};
class StateImpl1 : public StateBase {
public:
StateImpl1() : StateBase( 1 ) {}
~StateImpl1() {}
int getState() {
//std::cout << "stateimpl:" << m_stateInfo << std::endl;
return m_stateInfo;
}
};
class DeviceBase {
public:
// Constructor says: Give me exclusive ownership of a StateBase.
DeviceBase(std::unique_ptr<StateBase> pState) : mp_state(std::move(pState)) {}
// Destructor (implicitly generated) takes care of cleanup.
virtual void work() = 0;
protected:
std::unique_ptr<StateBase> mp_state;
};
class DeviceImpl1 : DeviceBase {
public:
DeviceImpl1() : DeviceBase(std::make_unique<StateImpl1>()) {}
// Base class constructor handles cleanup.
void work() {
std::cout << "DeviceImpl1 work: state = " << mp_state->getState() << std::endl;
}
};
int main() {
DeviceImpl1 impl1;
impl1.work();
return 0;
}
All we did here was to clarify that DeviceBase holds unique ownership of a StateBase. By doing that, we can eliminate all the destructors (std::unique_ptr handles the memory management for us, see also RAII). I would prefer = default; over an empty destructor implementation but that's largely immaterial. The automatically generated destructor of DeviceBase will call the unique_ptr destructor which will delete the stored StateBase instance.
Note that your original code does not follow the rule of three/five/zero, therefore you would run into problems (read: double free etc.) when attempting to copy instances of your class. In the above code using std::unique_ptr, the DeviceBase and DeviceImpl1 classes cannot be copied (because the std::unique_ptr member cannot be copied).

Answer 3

Inherit public base class :
#include <iostream>
class StateBase {
public:
StateBase(int val) : m_stateInfo(val) {}
virtual ~StateBase() {}
virtual int getState() = 0;
protected:
int m_stateInfo;
};
class StateImpl1 : public StateBase {
public:
StateImpl1() : StateBase(1) {}
~StateImpl1() {}
int getState() {
//std::cout << "stateimpl:" << m_stateInfo << std::endl;
return m_stateInfo;
}
};
class DeviceBase {
public:
DeviceBase(StateBase* pState) : mp_state(pState) {}
~DeviceBase() {} // TODO or delete here? but then it's a bit asymmetric...
virtual void work() = 0;
protected:
StateBase* mp_state;
};
class DeviceImpl1 : **public DeviceBase** { // Change is here
public:
DeviceImpl1() : DeviceBase(new StateImpl1()) {}
// TODO d'tor here? but then base is left without valid ptr to "mp_state"
~DeviceImpl1() { delete mp_state; }
void work() {
std::cout << "DeviceImpl1 work: state = " << mp_state->getState() << std::endl;
}
};
How you can initialize the DeviceImpl1 instance impl1 & call delete to execute both of the destructors :
int main() {
DeviceImpl1* impl1 = new DeviceImpl1();
DeviceBase* base = impl1;
impl1->work();
delete base; // This will execute both of the destructor.
return 0;
}