For the GCC version of this, see this post (at the time of writing this link is to a scheduled item, it may not work just yet, scheduled for Tuesday 4th October 2016 at 18:30 GMT+1).
I commonly employ a "Factory Create" style to my classes in C++, the reason being I like to take control over the specific way that classes can be created, rather than relying on the compiler to always create the default constructors for me. I like the constructors, but it leads to the problem of memory leaks, lets take a look at a bad example:
With this class any programmer can then do:
Alpha* l_somevalue = new Alpha(42);
They can then forget to call "delete l_somevalue;" and therefore leak memory.
We would therefore like to hide the constructors away, to prevent their miss use:
This necessitates we do expose someway to create an instance of the class, and that instance be wrapped as a smart pointer...
The first thing we see is a forward declaration of the class, then it's type wrapped as a smart pointer (a shared pointer in this case). Next we see the various constructors have been made public, curing and removing all possibility of the programmer leaving hanging pointers to instances of our class.
Finally, we see a set of static "create" functions, our method to create an instance of the class now would look like this:
BetaPtr l_instance = Beta::Create();
When the reference count to the l_instance copy drops to zero then it will be automatically cleaned up, this is the whole point of this programming pattern.
There is nothing wrong with this code at the moment, we can define the constructors, knowing they can't be used outside the class, like this:
And the create functions look like this:
So far, we've learned nothing new... So what is new?... Well in C++14, really we should not be calling "new" at all. The moment we see new outside the class we should implement this whole code pattern to hide the constructors away, exposing only smart pointers. And likewise internally to those create functions we should not be calling "new", we should be using "std::make_shared".
Like this:
The problem?...
Hmmm... "error C2248: 'Beta::Beta': cannot access private memory declared in class 'Beta'", what is this telling us?
That the constructor of Beta could not access one of the private members of itself? Huh?.. That makes no sense, of course the constructor should be able to access its own member!
What else does the error tell us? "File: memory"... memory?... Not my code file, but the memory header? We can open that location and take a look, what is the location of the error representing?
The _Ref_count_obj, the actual location that a shared_ptr is instantiated and the forward passed the arguments to the constructor, so the error is NOT that the constructor of our class can't get at it's private member, but that the template wrapped reference count object, which we inherit from because of the use of "make_shared", that reference can't get at the private members of the class!
How to solve this?... Simple:
Simply adding the "friend std::_Ref_count_obj<Beta>" allows that inherited class from "<memory>" to see inside the private area of the Beta class, and we enable the clean use of std::make_shared thereafter.
I highly recommend removing your constructors from prominence, and the use of "Factory Creation", as to other much more authoritative figures then myself.
My Complete code is below!
#include <iostream>
#include <memory>
class Alpha
{
private:
int m_AlphaValue;
public:
Alpha();
Alpha(const int& p_NewValue);
Alpha(const Alpha& p_OtherAlpha);
const int Value();
void Value(const int& p_NewValue);
};
class Beta;
using BetaPtr = std::shared_ptr<Beta>;
class Beta
{
private:
friend std::_Ref_count_obj<Beta>;
int m_AlphaValue;
Beta();
Beta(const int& p_NewValue);
Beta(const Beta& p_OtherBeta);
public:
static BetaPtr Create();
static BetaPtr Create(const int& p_NewValue);
static BetaPtr Create(const BetaPtr& p_OtherBeta);
const int Value();
void Value(const int& p_NewValue);
};
Beta::Beta()
:
m_AlphaValue(42)
{
}
Beta::Beta(const int& p_NewValue)
:
m_AlphaValue(p_NewValue)
{
}
Beta::Beta(const Beta& p_OtherBeta)
:
m_AlphaValue(p_OtherBeta.m_AlphaValue)
{
}
BetaPtr Beta::Create()
{
return std::make_shared<Beta>();
}
BetaPtr Beta::Create(const int& p_NewValue)
{
return std::make_shared<Beta>(p_NewValue);
}
BetaPtr Beta::Create(const BetaPtr& p_OtherBeta)
{
return std::make_shared<Beta>(*p_OtherBeta.get());
}
int main()
{
Alpha* l_Instance = new Alpha(42);
std::cout << "Alpha: " << l_Instance->Value() << std::endl;
BetaPtr l_BetterInstance = Beta::Create(42);
std::cout << "Beta: " << l_BetterInstance->Value() << std::endl;
// No need to delete l_BetterInstance, it cleans itself up
// Whoops... l_Instance of alpha leaks!
}
