La corruption de segment, tout en libérant de la mémoire

J'ai une classe comme suit

 struct CliHandler {
     CliHandler(int argc, char** argv);
     ~CliHandler();

     int doWork();

     int argc_; 
     char** argv_;  
     private:
     CliHandler(const CliHandler&){}
     CliHandler& operator=(const CliHandler&){} 
 };

//Constructeur

 CliHandler::CliHandler(int argc,
 char** argv) {
     //set command line parameters
     argc_ = argc; 

     argv_ = (char**) malloc(argc_ * sizeof(char*));

     for(int i=0; i<argc_; ++i)
     {
         std::cout<<sizeof(argv[i]); 
         argv_[i] = (char*) malloc(strlen(argv[i]) *
 sizeof(char));
         StrCpy(argv_[i], argv[i]);
     } }

//destructeur

 CliHandler::~CliHandler() {
     for(int i=0; i<argc_; ++i)
         free(argv_[i]); 
     free(argv_);  }

Alors que je debug, j'obtiens une erreur " corruption de Segment détecté. Le CRT a détecté que l'application a écrit à la mémoire après la fin de segment de mémoire tampon. "Ma question id "exactement Où suis-je fait une erreur ? Comment puis-je résoudre ce problème". Je suis à l'aide de visual stdio 2008.

Edit:j'ai fait quelque chose de ce genre pour ajouter 1

argv_[i] = (char*)
malloc(strlen(argv[i] + 1) *
sizeof(char));

Qui est terrible, comme il incrémente le pointeur de la argv[i] par un. Mon collègue a souligné que la subtile question. Il devrait être

argv_[i] = (char*)
malloc( (strlen(argv[i]) + 1) *
sizeof(char));

Une chose que je vois est que vous n'avez pas à allouer de l'espace pour les nuls-terminator. Devrait être strlen(argv[i]) + 1.
Pourquoi, si vous êtes à l'aide de C++, êtes-vous à l'aide de malloc? Et pourquoi n'êtes-vous pas en utilisant std:;vecteur et std::string?
Un autre problème que je vois est que vous ne suivez pas les Règle de Trois. Si la copie se passe, vous êtes en difficulté.
je suis l'intégration de certaines fonctions avec le code existant.
Et alors? Les choses que vous allouer pour le privé, donc ils ne peuvent pas être utilisés directement par l'héritage de code, de sorte que vous pouvez (et devez) mettre en œuvre à l'aide de vecteurs et de cordes. Sinon, vous êtes tout simplement écrire PLUS de code legacy.

OriginalL'auteur Eternal Learner | 2011-05-09

  1. 8

    Modifier le code pour:

     argv_[i] = (char*) malloc(strlen(argv[i]) + 1) ; 
 strcpy(argv_[i], argv[i]);

    C'est parce que votre StrCpy probablement des ordures de votre mémoire. Vous avez pour tenir compte de la résiliation octet nul, à condition que votre StrCpy fonctionne comme la norme de la fonction strcpy (qui elle doit, pour être utile, mieux d'utiliser seulement la norme de la fonction strcpy (), sauf si vous avez une bonne raison de ne pas).

    sizeof(char) est, par définition, 1, de sorte que peut être omis.

    OriginalL'auteur nos

  2. 1

    Vous devez attribuer un caractère de plus que la strlen d'un C-string si vous voulez le copier. C'est parce que strlen ne compte pas la terminaison null caractères.

    OriginalL'auteur Mikael Persson

  3. 1

    Veuillez utiliser strdup() - il alloue la quantité de mémoire et des copies de personnages pour vous.

    S'il vous plaît, ne faites pas cela.
    Pourquoi ne pas le faire?
    Non-standard, impossible de dire combien de désallouer, std::string est une bien meilleure façon de faire les choses .....
    il fait partie de la norme Posix, et vous libérer avec free(). Convenu que std::string est la bonne façon de le faire.
    Le gars est explicitement à l'aide de chaînes de style C ici. Si c'est ce qu'il veut, strdup() c'est bien. C'est dans la bibliothèque C standard.

    OriginalL'auteur Arkadiy

  4. 0

    Si StrCpy est quelque chose comme strcpy, il va écrire un octet de plus de strlen() retourne à zéro mettre fin à la chaîne.

    En résumant, il doit ajouter de l'espace pour l'octet supplémentaire sur la 2ème malloc()

    OriginalL'auteur Bo Persson