Re: friend 'operator new' in inheritance as a template
On Jun 14, 9:36 pm, Paavo Helde <nob...@ebi.ee> wrote:
"wo3...@gmail.com" <wo3...@gmail.com> kirjutas:
#include <iostream>
#include <map>
#include <utility>
//
// Base
// / | \
// Derived1 Derived2 \
// \ | /
// Derived3
//
template< typename _T >
struct Base {
friend void * operator new ( size_t _size ){
std::cout << typeid( _T ).name() << std::endl;
As far as I understand, operator new cannot be a template, and
a friend declaration does not make it into a template
automatically anyway, so the _T symbol should not be visible
inside the function. If the compiler still compiles this, I
think this is a compiler bug.
The whole thing is fishy. This basically says that 1) the
global operator new is a friend of Base, and 2) provides an
implementation of the global operator new. Which is, I guess,
legal. Once... because this is a template, it's going to
provide a new implementation of the global operator new each
time the template is instantiated. Which is a violation of the
one definition rule, and so undefined behavior. (Since the
function is defined *in* the template, I'm pretty sure that the
use of _T is legal.)
There's also the problem that because the function is defined in
a class definition, it is inline; the global operator new
function is not allowed to be inline (for the obvious reason
that it's likely to have been used in some library code
somewhere, and that code won't see your inline definition).
Which creates a couple of additional problems: if malloc fails,
his operator new is going to return a null pointer, rather than
raising a bad_alloc exception. And he hasn't provided a
corresponding operator delete (and of course, he has no idea as
to how the standard operator delete will try to free the
memory).
}
};
struct Derived1 : Base< Derived1 > {
};
struct Derived2 : Base< Derived2 >{
};
struct Derived3 : Derived1, Derived2, Base< Derived3 >{
};
Note that the code doesn't correspond to the diagram in comments
at the top.
int main(){
Derived1 * d1 = new Derived1; // prints 8Derived3
Derived2 * d2 = new Derived2; // prints 8Derived3
}
You have provided illegal source to the compiler; the results
can be whatever. I am not sure if the compiler is obliged to
produce a diagnostic; I suspect it is. Maybe you should file a
bug report to the compiler provider.
It's undefined behavior, but I can guess what is happening.
He's instantiated the template three times, which provides three
different implementations of the global operator new. The
compiler just happened to use the last one it saw.
--
James Kanze (GABI Software) email:james.kanze@gmail.com
Conseils en informatique orient=E9e objet/
Beratung in objektorientierter Datenverarbeitung
9 place S=E9mard, 78210 St.-Cyr-l'=C9cole, France, +33 (0)1 30 23 00 34