C++ hiding Dispose is BAD

[Ben Voigt [C++ MVP]]

Anyone know a direct translation for this C# code? I know I can make a new
function, of course, but that's clumsy.

assume (o is IDisposable)
MethodInvoker d = o.Dispose;

I tried taking the address of the destructor, that either tries to give me
protected void Dispose(bool) with an error (it's the wrong argument list) or
tells me {dtor} is not a member of IDisposable.

This is all on VS2005 SP1.

Automatic implementation of IDisposable screwed up this one!

[Mark Salsbery [MVP]]

"Ben Voigt [C++ MVP]" <rb*@nospam.nospamwrote in message
news:#x*************@TK2MSFTNGP06.phx.gbl...

Anyone know a direct translation for this C# code? I know I can make a
new function, of course, but that's clumsy.

assume (o is IDisposable)
MethodInvoker d = o.Dispose;

I tried taking the address of the destructor, that either tries to give me
protected void Dispose(bool) with an error (it's the wrong argument list)
or tells me {dtor} is not a member of IDisposable.

Does this work?

////////////////////////////////////////////////////////////////////////

ref class disposableclass
{
public:
disposableclass()
{
}
~disposableclass()
{
this->!disposableclass();
}
!disposableclass()
{
}
};

....

disposableclass ^o = gcnew disposableclass();
MethodInvoker ^d = gcnew MethodInvoker(o,
&disposableclass::~disposableclass);

////////////////////////////////////////////////////////////////////////
Mark

--
Mark Salsbery
Microsoft MVP - Visual C++

[Ben Voigt [C++ MVP]]

Mark Salsbery [MVP] wrote:

"Ben Voigt [C++ MVP]" <rb*@nospam.nospamwrote in message
news:#x*************@TK2MSFTNGP06.phx.gbl...

>Anyone know a direct translation for this C# code? I know I can
make a new function, of course, but that's clumsy.

assume (o is IDisposable)
MethodInvoker d = o.Dispose;

I tried taking the address of the destructor, that either tries to
give me protected void Dispose(bool) with an error (it's the wrong
argument list) or tells me {dtor} is not a member of IDisposable.

Does this work?

Your code compiles cleanly. So my situation is actually less general than I
first thought.

Change disposableclass so that it inherits System::Windows::Forms::Form, for
instance. Then:

..\CppTestJunk.cpp(28) : error C2248: 'disposableclass::Dispose' : cannot
access protected member declared in class 'disposableclass'

..\CppTestJunk.cpp(21) : compiler has generated 'disposableclass::Dispose'
here

..\CppTestJunk.cpp(8) : see declaration of 'disposableclass'

..\CppTestJunk.cpp(28) : error C3352: 'void disposableclass::Dispose(bool)' :
the specified function does not match the delegate type 'void (void)'

>
////////////////////////////////////////////////////////////////////////

ref class disposableclass
{
public:
disposableclass()
{
}
~disposableclass()
{
this->!disposableclass();
}
!disposableclass()
{
}
};

...

disposableclass ^o = gcnew disposableclass();
MethodInvoker ^d = gcnew MethodInvoker(o,
&disposableclass::~disposableclass);

////////////////////////////////////////////////////////////////////////
Mark

[Mark Salsbery [MVP]]

"Ben Voigt [C++ MVP]" <rb*@nospam.nospamwrote in message
news:ew**************@TK2MSFTNGP03.phx.gbl...

>
Your code compiles cleanly. So my situation is actually less general than
I first thought.

Change disposableclass so that it inherits System::Windows::Forms::Form,
for instance.

In that case, Dispose() is hidden (by access level change) by the Form
class and re-exposed through its Close() member, so yeah, that won't work.

[Mark Salsbery [MVP]]

"Mark Salsbery [MVP]" <MarkSalsbery[MVP]@newsgroup.nospamwrote in message
news:#e**************@TK2MSFTNGP06.phx.gbl...

>
In that case, Dispose() is hidden (by access level change) by the Form
class and re-exposed through its Close() member, so yeah, that won't work.

re-exposed is the wrong wording...I meant iDispose()'s functionality is
re-exposed through Close().

The derived class would need to implemented in a similar fashion.

Mark

--
Mark Salsbery
Microsoft MVP - Visual C++

>

[Ben Voigt [C++ MVP]]

"Mark Salsbery [MVP]" <MarkSalsbery[MVP]@newsgroup.nospamwrote in message
news:#e**************@TK2MSFTNGP06.phx.gbl...

"Ben Voigt [C++ MVP]" <rb*@nospam.nospamwrote in message
news:ew**************@TK2MSFTNGP03.phx.gbl...

>>
Your code compiles cleanly. So my situation is actually less general
than I first thought.

Change disposableclass so that it inherits System::Windows::Forms::Form,
for instance.

In that case, Dispose() is hidden (by access level change) by the Form
class and re-exposed through its Close() member, so yeah, that won't work.

..NET doesn't allow changing access level at inheritance. But the C++/CLI
compiler is considering the destructor reference to mean protected
Dispose(bool) instead of public Dispose(void).

[Mark Salsbery [MVP]]

"Ben Voigt [C++ MVP]" <rb*@nospam.nospamwrote in message
news:0B**********************************@microsof t.com...

>
.NET doesn't allow changing access level at inheritance.

Yeah I always believe that in C#.

What magic does C++ use to make this fail to compile:

System::Windows::Forms::Form ^frm = gcnew
System::Windows::Forms::Form();
frm->Dispose();
???

[Mark Salsbery [MVP]]

Duh - C++ doesn't let you call Dispose().
///////////////////////////////////////

ref class disposableclass : public System::Windows::Forms::Form
{
public:
disposableclass()
{
}
~disposableclass()
{
this->!disposableclass();
}
!disposableclass()
{
}
};

....
disposableclass ^o = gcnew disposableclass();
o->~disposableclass(); // This is ok
MethodInvoker ^d = gcnew MethodInvoker(o,
&disposableclass::~disposableclass); // This is not ok?

///////////////////////////////////////
Bug?

[Ben Voigt [C++ MVP]]

Not sure what you meant by that last comment.

delete (some_tracking_handle);

does exactly call Dispose on the object if it implements IDisposable.

"Mark Salsbery [MVP]" <MarkSalsbery[MVP]@newsgroup.nospamwrote in message
news:uH**************@TK2MSFTNGP03.phx.gbl...

Duh - C++ doesn't let you call Dispose().
///////////////////////////////////////

ref class disposableclass : public System::Windows::Forms::Form
{
public:
disposableclass()
{
}
~disposableclass()
{
this->!disposableclass();
}
!disposableclass()
{
}
};

...
disposableclass ^o = gcnew disposableclass();
o->~disposableclass(); // This is ok
MethodInvoker ^d = gcnew MethodInvoker(o,
&disposableclass::~disposableclass); // This is not ok?

///////////////////////////////////////
Bug?