ctor requires operator delete when using C++ exception handling

Hi,
It seems that C++ exception handling (we currently don't use it
really)
requires class to have operator delete available.

I have a service component that creates instances of some class C and
gives
references to client components. I want to forbid clients directly
accessing
C objects - especially deleting them.

Therefore I created a wrapper/smart ptr for them (C_ptr).
NEvertheless
clients can do

         const C* real_C = c.operator->(); // cannot prevent this
         delete real_C; // this must not happen!!!

Therefore I declared but did not implement operator delete. Now
clients
cannot call delete any more and they cannot delete the objects. They
will receive a linker error.

But this only works when exception handling is turned off. When turned
on I
(too) get the linker error:

unresolved external symbol "public: static void __cdecl C::operator
delete(void *)"
(??3C@@SAXPAX@Z) referenced in function
__unwindfunclet$?create_C@Service@@QAE?AVC_ptr@@XZ$0

In the assembly code I see the call to C::delete is part of stack
unwinding
code. This means the trick with hiding delete does not work in this
case.

Do you have another pattern or mechanism where I can achieve the same
as above? That is a delivering a "pointer" with "denial of deletion".
What I dislike very much is my operator-> returning the address of the
real object anyway!

Here's my sample code:

class C {
public:
  C () {} // requires "public: static void __cdecl C::operator
delete(void
*)"
  void f () const {} // client may call
  void g (); // service may call
public:
  // not implemented on purpose!
  void operator delete(void*); // to compile comment out
private:
  // ...
};

class C_ptr {
public:
  C_ptr (const C* pc) : c_ (pc) {}
  const C* operator->() { return c_; }
private:
  const C* c_;
};

class Service {
public:
  C_ptr create_C ();
  // ...
};

C_ptr Service::create_C () {
  C* c = new C ();
  // ...
  return C_ptr (c);
}

void main () {
  Service s;
  C_ptr c = s.create_C ();
  c->f (); // okay
  //c->g (); // fails, which is okay
  const C* real_C = c.operator->(); // cannot prevent this
  delete real_C; // this must not happen!!! to link comment out
}

--
      [ See http://www.gotw.ca/resources/clcm.htm for info about ]
      [ comp.lang.c++.moderated. First time posters: Do this! ]