Programmation en C d'impression tableau de caractères

J'ai un tableau de caractères déclaré:

char *array[size];

Lorsque j'effectue une

printf("%s", array);

il me donne des caractères binaires, pourquoi il en est ainsi?

http://www.cplusplus.com/reference/clibrary/cstdio/printf/

Cette url indique printf prend dans le format: int printf ( const char * format, ... );

#include <stdio.h>
#include <string.h>
#define size 20
#define buff 100
char line[buff];

int main ()
{
    char *array[100];
    char *sep = " \t\n";

    fgets(line, buff, stdin);

    int i;

    array[0] = strtok(line, sep);

    for (i = 1; i < size; i++) {
        array[i] = strtok(NULL, sep);

        if (array[i] == NULL)
            break;
    }

    return 0;
}

C'est un tableau de pointeurs, pas de caractères.

InformationsquelleAutor ilovetolearn | 2011-10-23

c cstring

3

Votre tableau n'est pas initialisé, et aussi que vous avez un tableau de pointeurs, au lieu d'un tableau de char. Il devrait être char* array = (char*)malloc(sizeof(char)*size);, si vous voulez un tableau de char. Maintenant, vous avez un pointeur vers le premier élément du tableau.
- new n'est pas un opérateur dans C
InformationsquelleAutor Tony The Lion
6

Vous déclarez un tableau de caractères comme suit:
```
char foo[size];
```
Vous semblez avoir tout mélangé avec char *, qui est un pointeur sur un caractère. On pourrait dire
```
char *bar = foo;
```
qui ferait bar point sur le contenu de foo. (Ou, en fait, le premier caractère de foo.)

Pour ensuite imprimer le contenu du tableau, vous pouvez effectuer l'une des opérations suivantes:
```
//either print directly from foo:
printf("%s", foo);
//or print through bar:
printf("%s", bar);
```
Noter, cependant, que C n'effectue aucune initialisation du contenu des variables, de sorte que si vous définissez le contenu de quelque chose, vous obtiendrez des ordures. En outre, si cette poubelle n'arrive pas à contenir un \0; c'est un char avec la valeur 0, cela permettra de tenir sur la sortie après la fin du tableau.
- &foo est de type char(*)[size]: il n'est pas vraiment compatible avec char*, le type de bar. Vous dire: char *bar = foo;
- Ça m'apprendra à ne pas écrire du code C sans le tester. Corrigé, merci. 🙂
InformationsquelleAutor Sebastian Paaske Tørholm
4

Pourquoi faisons-nous une chose toute simple son de si difficile?
```
char array[SIZE];
... /* initialize array */
puts(array);   /* prints the string/char array and a new line */
/* OR */
printf("%s", array); /* prints the string as is, without a new line */
```
La char dans tableau après la fin de ce que vous souhaitez pour votre chaîne (c'est à dire. si vous voulez que votre chaîne à lire "Bonjour", ce qui pourrait être le prochain char après le "o") doit être appelé à disparaître caractère NUL '\0'. Si vous utilisez une fonction C pour lire l'entrée qui sera automatiquement ajouté à la fin de votre tampon. Vous n'aurez qu'à vous soucier de le faire manuellement si vous avez été individuellement l'écriture des caractères à votre tampon ou quelque chose pour une raison quelconque.

EDIT: Comme avec pmg commentaire, le '\0' accompagne partout où vous voulez le chaîne à la fin, donc si vous voulez réduire votre chaîne, vous pourriez juste le déplacer plus près de l'avant, soit à une chaîne vide vous avez juste array[0] = '\0';. Cela peut également être utilisé pour tokenise petites chaînes de caractères dans un tampon unique, tout comme strtok n'. c'est à dire. "Part1\0Part2\0Part3\0". Mais je pense que c'est s'éloigner de la portée de la question.

ie. vous avez voulu pour stocker les 3 premiers caractères de l'alphabet comme une chaîne de caractères (je ne sais pas pourquoi quelqu'un voudrait faire de cette façon, mais c'est juste un exemple):
```
char array[4];
array[0] = 'a';
array[1] = 'b';
array[2] = 'c';
array[3] = 'char array[4];
array[0] = 'a';
array[1] = 'b';
array[2] = 'c';
array[3] = '\0';
printf("%s\n", array);
';
printf("%s\n", array);
```
Si vous avez quelque chose comme char array[] = "Hello"; le '\0' est ajouté automatiquement pour vous.
- -1: printf(array) ne pas "imprimer la chaîne comme est". C' interprète la chaîne provoquant un Comportement indéterminé il contient toutes les spécifications de conversion. Utilisation printf("%s", array) à la place.
- oups my bad, c+p le met(array) et il a changé à printf. C'était une assez mauvaise échouer, sujettes à la chaîne de format exploits trop.
- Juste révoqué le -1. Maintenant, il y a juste un point de détail dans votre réponse: la terminaison zéro n'a pas besoin d'être le dernier char dans le tableau. C'est parfaitement valide (bien qu'inutile): char foo[7] = "foo\0bar"; --- foo[6] est 'r'; puts(foo); sorties "foo\n"
- Ouais je pense que je n'ai pas la structure de ce que je disais très bien, permettez-moi de résoudre ce problème. Des acclamations.
InformationsquelleAutor AusCBloke
0
```
char *array[size];
```
array n'est pas un char * avec qui, il est de plus en plus comme un char ** (pointeur vers un tableau de caractères, avec est similaire à pointeur de pointeur de char).

Si vous avez besoin d'une chaîne C, soit:
```
char array[size];
```
et assurez-vous de 0-de le terminer correctement, ou
```
char *array;
```
et assurez-vous de bien répartir et de stockage gratuit pour elle (et 0 à la fin de trop).
- qu'entendez-vous par zéro de résilier le pointeur de tableau de caractères
- Chaînes de caractères en C sont juste un tableau de char valeurs. La fin de la chaîne est signifié par un char avec la valeur 0.
- En C, les chaînes de caractères doivent être null, donc le dernier caractère doit être un '\0' (un char de la valeur 0)
- il n'y a aucun moyen que je peux utiliser printf pour imprimer le tableau, sauf pour la lecture en boucle le tableau et vérifier la valeur NULL ?
- Ce n'est pas ça du tout. printf fera que si vous lui passez un char* et l'utilisation de la %s spécificateur de format. MAIS si votre chaîne ne prend pas fin avec un 0 (ce n'est pas un pointeur, c'est un char), il va aller sur et imprimer tout ce qui est stocké dans la mémoire après votre chaîne, provoquant un comportement indéfini.
- J'ai imprimé le char *tableau[taille] par met(*tableau) il n'imprimer 1 mot... pouvez-vous expliquer comment fonctionne l'imprimerie?
- Pas sans voir votre code. Je ne peux pas deviner ce tableau est initialisé à, et la manipulation des chaînes est couvert de centaines de livres et des tutoriels qui sont faciles à trouver.
- Je ne comprends pas les exemples donnés en ligne. Il est très simple tableau d'accéder à des exemples.
- Ensuite, ramasser un C livre, ou de trouver d'autres exemples en ligne. C'est de base C.
InformationsquelleAutor Mat

Vous devez vous connecter pour publier un commentaire.