tableau de chaînes avec le caractère de poubelle à la fin

J'ai un char tableau tampon que j'utilise pour stocker les caractères que l'utilisateur devra saisir un par un. Mon code ci-dessous fonctionne, mais a quelques problèmes que je n'arrive pas à comprendre:

  1. quand j'execute un printf pour voir ce qui est dans la mémoire Tampon, il n'a remplir, mais j'obtiens des caractères illisibles à la fin
  2. de ne pas s'arrêter à 8 caractères en dépit d'être déclaré en tant que char Tampon[8];

Quelqu'un peut-il m'expliquer ce qui se passe et peut-être comment je pourrais résoudre ce problème? Merci.

char Buffer[8]; //holds the byte stream
int i=0;

if (/* user input event has occurred */) 
{
        Buffer[i] = charInput;
        i++;

        //Display a response to input
        printf("Buffer is %s!\n", Buffer);

}

De sortie:

tagBuffer est de 1 â â w! 
tagBuffer est de 12 â w! 
tagBuffer est 123w! 
tagBuffer est 1234! 
tagBuffer est 12345! 
tagBuffer est 123456=! 
tagBuffer est 1234567! 
tagBuffer est 12345678!

tagBuffer est 123456789!

source d'informationauteur Steve | 2008-11-06

  1. 26

    Vous devez mettre fin à la chaîne avec un \0 caractères. C'est pourquoi ils sont appelés à zéro des chaînes terminées.

    Il est également sage d'affecter 1 extra char à tenir le \0.

  2. 8

    La seule chose que vous êtes de passage à la fonction printf() est un pointeur vers le premier caractère de votre chaîne. printf() n'a aucun moyen de connaître la taille de votre tableau. (Il ne sait même pas si c'est un tableau réel, depuis un pointeur est une adresse de mémoire.)

    printf() et toutes les c standard des fonctions de chaîne, à supposer qu'il existe un 0 à la fin de votre chaîne. printf() par exemple gardera l'impression de caractères en mémoire, en commençant par le char que vous passez à la fonction, jusqu'à ce qu'il frappe une 0.

    Par conséquent, vous devez modifier votre code à quelque chose comme ceci:

    char Buffer[9]; //holds the byte stream
int i=0;

if( //user input event has occured ) 
{
        Buffer[i] = charInput;
        i++;

        Buffer[i] = 0; //You can also assign the char '
    char Buffer[9]; //holds the byte stream
int i=0;
if( //user input event has occured ) 
{
Buffer[i] = charInput;
i++;
Buffer[i] = 0; //You can also assign the char '\0' to it to get the same result.
//Display a response to input
printf("Buffer is %s!\n", Buffer);
}
    ' to it to get the same result.    

        //Display a response to input
        printf("Buffer is %s!\n", Buffer);

}
  3. 3

    En plus des observations précédentes, à savoir zéro de la résiliation, vous devez accepter la responsabilité pour ne pas déborder votre propre tampon. Il ne s'arrête pas à 8 caractères parce que votre code n'est pas d'arrêt! Vous avez besoin de quelque chose comme ce qui suit (piggy-backing sur Jeremy est une suggestion):

    #define DATA_LENGTH 8
#define BUFFER_LENGTH (DATA_LENGTH + 1)

char Buffer[BUFFER_LENGTH]; //holds the byte stream
int charPos=0;  //index to next character position to fill

while (charPos <= DATA_LENGTH  ) { //user input event has occured
    Buffer[i] = charInput;

    Buffer[i+1] = '
    #define DATA_LENGTH 8
#define BUFFER_LENGTH (DATA_LENGTH + 1)
char Buffer[BUFFER_LENGTH]; //holds the byte stream
int charPos=0;  //index to next character position to fill
while (charPos <= DATA_LENGTH  ) { //user input event has occured
Buffer[i] = charInput;
Buffer[i+1] = '\0';
//Display a response to input
printf("Buffer is %s!\n", Buffer);
i++; 
}
    '    ;

    //Display a response to input
    printf("Buffer is %s!\n", Buffer);

    i++; 

}

    En d'autres termes, assurez-vous d'arrêter d'accepter des données lorsque la longueur maximale a été atteinte, indépendamment de ce que l'environnement essaie de le pousser à vous.

  4. 0

    Si vous êtes à la programmation en C ou C++, vous devez vous rappeler que:
    1) les cordes sont finis avec un \0 caractères.
    2) C n'a pas de vérification de limites à cordes, ils sont juste des tableaux de caractères.

  5. 0

    C'est bizarre que personne n'a mentionné cette possibilité:

    char Buffer[8]; //holds the byte stream
int i = 0;

while (i < sizeof(Buffer) && (charInput = get_the_users_character()) != EOF)
{
    Buffer[i] = charInput;
    i++;

    //Display a response to input
    printf("Buffer is %.*s!\n", i, Buffer);
}

    Cette notation dans le printf() chaîne de format spécifie la longueur maximale de la chaîne à afficher, et ne nécessite pas de fin null (null si la résiliation est en fin de compte la meilleure façon d'aller, au moins une fois que vous quittez cette boucle).

    La while boucle est plus plausible qu'un simple ifet cette version assure que vous n'avez pas de dépassement de la fin de la mémoire tampon (mais ce n'est pas assurez-vous de laisser suffisamment d'espace pour une fuite NUL '\0'. Si vous souhaitez gérer, utiliser sizeof(Buffer) - 1 puis ajouter le NUL après la boucle.

  6. 0

    Depuis Buffer n'est pas initialisé, il commence avec les 9 ordures valeurs.
    À partir de l'output observé, 2ème, 3ème, 4ème, 5ème, 6ème, 7ème, 8ème et 2 prochain emplacement de mémoire(à l'extérieur de la matrice), les éléments sont clairement 'T', 'T', 'W', '\0', '\0', '=', '\0', '\0', '\0'.

    Chaînes de consommer tous les caractères jusqu'à ce qu'ils voient caractère NULL. C'est pourquoi, à chaque itération, comme les éléments d'un tableau sont affectés à un par un, tampon est imprimé jusqu'à la partie où une poubelle NULL est présent.

    C'est-à-dire, la chaîne a un comportement indéfini si le tableau de caractères ne prend pas fin avec '\0'. Vous pouvez éviter cela en ayant un espace supplémentaire pour '\0' à la fin de la mémoire tampon.

  7. -1

    Vous pouvez aussi rechercher dans l'aide d'une stringstream.