Bonjour,

J'ai déjà posé la question ici , mais comme j'ai toujours pas de réponses, je tente ma chance ici.

À ma grande surprise, on peut (re)définir les opérateurs new et delete de la façon suivante:

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
#include <stdlib.h>
 
void * operator new(size_t size)
{
  return malloc(size);
}
 
void * operator new[](size_t size)
{
  return malloc(size);
}
 
void operator delete(void * ptr)
{
  free(ptr);
}
 
void operator delete[](void * ptr)
{
  free(ptr);
}
Ce qui m'étonne, c'est que ça fonctionne! par exemple:
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
 class TY
{
  public:
  TY(int aVal) ;
 
  private:
  int val ;
};
 
TY::TY(int aVal)
{
  val = aVal ;
}
 
void foo(void)
{
  int* x = new int ; 
  char* T = new char[10] ;
  TY* y = new TY(2) ;
}
Ce qui me dépasse, c'est que l'opérateur new s'attend à recevoir un paramètre de type size_t . De ma compréhension des choses, un "size_t", c'est essentiellement un unsigned int .

Or, pour l'avoir testé, l'opérateur s'attend à recevoir un type, et non pas un "unsigned int". Un peu comme si le compilateur disait "l'opérateur new veut un "unsigned int", il me donne un type, je fais donc implicitement un sizeof du type. Mais c'est pas exactement ça qui se passe, parce que le code qui suit ne passe pas à la compilation:

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
 
void test(size_t size)
{
}
 
void foo(void)
{
  test(10) ; // ok
  test(int) ; // erreur
}
Par contre:
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
 
  int* x = new 10 ; // erreur
  int* y = new int ; // ok
Vous pouvez m'éclairer?

Merci!