IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Langage C++ Discussion :

opérateur new et delete, je comprends pas


Sujet :

Langage C++

Vue hybride

Message précédent Message précédent   Message suivant Message suivant
  1. #1
    Membre expérimenté
    Homme Profil pro
    Enseignant
    Inscrit en
    Mars 2012
    Messages
    164
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Belgique

    Informations professionnelles :
    Activité : Enseignant
    Secteur : Enseignement

    Informations forums :
    Inscription : Mars 2012
    Messages : 164
    Par défaut opérateur new et delete, je comprends pas
    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!

  2. #2
    Membre émérite

    Profil pro
    Inscrit en
    Décembre 2008
    Messages
    533
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Décembre 2008
    Messages : 533
    Par défaut
    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é.

  3. #3
    Rédacteur/Modérateur


    Homme Profil pro
    Network game programmer
    Inscrit en
    Juin 2010
    Messages
    7 147
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 38
    Localisation : Canada

    Informations professionnelles :
    Activité : Network game programmer

    Informations forums :
    Inscription : Juin 2010
    Messages : 7 147
    Billets dans le blog
    4
    Par défaut
    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.
    Pensez à consulter la FAQ ou les cours et tutoriels de la section C++.
    Un peu de programmation réseau ?
    Aucune aide via MP ne sera dispensée. Merci d'utiliser les forums prévus à cet effet.

  4. #4
    Membre expérimenté
    Homme Profil pro
    Enseignant
    Inscrit en
    Mars 2012
    Messages
    164
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Belgique

    Informations professionnelles :
    Activité : Enseignant
    Secteur : Enseignement

    Informations forums :
    Inscription : Mars 2012
    Messages : 164
    Par défaut
    merci pour vos réponse éclairantes.

  5. #5
    Membre Expert

    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Août 2004
    Messages
    1 391
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 35
    Localisation : France, Doubs (Franche Comté)

    Informations professionnelles :
    Activité : Ingénieur développement logiciels

    Informations forums :
    Inscription : Août 2004
    Messages : 1 391
    Par défaut
    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.

+ Répondre à la discussion
Cette discussion est résolue.

Discussions similaires

  1. opérateurs new et delete sous gcc, je comprends pas.
    Par Guyt54 dans le forum Embarqué
    Réponses: 5
    Dernier message: 07/08/2012, 17h56
  2. Surcharge de l'opérateur new
    Par :Bronsky: dans le forum C++
    Réponses: 17
    Dernier message: 27/10/2010, 21h33
  3. Redéfinition opérateurs new et delete globaux
    Par bolhrak dans le forum C++
    Réponses: 8
    Dernier message: 30/07/2007, 11h34
  4. sql ne comprend pas mon where!et me demande des parametres
    Par marie10 dans le forum Langage SQL
    Réponses: 10
    Dernier message: 20/04/2004, 11h08
  5. [Rave] un message que je ne comprends pas
    Par Clotilde dans le forum Rave
    Réponses: 2
    Dernier message: 30/09/2003, 21h46

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo