Discussion :

[Guyt54]

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!

[cob59]

Même s'il l'allocation elle-même peut être redéfinie "naïvement", l'opérator new a quand même une syntaxe particulière qui interdit d'omettre un type :
http://en.cppreference.com/w/cpp/language/new

Et je crois qu'il y a effectivement des sizeof implicites qui sont faits pour traduire en size_t la taille d'un type donné.

[Bousk]

Par contre je ne comprends pas à quoi tu t'attendais avec tes 2 "tests".

Ta fonction attend n size_t (un unsigned int plus ou moins comme tu le dis), alors c'est tout à fait normal qu'elle plante à la 2° ligne.
De même quand tu crées un pointeur sur int, il faut allouer un int, allouer un 10 n'a pas de sens.


La surcharge des opérateurs new/delete peut être pratique en cas de debug par exemple, tu peux tracker les (dés)allocations et voir les fuites de mémoire.

[Guyt54]

merci pour vos réponse éclairantes.

[Flob90]

Il faut bien distinguer l'opérateur new et la syntaxe de création d'objets dynamiques.

L'opérateur new c'est un opérateur comme les autres, donc une fonction. Tu peux tester si tu veux, fait un appel du genre ::operator new(n); là n devra être un size_t.

La syntaxe c'est l'ensemble des règles qui définissent ce que doit faire le compilateur quand il rencontre une certaine expression (new T, cf la grammaire dans la norme pour toutes les syntaxes possibles). Pour faire simple cette syntaxe conduit à 2 étapes :

1. Allocation d'un espace mémoire via une fonction d'allocation : operator new.
2. Initialisation de l'espace mémoire via les règles d'initialisation "classique".

Le reste des mécanismes est en accord avec ceux des fonctions et des types :

• Recherche de la fonction d'allocation via les règles usuels (c'est ici que rentre en jeu le besoin d'un type pour utiliser la syntaxe new).
• Initialisation de l'objet selon l'initialiseur et sa forme.