Re: virtual destructor 101
On 10/20/2010 02:16 PM, Kenneth 'Bessarion' Boyd wrote:
On Oct 19, 3:53 am, Dragan Milenkovic<dra...@plusplus.rs> wrote:
[snip]
class Stack {
protected:
virtual ~Stack() = 0;
public:
virtual void foo() = 0;
};
Stack * create_stack();
void delete_stack(Stack *); // should call this one!
I'd make delete_stack a friend of class Stack if I wanted to do this;
otherwise it'll suffer the same fate as main. [Note: I have no
imagination what a use case, for strongly enforcing renaming outside
calls of Stack::~Stack as void delete_stack(Stack *), would be.]
This is only a simplification for presentation sake. Factory functions
may be actually a part of an abstract factory. It may not be a simple
new/delete pair, it may be a reference counting or may return
a singleton instance. I hope this answers your real-life usage
question, too.
My interface named Stack was trying to make a contract on Stack usage,
but it also becomes necessary for it to mess with the object ownership
and lifetime contracts. And this is what feels wrong.
Yet, no one here to support my claim and to help
expand this discussion beyond my annoying repeating
of "I feel this is wrong, I feel this is wrong!".
Agreed: explicitly breaking idiomatic syntax for abbreviating C++
source code, relative to C source code, feels wrong.
How about I change approach.
Given:
class FooStack {
private:
FooStack();
~FooStack();
/* representation */
public:
void push(int x);
int top() const;
void pop();
};
// Reference-counting implementation
// Illogical for a stack, but let it be please...
class FooStackFactory {
public:
FooStack * acquire_stack();
void release_stack(FooStack *);
};
and:
class BarStack {
public:
BarStack();
~BarStack();
void push(int x);
int top() const;
void pop();
private:
/* representation */
};
Could anyone write a common abstract interface for both
FooStack and BarStack? Of course, you can modify FooStack
and BarStack (eg. to make functions virtual),
but the functionality must remain the same.
IMHO, it is a fairly reasonable request of mine to want
an interface that only makes a contract on push/pop/top
functions of a stack, leaving lifetime and ownership
of objects unspecified, or to be specified by another
interface.
The best think I can do so far is to make the destructor
virtual and public, but write a specification
"The concrete implementation shall specify if you are
allowed to use this PUBLIC destructor or are there other means
to do lifetime management". Shall I say again that
this feels wrong?
Just to make it clear, I know that it would be reasonable
to write an adapters for FooStack and BarStack whose
destructor would invoke FooStackFactory::release_stack
and BarStack::~BarStack respectively, but this is
not what I want. Well, actually, I might want that
in a higher design layer.
--
Dragan
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]