Bad Pointer? - C++

Question

J'écris un programme de tokenisation de chaînes de caractères pour une affectation de devoirs en C++, qui utilise des pointeurs. Cependant, quand je lance & le déboguer, il indique que mon pointeur pStart, est invalide. J'ai le sentiment que mon problème réside dans mon constructeur param'ed, j'ai inclus le constructeur et la création d'objet ci-dessous.

J'apprécierais que vous me disiez pourquoi on dit que pStart est un mauvais pointeur quand je le débogue.

Merci!

StringTokenizer::StringTokenizer(char* pArray, char d) 
{ 
pStart = pArray; 
delim = d; 
} 

// create a tokenizer object, pass in the char array 
// and a space character for the delimiter 
StringTokenizer tk("A test char array", ' '); 

stringtokenizer.cpp complète:

#include "stringtokenizer.h" 
#include <iostream> 
using namespace std; 

StringTokenizer::StringTokenizer(void) 
{ 
pStart = NULL; 
delim = 'n'; 
} 

StringTokenizer::StringTokenizer(const char* pArray, char d) 
{ 
pStart = pArray; 
delim = d; 
} 

char* StringTokenizer::Next(void) 
{ 
char* pNextWord = NULL; 

while (pStart != NULL) 
{ 
    if (*pStart == delim) 
    { 
     *pStart = '\0'; 
     pStart++; 
     pNextWord = pStart; 

     return pNextWord; 
    } 
    else 
    { 
     pStart++; 
    } 
} 
    return pNextWord; 
} 

La fonction est ensuite censé arriver pour retourner un pointeur sur le mot suivant dans le tableau de caractères. Ce n'est pas fini pour le moment. :)

stringtokenizer.h complète:

#pragma once 

class StringTokenizer 
{ 
public: 
StringTokenizer(void); 
StringTokenizer(const char*, char); 
char* Next(void); 
~StringTokenizer(void); 
private: 
char* pStart; 
char delim; 
}; 

main.cpp complète:

const int CHAR_ARRAY_CAPACITY = 128; 
const int CHAR_ARRAY_CAPCITY_MINUS_ONE = 127; 

// create a place to hold the user's input 
// and a char pointer to use with the next() function 
char words[CHAR_ARRAY_CAPACITY]; 
char* nextWord; 

cout << "\nString Tokenizer Project"; 
cout << "\nyour name\n\n"; 
cout << "Enter in a short string of words:"; 
cin.getline (words, CHAR_ARRAY_CAPCITY_MINUS_ONE); 

// create a tokenizer object, pass in the char array 
// and a space character for the delimiter 
StringTokenizer tk(words, ' '); 

// this loop will display the tokens 
while ((nextWord = tk.Next ()) != NULL) 
{ 
    cout << nextWord << endl; 
} 


system("PAUSE"); 
return 0; 

Answer 1

Modifiez pStart dans la classe StringTokenizer de char * à const char * et apportez la même modification au constructeur.

Answer 2

changement

StringTokenizer::StringTokenizer(char* pArray, char d) 

à

StringTokenizer::StringTokenizer(const char * pArray, char d) 

Un littéral de chaîne est toujours une variable const char * const, et puisque C++ convertit automatiquement un const non const, il ne peut pas convertir un const en non const.

Vous pouvez également créer différents constructeurs, mais je ne pense pas que vous en aurez besoin, du moment que vous venez de lire la chaîne pArray.

Vous pouvez utiliser quelque chose comme ceci:

TokenList& StringTokenizer::StringTokenizer(const char* pArray, char d){ 
    TokenList lst(); 
    size_t i=0; 
    char buffer[100]; //hardcoded limit, just an example, you should make it grow dinamically, or just use a std::string 
    while((*pArray)){ 
    if(*pArray == d){ 
     buffer[i] = 0; //string ending character, 0 = '\0'; 
     lst.add(buffer); 
     i=0; 
    } 
    pArray++; 
    } 
    //Last token in the input string won't be ended by the separator, but with a '\0'. 
    buffer[i] = 0; 
    lst.add(buffer); 

    return lst; 
} 

Answer 3

Vous ne pouvez pas modifier pStart dans votre tokenizer, parce qu'une chaîne littérale en C et C++ est non modifiable, il a un type const char *. Lorsque vous faites l'affectation

pStart = pArray; 

dans votre constructeur, pStart est maintenant pointant vers une mémoire non modifiable. Très probablement c'est votre problème. Vous devrez poster plus de code si ce n'est pas le cas.

Édition: Après avoir regardé votre modification, vous semblez avoir modifié votre code pour utiliser un tableau. C'est bon. Je ne l'ai pas regardé votre code dans trop de détails, mais il y a au moins une erreur:

while (pStart != NULL) 

devrait être:

while (pStart != NULL && *pStart) 

Ceci est parce que vous voulez arrêter votre boucle quand vous frappez la terminaison '\0' dans votre chaîne. Je ne vois pas pourquoi vous utilisez des chaînes de style C en C++. Est-ce une exigence dans vos devoirs?

Answer 4

À mon avis, vous devez changer le constructeur et destructor de StringTokenizer:

StringTokenizer::StringTokenizer(char* pArray, char d) 
{ 
    pStart = str = strdup(pArray); 
    delim = d; 
} 

StringTokenizer::~StringTokenizer(char* pArray, char d) 
{ 
    free(str); 
} 

Maintenant, vous pouvez utiliser PSTART dans la façon dont vous utilisez: modifier la chaîne, mettre des zéros pour marquer des mots, etc. Vous avez seulement besoin d'ajouter un attribut privé "char * str" à StringTokenizer.

L'astuce ici est que vous créez votre propre copie de la chaîne, ainsi vous pouvez manipuler comme vous voulez, à condition de le libérer dans le destructeur. Le seul inconvénient est que vous avez besoin de mémoire pour stocker la copie (donc vous avez besoin de deux fois la mémoire pour chaque chaîne).

La raison pour laquelle votre solution n'a pas fonctionné est que les littéraux sont ou peuvent être stockés dans la mémoire morte, ils sont donc correctement marqués comme const char *, étant "impossible" d'y écrire.