Solutionnaire du minitest sur new et delete

La consigne était :

Ce qui suit est un solutionnaire possible, accompagné de brèves discussions. Le tout n'est pas exhaustif.

Option A

Une solution simple (pour vous, du moins), basée sur ce que nous avons vu en classe avec l'exemple de détecteur de fuites, serait :

void *operator new(std::size_t n) {
   auto p = std::malloc(n + sizeof(std::max_align_t));
   if(!p) throw std::bad_alloc{};
   new (p) std::size_t{ n };
   auto q = static_cast<char *>(p);
   std::uninitialized_fill(q + sizeof n, q + sizeof(std::max_align_t) + n, 0x00);
   return p;
}
void operator delete(void *p) {
   if(!p) return;
   p = static_cast<std::max_align_t*>(p) - 1;
   auto n = *static_cast<std::size_t*>(p);
   auto q = static_cast<char *>(p);
   std::uninitialized_fill(q, q + sizeof(std::max_align_t) + n, 0xff);
   free(p);
}

À noter :

• À la ligne , nous allouons un peu plus que ce que le code client demande dans le but de « cacher » la valeur de n pour être en mesure de la récupérer lors du delete correspondant (ligne ). Nous tenons compte des restrictions associées à l'alignement naturel des objets
• À la ligne , nous levons une exception (de type std::bad_alloc) si std::malloc() signale ne pas être parvenue à réaliser l'allocation demandée
• À la ligne ,
nous entreposons la valeur de n avant la zone qui sera retournée. Notez le recours à un new positionnel (Placement new) et non pas à une affectation, faute d'avoir un objet à gauche d'une affectation (en effet, nous opérons sur de la mémoire brute ici)
• Pour le reste, j'ai utilisé std::uninitialized_fill() pour remplir la zone de mémoire avec la valeur sentinelle demandée, tout en prenant soin de ne pas écraser la taille au passage
• Les opérations dans operator delete font un travail symétrique à celui d'operator new, à ceci près que j'ai choisi d'écrire par-dessus la taille avec des 0xff

Il est possible de faire plus simple si on utilise la déclinaison d'operator delete qui, depuis C++ 14, accepte un std::size_t (le nombre de bytes à lié au new correpondant), car cela nous permet de faire l'économie du jeu de cachette de n :

void *operator new(std::size_t n) {
   auto p = std::malloc(n);
   if(!p) throw std::bad_alloc{};
   auto q = static_cast<char *>(p);
   std::uninitialized_fill(q, q + n, 0x00);
   return p;
}
void operator delete(void *p, std::size_t n) { // Ok depuis C++14
   if(!p) return;
   auto q = static_cast<char *>(p);
   std::uninitialized_fill(q, q + n, 0xff);
   free(p);
}

Remarque importante : écrire des valeurs dans la mémoire après l'appel à free() sera probablement un no-op en pratique avec les compilateurs contemporains. En effet, les compilateurs sont très (trop?) intelligents et, voyant l'appel à free() suivant l'écriture, peuvent considérer l'écriture comme du Dead Code et la supprimer.

Option B

En pratique, l'option B est un peu plus simple à implémenter que l'option A, du moins si on se limite à C++ 11 et avant (l'option A se fait aisément avec C++ 14). La raison est qu'il n'est pas nécessaire de retenir la taille du bloc alloué lors du new pour implémenter le delete. Par contre, il faut placer le 0xdeadc0de de fin en tenant compte de l'alignement (je tends à être gentil quand je corrige cela).

Ça donne quelque chose comme :

void *operator new(std::size_t n) {
   // n bytes de données; 0xdeadc0de au début, mais il faut allouer sizeof(std::max_align_t)
   // bytes pour que les données respectent le pire alignement naturel possible
   void *p = std::malloc(sizeof(std::max_align_t) + n + sizeof(unsigned int));
   new (p) unsigned int{ 0xdeadc0de };
   new (static_cast<char*>(p) + sizeof(std::max_align_t) + n) unsigned int{ 0xdeadc0de };
   return static_cast<std::max_align_t*>(p) + 1;
}
void operator delete(void *p) {
   if(!p) return;
   std::free(static_cast<std::max_align_t*>(p) - 1); // note : free(nullptr) est un no-op
}

Si nous souhaitons être plus rigoureuse / rigoureux avec le positionnement du 0xdeadc0de final, nous avons :

void *operator new(std::size_t n) {
   // n bytes de données; 0xdeadc0de au début, mais il faut allouer sizeof(std::max_align_t)
   // bytes pour que les données respectent le pire alignement naturel possible; à la fin,
   // il faut s'assurer que le 0xdeadc0de soit bien aligné aussi si on veut être rigoureuse ou
   // rigoureux
   const auto delta = (sizeof(std::max_align_t) - n % sizeof(std::max_align_t)) % sizeof(std::max_align_t);
   void *p = std::malloc(sizeof(std::max_align_t) + n + delta + sizeof(unsigned int));
   new (p) unsigned int{ 0xdeadc0de };
   new (static_cast<char*>(p) + sizeof(std::max_align_t) + n + delta) unsigned int{ 0xdeadc0de };
   return static_cast<std::max_align_t*>(p) + 1;
}
void operator delete(void *p) {
   if(!p) return;
   std::free(static_cast<std::max_align_t*>(p) - 1); // note : free(nullptr) est un no-op
}