Notify the instance of the object when it is copied - c++

Question

I have a class with lazy initialization. For the sake of simplicity let's say that it is a database proxy. An object of the class can be in any of two states: Ready and Initialized. Initially, when you construct the object, you specify the database address, and the object becomes Ready, but doesn't connect to the DB yet. When you call any function which wants to access the DB the object performs the connection and changes its state to Initialized. I want the object to initialize when I do anything with it.
Including, I want to make this object copyable. However, I don't want to allow the uninitialized object to be copied: in this case two connections will be performed later. Instead I would like to notify the object when I'm trying to copy it so it can perform initialization, switch the state and only then copy to another object.
Here is a sample code with the behavior I'm trying to achieve.
class Foo {
public:
Foo(Config conf) :
initialized(false)
{
// process the config somehow
}
void tryInitialize() {
if (!initialized) {
// perform the connection
initialized = true;
connection = createConnection();
}
}
void accessDatabase() {
tryInitialize();
// do something
}
Foo(const Foo& other) {
other.tryInitialize(); // this is a problem because other is const
initialized = true;
connection = other.connection;
}
private:
bool initialized;
DBConnection connection;
};
The problem still arises if I declare copy ctor as Foo(Foo other) because in this case the original object wouldn't be modified as well. Of course, this is achievable with move ctor, but I'd like to use copy ctor as well.
P.S. The real problem is not much about databases but complex enough to be explained here. So you can assume that no real world problems about databases matter here: connection attempts always succeed, having two instances of the same connection is OK, etc.

Answer 1

You can mark your private members as mutable and make you tryInitialize() method const (or you can write some other private initialize method with constness).
This solution is a bit dirty but anyway it solves your problem :)

Answer 2

If i'm understanding this correctly, you want a copy constructor that can modify the passed in argument. If this is true then what your are saying is correct, foo( foo other ) would not work because that would only pass a copy of the argument, and foo( const foo& other ) would not be modifiable in the copy constructor. The solution is simply passing by reference.
Foo(Foo& other) {
initialized = true;
other.tryInitialize(); // Now will be able to modify other
connection = other.connection;
}
Reference article below for const correctness of copy constructors below, and I quote, " Pass by non-const reference ONLY if the function will modify the parameter and it is the intent to change the caller's copy of the data, otherwise pass by const reference."
http://www.cplusplus.com/articles/y8hv0pDG/
Reference article for mutable below, "mutable - applies to non-static class members of non-reference non-const type and specifies that the member does not affect the externally visible state of the class (as often used for mutexes, memo caches, lazy evaluation, and access instrumentation). mutable members of const classes are modifiable. (Note: the C++ language grammar treats mutable as a storage-class-specifier, but it does not affect storage class.)"
http://en.cppreference.com/w/cpp/language/cv
See example of using mutable from "Effective C++ Third Edition" by Scott Meyers, and apply for alternative solution to pass by reference.
class CTextBlock {
public:
...
std::size_t length() const;
private:
char *pText;
mutable std::size_t textLength;
mutable bool lengthIsValid;
};
std::size_t CTextBlock::length() const
{
if(!lengthIsValid) {
textLength = std::strlen(pText);
lengthIsValid = true;
}
return textLength;
}