si la capacité maximale du caractère est de 256 comment stocker le tableau de caractères de 1000?

Question

Si la capacité maximale du caractère est de 256 comment stocker tableau de caractères de 1000? est-il possible de déclarer: char s [1000];

Answer 1

Oui, c'est certainement possible.

char s[1000]; 

Vous pouvez penser à 1000 comme la « longueur » du tableau et 256 comme « largeur ». Vous obtenez un tableau de 1000 char s. Chaque char est 8 bits (sur la machine que vous utilisez, au moins), et peut donc stocker 256 valeurs distinctes. (Et, en fait, il serait probablement plus approprié de penser à la « largeur » comme étant 8, et non 256.)

Voici votre tableau, chaque boîte représentant un char:

+---+---+---+---+---+---+---+---+- -+---+ 
s: | | | | | | | | | ... | | 
    +---+---+---+---+---+---+---+---+- -+---+ 
    0 1 2 3 4 5 6 7  999 

Ou ici, il montre les bits individuels:

+---+---+---+---+---+---+---+---+- -+---+ 
s: | | | | | | | | |  | | 7 
    +---+---+---+---+---+---+---+---+- -+---+ 
    | | | | | | | | |  | | 6 
    +---+---+---+---+---+---+---+---+- -+---+ 
    | | | | | | | | |  | | 5 
    +---+---+---+---+---+---+---+---+- -+---+ 
    | | | | | | | | |  | | 4 
    +---+---+---+---+---+---+---+---+- -+---+ bit 
    | | | | | | | | | ... | | 3 number 
    +---+---+---+---+---+---+---+---+- -+---+ 
    | | | | | | | | |  | | 2 
    +---+---+---+---+---+---+---+---+- -+---+ 
    | | | | | | | | |  | | 1 
    +---+---+---+---+---+---+---+---+- -+---+ 
    | | | | | | | | |  | | 0 
    +---+---+---+---+---+---+---+---+- -+---+ 
    0 1 2 3 4 5 6 7  999 
       array index 

Supposons que nous avons mis une chaîne dans le tableau, soit en appelant strcpy:

strcpy(s, "Hello!"); 

ou mon initialisant quand nous déclarons:

char s[1000] = "Hello!"; 

En octets, il ressemble à ceci:

+---+---+---+---+---+---+---+---+- -+---+ 
s: | H | e | l | l | o | ! |\0 | | ... | | 
    +---+---+---+---+---+---+---+---+- -+---+ 
    0 1 2 3 4 5 6 7  999 

Ou par des bits, il ressemble à ceci:

+---+---+---+---+---+---+---+---+- -+---+ 
s: | 0 | 0 | 0 | 0 | 0 | 0 | 0 | |  | | 7 
    +---+---+---+---+---+---+---+---+- -+---+ 
    | 1 | 1 | 1 | 1 | 1 | 0 | 0 | |  | | 6 
    +---+---+---+---+---+---+---+---+- -+---+ 
    | 0 | 1 | 1 | 1 | 1 | 1 | 0 | |  | | 5 
    +---+---+---+---+---+---+---+---+- -+---+ 
    | 0 | 0 | 0 | 0 | 0 | 0 | 0 | |  | | 4 
    +---+---+---+---+---+---+---+---+- -+---+ bit 
    | 1 | 0 | 1 | 1 | 1 | 0 | 0 | | ... | | 3 number 
    +---+---+---+---+---+---+---+---+- -+---+ 
    | 0 | 1 | 1 | 1 | 1 | 0 | 0 | |  | | 2 
    +---+---+---+---+---+---+---+---+- -+---+ 
    | 0 | 0 | 0 | 0 | 1 | 0 | 0 | |  | | 1 
    +---+---+---+---+---+---+---+---+- -+---+ 
    | 0 | 1 | 0 | 0 | 1 | 1 | 0 | |  | | 0 
    +---+---+---+---+---+---+---+---+- -+---+ 
    0 1 2 3 4 5 6 7  999 
       array index 

