Turning ownership on and off
Let’s return to the ownership problem. Containers that hold objects by
value don’t usually worry about ownership because they clearly own the objects
they contain. But if your container holds pointers (which is more common with
C++, especially with polymorphism), then it’s very likely
those pointers may also be used somewhere else in the program, and you don’t
necessarily want to delete the object because then the other pointers in the
program would be referencing a destroyed object. To prevent this from
happening, you must consider ownership when designing and using a container.
Many programs are much simpler than this,
and don’t encounter the ownership problem: One container holds pointers to
objects that are used only by that container. In this case ownership is very
straightforward: The container owns its objects.
The best approach to handling the
ownership problem is to give the client programmer a choice. This is often
accomplished by a constructor argument that defaults to indicating ownership
(the simplest case). In addition there may be “get” and “set” functions to view
and modify the ownership of the container. If the container has functions to
remove an object, the ownership state usually affects that removal, so you may
also find options to control destruction in the removal function. You could
conceivably add ownership data for every element in the container, so each
position would know whether it needed to be destroyed; this is a variant of
reference counting, except that the container and not the
object knows the number of references pointing to an object.
//: C16:OwnerStack.h
// Stack with runtime conrollable ownership
#ifndef OWNERSTACK_H
#define OWNERSTACK_H
template<class T> class Stack { struct Link { T* data;
Link* next;
Link(T* dat, Link* nxt)
: data(dat), next(nxt) {} }* head;
bool own;
public:
Stack(bool own = true) : head(0), own(own) {} ~Stack();
void push(T* dat) { head = new Link(dat,head);
}
T* peek() const { return head ? head->data : 0;
}
T* pop();
bool owns() const { return own; } void owns(bool newownership) { own = newownership;
}
// Auto-type conversion: true if not empty:
operator bool() const { return head != 0; }};
template<class T> T* Stack<T>::pop() { if(head == 0) return 0;
T* result = head->data;
Link* oldHead = head;
head = head->next;
delete oldHead;
return result;
}
template<class T> Stack<T>::~Stack() { if(!own) return;
while(head)
delete pop();
}
#endif // OWNERSTACK_H ///:~
The default behavior is for the container to
destroy its objects but you can change this by either modifying the constructor
argument or using the owns( ) read/write member functions.
As with most templates you’re likely to
see, the entire implementation is contained in the header file. Here’s a small
test that exercises the ownership abilities:
//: C16:OwnerStackTest.cpp
//{L} AutoCounter #include "AutoCounter.h"
#include "OwnerStack.h"
#include "../require.h"
#include <iostream>
#include <fstream>
#include <string>
using namespace std;
int main() { Stack<AutoCounter> ac; // Ownership on
Stack<AutoCounter> ac2(false); // Turn it off
AutoCounter* ap;
for(int i = 0; i < 10; i++) { ap = AutoCounter::create();
ac.push(ap);
if(i % 2 == 0)
ac2.push(ap);
}
while(ac2)
cout << ac2.pop() << endl;
// No destruction necessary since
// ac "owns" all the objects
} ///:~
The ac2 object doesn’t own the
objects you put into it, thus ac is the “master” container which takes
responsibility for ownership. If, partway through the lifetime of a container,
you want to change whether a container owns its objects, you can do so using owns( ).
It would also be possible to change the
granularity of the ownership so that it is on an object-by-object basis, but that
will probably make the solution to the ownership problem more complex than the
problem.
