inline operator delete redefinition and in-charge deleting destructor

inline operator delete redefinition and in-charge deleting destructor

[Christian BRUEL]

I have the following problem with gcc3.3.3 on Solaris:

If providing the definition of a destructor outside the module where
"delete" is called, the compiler instantiates a function call to delete
to the standard library, thus missing my definition.

See the following program:

Of course, I comment out the "#include "new"" in ddef.cxx the program
works.

Similarly if I don't inline the operator delete I get a correct
behavior.

Do I miss something ? is it a problem with the "inline" keyword that
don't provide a definition preempting the one from the library ?
Shouldn't inlined functions provide their body in case they are not
member functions ?

Does the "language" forces me to include "new" for every implicit call
to memory operators ?

Thank you,

--- i.h ---
class MyClass
{
public:
  virtual ~MyClass(void);
};


--- new ---
extern int glob;

inline void operator delete(void *p)
{
  glob++;
}

--- ddef.cxx ---
#include "i.h"

MyClass::~MyClass(void)
{
}

--- foo.cxx ---
#include <stdio.h>
#include "i.h"

// explicit call to delete. include definition
#include "new"

int glob;

main()
{
  MyClass *b = new MyClass;	
  delete b;

  if (glob != 1)
    printf ("FAILED %d\n", glob);
  else
    printf ("SUCCESS\n");
}

Re: inline operator delete redefinition and in-charge deleting destructor

[Eljay Love-Jensen]

Hi Christian.

You need...
#include "new"
... at the top of your i.h file.

Also, destructors have () parameter specification, not (void) for their 
parameters.

Also, your header files should have guards to make sure they are only 
included once.

Also, C++ uses...
#include <cstdio>
... not...
#include <stdio.h>

Also, you may want to change the name of your "new" header file to 
"mynew.h" or "mynew.hxx" or "mynew.hpp".  I prefer the first convention.

Style point:  MyClass* b = new MyClass; (the C++ way) is preferable to 
MyClass *b = new MyClass; (the C way).

Style point:  you should put the "extern int glob;" in a header file, 
instead of hard coded.

HTH,
--Eljay

Re: inline operator delete redefinition and in-charge deleting destructor

[Jonathan Wakely]

> Also, destructors have () parameter specification, not (void) for their 
> parameters.

That's a matter of style, they mean the same thing and are equally valid.

> Also, C++ uses...
> #include <cstdio>
> ... not...
> #include <stdio.h>

Again, both are valid.

jon


-- 
"A great many people think they are thinking when they are merely
 rearranging their prejudices."
	- William James

Re: inline operator delete redefinition and in-charge deleting destructor

[Eljay Love-Jensen]

Hi Jon,

 >That's [(void) for the destructor] a matter of style, they mean the same 
thing and are equally valid.

I believe that is incorrect*, and that they are explicitly invalid for 
destructors and default constructors.

They are optional for other member methods, and typically in C++ are omitted.

 >Again, both [<stdio.h> and <cstdio>] are valid.

I believe that is incorrect*.  In C the header file is <stdio.h>, whereas 
in C++ <cstdio> is the header file.

Sincerely,
--Eljay

* I may be mistaken.  I'd have to review the ISO 14882 spec to be sure.

Re: inline operator delete redefinition and in-charge deleting destructor

[llewelly]

Eljay Love-Jensen <eljay@adobe.com> writes:

> Hi Jon,
> 
>  >That's [(void) for the destructor] a matter of style, they mean the
> same thing and are equally valid.
> 
> I believe that is incorrect*, and that they are explicitly invalid for
> destructors and default constructors.
> 
> They are optional for other member methods, and typically in C++ are omitted.
> 
>  >Again, both [<stdio.h> and <cstdio>] are valid.
> 
> I believe that is incorrect*.  In C the header file is <stdio.h>,
> whereas in C++ <cstdio> is the header file.

See D.5/1, table 100 . <stdio.h> is deprecated, but still normative. I
    doubt it will ever be removed, unless C merges with C++, which
    seems unlikely.

Re: inline operator delete redefinition and in-charge deleting destructor

[llewelly]

Christian BRUEL <christian.bruel@st.com> writes:

> I have the following problem with gcc3.3.3 on Solaris:
> 
> If providing the definition of a destructor outside the module where
> "delete" is called, the compiler instantiates a function call to delete
> to the standard library, thus missing my definition.
> 
> See the following program:
> 
> Of course, I comment out the "#include "new"" in ddef.cxx the
> program

'new' is a standard C++ library header. if you re-define it, the
    behavior is undefined.

If you aren't trying to re-implemtn part of the C++ standard library,
    you have no business naming a header file 'new'.

Otherwise, investigate -nostdinc++, see: http://xrl.us/b2qw
[snip]

Re: inline operator delete redefinition and in-charge deleting destructor

[Eljay Love-Jensen]

Hi Christian,

Keep in mind that inlined routines must be visible in all compilation units 
in which they are used.

Sincerely,
--Eljay

Re: inline operator delete redefinition and in-charge deleting destructor

[Christian Bruel]

including "new" in i.h will certainly make the example work (and would 
certainly be of better style), but I would like to know if it is just a 
workaround in order to comply with the new C++ ABI or is it mandatory by the 
langage ? 

The compiler generates implicit calls to "delete", so the programmer is not 
faulty not have included the "delete" definition in ddef.cxx.

The real problem is that I have a very different behavior in case "delete" is 
not inlined (e.g heuristic decided not to), because this way my "delete" 
contribution becomes externally visible, in particular from the 
deleting-destructor. I don't think that "inline" should change the semantic 
of a program when not unspecified.

Would it be possible in order to to fix this behavior that the compiler always 
emits the function body of inlined memory operators, the rational is that the 
compiler might instantiate calls to those and need the contribution ? (To: 
gcc-bugs)

Best Regards and thanks,

--- i.h ---
class MyClass
{
public:
  virtual ~MyClass(void);
};


--- new ---
extern int glob;

inline void operator delete(void *p)
{
  glob++;
}

--- ddef.cxx ---
#include "i.h"

MyClass::~MyClass(void)
{
}

--- foo.cxx ---
#include <stdio.h>
#include "i.h"

// explicit call to delete. include definition
#include "new"

int glob;

main()
{
  MyClass *b = new MyClass;
  delete b;

  if (glob != 1)
    printf ("FAILED %d\n", glob);
  else
    printf ("SUCCESS\n");
}


----- Original Message ----- 
From: "Eljay Love-Jensen" <eljay@adobe.com>
To: "Christian BRUEL" <christian.bruel@st.com>; <gcc-help@gcc.gnu.org>
Sent: Tuesday, May 11, 2004 5:54 PM
Subject: Re: inline operator delete redefinition and in-charge deleting
destructor


> Hi Christian.
>
> You need...
> #include "new"
> ... at the top of your i.h file.
>
> Also, destructors have () parameter specification, not (void) for their
> parameters.
>
> Also, your header files should have guards to make sure they are only
> included once.
>
> Also, C++ uses...
> #include <cstdio>
> ... not...
> #include <stdio.h>
>
> Also, you may want to change the name of your "new" header file to
> "mynew.h" or "mynew.hxx" or "mynew.hpp".  I prefer the first convention.
>
> Style point:  MyClass* b = new MyClass; (the C++ way) is preferable to
> MyClass *b = new MyClass; (the C way).
>
> Style point:  you should put the "extern int glob;" in a header file,
> instead of hard coded.
>
> HTH,
> --Eljay
>
>
>