operateur new et namespace

Version imprimable

Code:

1
2
3
4
5
6
7
8
9
10
class A {};
 
namespace test {
    void* operator new(size_t size, char* c) throw (std::bad_alloc) { return malloc(size); }
}
 
int main() {
   A* a = test::new ("test") A; //Ne veux pas compiler!
   return 0;
}

Alors que:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
class A {};
 
namespace test {
    void* operator new(size_t size, char* c) throw (std::bad_alloc) { return malloc(size); }
}
 
using namespace test;
 
int main() {
   A* a = new ("test") A; //Compile! Oo
   return 0;
}

La question est: ... pourquoi? :aie:

24/06/2008, 01h39
JolyLoic

Sous réserve d'erreur, c'est un domaine que je ne connais pas assez bien à mon goût.

Quand tu écris :

Code:

A* a = new A;

Bien qu'on puisse croire le contraire, tu n'appelle pas l'opérateur new directement, ce n'est pas un appel de fonction. Tu fais juste une "new-expression". Donc ce new n'a pas à être préfixé d'un namespace.

A l'intérieur de l'exécution d'une new-expression, le compilateur va chercher à trouver une "allocation function" (c'est ça que tu a écris quand tu as surchargé l'opérateur new) qui convienne. Il a deux manières de chercher, selon que tu a écrit ta new-expression new ou ::new (rien devant les ::, ca ne veut rien dire) :

Citation:

If the newexpression begins with a unary :: operator, the allocation function’s name is looked up in the global scope. Otherwise, if the allocated type is a class type T or array thereof, the allocation function’s name is looked up in the scope of T. If this lookup fails to find the name, or if the allocated type is not a class type, the allocation function’s name is looked up in the global scope.

Effectivement après recherche il se trouve que l'opérateur new ne peux etre défini que de manière global ou dans une classe (surcharge), et non dans un namespace (ou en static dans une classe)...

Le fait de l'écrire dans le namespace ne change pas sa portée globale dans ce cas, en fait meme en désactivant "using namespace test;" j'arrive à compiler.

Pour l'opérateur new, il alloue la memoire puis construit l'objet. On peu appeller le constructeur d'un objet sans allouer à nouveau la mémoire avec le placement new:
Code:

1 2 3 4 5 6 //Dummy code! char* myChar[sizeof(A)]; //Un tableau de bytes A* obj = new ((void*)myChar) A; //Initialisation de A dans myChar :D //par contre il faut appeler le destructeur explicitement car la mémoire est allouée statiquement: obj->~A();