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

 C++ Discussion :

char* et char[]


Sujet :

C++

  1. #1
    Futur Membre du Club
    Profil pro
    Inscrit en
    Février 2009
    Messages
    7
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Février 2009
    Messages : 7
    Points : 5
    Points
    5
    Par défaut char* et char[]
    Je reviens avec une nouvelle question !

    Quelle est la différence au niveau utilisation mémoire (et les éventuels risques) entre :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    void A( const char * fileName )
    {
    	char * fullPath = new char[1024];
    	sprintf( fullPath, “files/%s”, fileName );
     
    	m_Texture = new Texture( fullPath );
     
    	delete[] fullPath;
    }
    et :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    void B( const char * fileName )
    {
    	char fullPath[1024];
    	sprintf( fullPath, “files/%s”, fileName );
     
    	m_Texture = new Texture( fullPath );
    }
    Il me semble qu'il y en a un qui réserve tout l'espace en mémoire dès le départ, et l'autre qui alloue dynamiquement, mais je ne suis plus sûr ?

  2. #2
    Membre éclairé
    Avatar de buggen25
    Ingénieur développement logiciels
    Inscrit en
    Août 2008
    Messages
    554
    Détails du profil
    Informations professionnelles :
    Activité : Ingénieur développement logiciels
    Secteur : Communication - Médias

    Informations forums :
    Inscription : Août 2008
    Messages : 554
    Points : 709
    Points
    709
    Par défaut
    salut;
    char fullPath[1024];
    Pour reserver un tableau de 1024 caractères sur la pile
    char * fullPath = new char[1024];
    Pour reserver 1024 caractères sur le tas (memoire dynamique), le sel risque est que tu ne fasse pas appel au delete[]
    If you type Google into Google, you Can break the internet" - The IT Crowd

  3. #3
    Rédacteur
    Avatar de 3DArchi
    Profil pro
    Inscrit en
    Juin 2008
    Messages
    7 634
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Juin 2008
    Messages : 7 634
    Points : 13 017
    Points
    13 017
    Par défaut
    Je rajouterais qu'en C++, tu utiliserais plutôt une std::string

    Quelques remarques:
    1/ Il est plus probable de saturer la pile (char T[]) que le tas (new char[]),
    2/ Il est plus probable d'oublier le delete si on n'utilise les pointeurs bêtes,
    3/ Une corruption de la pile se verra plus rapidement qu'une corruption du tas,
    4/ Si tu sature la pile, ton plantage sera immédiat,
    5/ alors que tu peux gérer la saturation du tas (gestion de l'échec de l'allocation)

    Après l'un ou l'autre dépend fortement de ce que tu veux faire. Et dans ton cas, l'utilisation d'une std::string sur la pile semble encore la meilleure solution...

  4. #4
    Expert éminent sénior
    Avatar de Médinoc
    Homme Profil pro
    Développeur informatique
    Inscrit en
    Septembre 2005
    Messages
    27 369
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 40
    Localisation : France

    Informations professionnelles :
    Activité : Développeur informatique
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Septembre 2005
    Messages : 27 369
    Points : 41 518
    Points
    41 518
    Par défaut
    On peut ajouter aussi qu'un dépassement de buffer aura causera une faille de sécurité plus évidente sur la pile que qu'un débordement de buffer sur le tas.
    SVP, pas de questions techniques par MP. Surtout si je ne vous ai jamais parlé avant.

    "Aw, come on, who would be so stupid as to insert a cast to make an error go away without actually fixing the error?"
    Apparently everyone.
    -- Raymond Chen.
    Traduction obligatoire: "Oh, voyons, qui serait assez stupide pour mettre un cast pour faire disparaitre un message d'erreur sans vraiment corriger l'erreur?" - Apparemment, tout le monde. -- Raymond Chen.

  5. #5
    Membre émérite

    Inscrit en
    Mai 2008
    Messages
    1 014
    Détails du profil
    Informations forums :
    Inscription : Mai 2008
    Messages : 1 014
    Points : 2 252
    Points
    2 252
    Par défaut
    Traduit en code cela donne :
    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
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
     
    {
       // tableau statique
       char array[50]; // Alloue 50 char dans la pile
    } // Le tableau est entièrement détruit en sortant de la portée. 
    // C'est possible car le compilateur connait la taille du tableau à la compilation
     
    {
       int size;
       cin >> size;
       // char array[size]; // erreur, la taille doit être connue à la compilation
    }
     
    {
       int size;
       cin >> size;
       // tableau dynamique
       char* array = new char[size] // ok, on réserve un bloc de mémoire dans le tas de taille size. 
    //Personne ne peut plus écrire dedans sauf en utilisant le pointeur.
       delete[] array; // on libère la mémoire. 
    // A partir de maintenant le sytème considère que le bloc est disponible à nouveau.
     
    } // le pointeur array est détruit en sortant de la portée
     
    {
       int size;
       cin >> size;
       char* array = new char[size];
    } /* vlan fuite mémoire. 
    Le bloc de mémoire alloué dans le tas n'a pas été libéré 
    et le pointeur n'est plus accessible car détruit en sortant de la portée. 
    Le bloc sera locké jusqu'à la fin du programme. */
     
    {
       int size;
       cin >> size;
       std::shared_ptr<char> array(new char[size]); // smart pointer.
    // De plus en plus souvent disponible sur les compilateurs récents. 
    } // pas de fuite mémoire. En sortant de la portée le shared_ptr 
    // est détruit et désalloue automatiquement la mémoire à notre place.

Discussions similaires

  1. pb conversion unsigned char vers char *
    Par FamiDoo dans le forum C
    Réponses: 11
    Dernier message: 24/08/2006, 19h11
  2. Comparer 2 Char / Convertir Char -> Int
    Par mbk-w dans le forum Général JavaScript
    Réponses: 3
    Dernier message: 09/06/2006, 12h09
  3. unsigned char* to char*
    Par xela2000 dans le forum MFC
    Réponses: 4
    Dernier message: 20/11/2005, 17h07
  4. conversion char wide char
    Par ep31 dans le forum MFC
    Réponses: 4
    Dernier message: 15/11/2005, 09h14
  5. Pb Invalid Conversion "char" to "char*"
    Par kazarn dans le forum C++
    Réponses: 3
    Dernier message: 02/03/2005, 14h24

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