Et Il reste 993 espaces dans le tableau.

[P.S. to nitpickers: Oui, ce sont des codes ASCII, et non, le codage de caractères n'est pas spécifié par le standard C. Mais je pense que nous pouvons supposer sans risque que ce sont les codes questionneur verrait.]

Answer 2

256 est le nombre de valeurs dans un seul char (ce qui est souvent un octet 8 bits et 256 = 2) .

^{(opposition, la norme C11 permet plus large char -s, par exemple de 32 bits, mais ceci est très rare )}

Une chaîne est un tableau ou une zone de mémoire contenant plusieurs char -s, et classiquement terminé par un octet zéro.

Vous pouvez avoir de très grandes chaînes, notamment en utilisant C dynamic memory allocation. Par exemple, sur certains ordinateurs

char*hugestring = malloc(1000000000); 

peut réussir. Ensuite, vous pouvez remplir cette chaîne de milliards d'octets.Sur de nombreux ordinateurs, que malloc appel échouait, et vous toujours besoin de vérifier le résultat de malloc, au moins en suivant la ligne ci-dessus avec

if (!hugestring) { perror("malloc hugestring"); exit(EXIT_FAILURE); }; 

Si vous utilisez malloc, ne pas oublier d'appeler plus tard free (vous devez avoir conventions sur qui est responsable de cela); sinon vous avez un memory leak. BTW les fonctions asprintf, strdup et open_memstream sont très utiles (mais pas disponible partout) pour construire de manière pratique des chaînes allouées dynamiquement (en interne malloc est utilisé par eux). Des outils comme valgrind sont utiles pour aider à détecter les fuites de mémoire.

Vous pouvez également avoir des tableaux. Si elles sont local variables (automatic variables a.k.a.), ils sont généralement assis dans le call stack (à moins que le compilateur optimisé pour eux).

Par exemple, en utilisant snprintf pour remplir en toute sécurité un tampon local (sans buffer overflow),

char buffer[100]; 
snprintf(buffer, sizeof(buffer), "x=%d, name=%s", x, name); 

mais il est déraisonnable d'avoir de grands cadres d'appel, donc un tableau local devrait généralement être inférieure à quelques centaines d'octets (ou peut-être quelques milliers d'entre eux). La pile d'appels entière est généralement limitée à un ou plusieurs mégaoctets. Les détails sont spécifiques au système.

Tenez compte des problèmes character encoding. En 2017 lu au moins utf8everywhere.org et environ Unicode .... donc penser à char comme un octet (car certains caractères ont besoin UTF-8plusieurs octets, alors prenez plusieurschar -s être représenté, donc sur mon ordinateur de bureau Linux est strlen("être") 5 et sizeof("être") est 6 puisque la lettre accentuée ê est codée en UTF-8 sur deux octets). Vous pouvez utiliser une bibliothèque comme libunistring.

Regardez également dans certains C reference.

Answer 3

Vous semblez mal interpréter ce que vous appelez la "capacité" d'un char. char est une valeur de 8 bits, ce qui signifie qu'il peut être compris entre 0000 0000b() et 1111 1111b (255).

Cela se réfère uniquement à une valeur individuelle. Cela signifie que vous pouvez écrire char c = 20;, mais pas char c = 1000;. En tant que tel, cela signifie qu'il existe 256 valeurs possibles différentes pour un char unique. Les tableaux sont un concept différent: Un tableau stocke plusieurs valeurs d'un type spécifique - tel qu'un tableau de caractères.

Pour répondre à votre question: Oui, vous pouvez stocker 1000 valeurs char dans un tableau, comme char s[1000] comme suggéré par Steve Summit.

Naturellement, si vous avez 1000 caractères, cela signifie qu'il y aura des doublons (puisqu'il n'y a que 256 caractères uniques possibles).