C char initialisation de tableau

Je ne suis pas sûr de ce qui va être dans le char tableau après l'initialisation de la manière suivante.

1.char buf[10] = "";

2. char buf[10] = " ";

3. char buf[10] = "a";

Pour le cas 2, je pense que buf[0] devrait être ' ', buf[1] devrait être '\0', et de buf[2] à buf[9] sera contenu aléatoire. Pour le cas 3, je pense que buf[0] devrait être 'a', buf[1] devrait être '\0', et de buf[2] à buf[9] sera contenu aléatoire.

Est-ce exact?

Et pour le cas 1, ce sera dans le buf? buf[0] == '\0' et de buf[1] à buf[9] sera contenu aléatoire?

  • Aucun de ces tableaux sont initialisés.
  • Eh bien, mon compilateur n'accepte pas votre (corrigé) code: "tableau de type 'char [10] " n'est pas assignable".
  • maintenant, il va travailler...
  • char buf[10]; buf = "a"; ne compile pas. - S'il vous plaît essayez d'abord, et ensuite copier/coller votre code dans la question. Qui permet d'économiser beaucoup de travail pour vous et pour tous les lecteurs de votre question.
  • Désolé pour ça. Je pensais que je peux attribuer le buf[] dernier, mais il semble que non. Maintenant, le code s'exécute.
  • Double Possible de un littéral de chaîne de comptage partiel de l'initialiseur et zéro-initialiser?
  • Âgées de question n'a de réponses dessin de normes et parle aussi d'agrégation de l'initialiseur ainsi
  • Je ne pense pas que la question couvre toutes les question ici. Aussi, c'est une question de recherche convivial et clair, ce qui donne plus de points de vue sur cette question. Merci!

InformationsquelleAutor lkkeepmoving | 2013-09-08
  1. 187

    Ce n'est pas une façon d'initialiser un tableau, mais le pour:

    1. La première déclaration:

      char buf[10] = "";

      est équivalent à

      char buf[10] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0};

    2. La deuxième déclaration:

      char buf[10] = " ";

      est équivalent à

      char buf[10] = {' ', 0, 0, 0, 0, 0, 0, 0, 0, 0};

    3. La troisième déclaration:

      char buf[10] = "a";

      est équivalent à

      char buf[10] = {'a', 0, 0, 0, 0, 0, 0, 0, 0, 0};

    Comme vous pouvez le voir, pas de contenu aléatoire: si il y a moins d'initialiseurs, le reste du tableau est initialisé avec 0. C'est le cas, même si le tableau est déclaré à l'intérieur d'une fonction.

    • Pour le bien de la personne qui pose la question, il est intéressant de souligner que la norme exige que toute partiellement-une gamme complète d'initialisation à être rembourré avec zéro pour les autres éléments (par le compilateur). Cela vaut pour tous les types de données, et pas seulement char.
    • pourquoi il n'y a pas de '\0' à la fin de buf[]?
    • et '\0 ont la même valeur.
    • Et pourquoi je ne peux pas faire 'char buf[10]; buf = "a"' ?
    • parce que le C, vous devez initialiser au moment de la déclaration. Ensuite, vous ne pouvez pas affecter une valeur à un tableau.
    • Initialisation et affectation sont les deux bêtes, donc C vous permet de fournir une chaîne de caractères comme un initialiseur pour un char tableau, mais interdit les affectations de tableau (comme ouah dit).
    • J'ai roulé en arrière votre edit, c'est correct, mais je ne pense pas que cela ajoute quelque chose de plus.
    • Ce qui se passe ensuite, lorsque vous aurez plus d'éléments que l'espace? E. g. char buff[3] = "abcdefghijkl"; ? Est-ce valable et identique à char buff[3] = {'a', 'b', 'c'}?
    • il n'est pas valide comme par c99, 6.7.8p1.
    • Voulez-vous dire que char buff[3] = "abcdefghijkl"; ne compile pas? (Je ne suis pas un codeur C.) Alors pourquoi char p3[5] = "String"; compiler?
    • buff[3] = "abcdefghijkl"; n'est pas valide. char p3[5] = "String"; est pas valide. char p[6] = "String"; est valide et est le même que char p[6] = {'S', 't', 'r', 'i', 'n', 'g'};.
    • pour la terminologie, il y a une violation de contrainte dans les deux non valide exemples, ce qui signifie un compilateur est tenu d'émettre un diagnostic et peut refuser de compiler le programme.
    • qu'en char buf[] = {}?
    • buf[] = {} n'est pas valide en C sous vide initialiseurs ne sont pas autorisés. GNU C permet il et il déclare un tableau de taille 0.
    • Si vous avez une constante MAX = 5000, je ne mettrai pas 0x500 dans mon code... est fou solution!!!! si vous souhaitez définir une valeur dans une fonction, utiliser "strcpy" s'il vous plaît...
    • Qu'entendez-vous, et quelle est la pertinence à cette réponse?
    • merci man @ouah

    InformationsquelleAutor ouah
  2. 20

    Edit: OP (ou l'éditeur) en silence changé certains des guillemets simples dans la question d'origine guillemets doubles à un certain point, après j'ai fourni cette réponse.

    Votre code entraînera des erreurs de compilation. Votre premier fragment de code:

    char buf[10] ; buf = ''

    est doublement illégal. Tout d'abord, en C, il n'y a pas une telle chose comme un vide char. Vous pouvez utiliser des guillemets pour désigner une chaîne vide, comme avec:

    char* buf = "";

    Qui vous donnera un pointeur vers un NUL chaîne, c'est à dire, une seule chaîne de caractères avec seulement le NUL caractère. Mais vous ne pouvez pas utiliser les guillemets simples avec rien à l'intérieur-qui n'est pas défini. Si vous devez désigner le NUL personnage, vous devez le spécifier:

    char buf = '
    char buf = '\0';
    '    ;

    La barre oblique inverse est nécessaire pour lever l'ambiguïté du personnage '0'. 

    char buf = 0;

    accomplit la même chose, mais la première est un peu moins ambigu, à lire, je pense.

    Deuxièmement, vous ne pouvez pas initialiser les tableaux après qu'ils ont été définis. 

    char buf[10];

    déclare et définit la matrice. Le tableau identifiant buf est maintenant une adresse en mémoire, et vous ne pouvez pas modifier où buf points le biais d'une cession. Donc 

    buf =     //anything on RHS

    est illégal. Le deuxième et le troisième fragments de code sont illégales pour cette raison.

    Pour initialiser un tableau, vous devez le faire au moment de la définition:

    char buf [10] = ' ';

    vous offrons 10-tableau de caractères avec le premier char d'être l'espace '\040' et le reste étant NUL, c'est à dire, '\0'. Lorsqu'un tableau est déclarée et définie avec un initialiseur, les éléments du tableau (le cas échéant) au-delà de ceux avec des valeurs initiales sont automatiquement rembourré avec 0. Il n'y aura pas de "contenu aléatoire".

    Si vous déclarer et définir le tableau, mais ne pas l'initialiser, comme dans l'exemple suivant:

    char buf [10];

    vous aurez du contenu aléatoire dans tous les éléments.

    • "Pour initialiser un tableau, vous devez le faire au moment de la définition..." Ce, et la ligne suivante fait mieux que la accepté de répondre.
    InformationsquelleAutor verbose
  3. 18

    1. Ce sont les équivalents des

      char buf[10] = "";
char buf[10] = {0};
char buf[10] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0};

    2. Ce sont les équivalents des

      char buf[10] = " ";
char buf[10] = {' '};
char buf[10] = {' ', 0, 0, 0, 0, 0, 0, 0, 0, 0};

    3. Ce sont les équivalents des

      char buf[10] = "a";
char buf[10] = {'a'};
char buf[10] = {'a', 0, 0, 0, 0, 0, 0, 0, 0, 0};
    InformationsquelleAutor Steven Penny
  4. 6

    La partie pertinente de C11 projet de norme n1570 6.7.9 initialisation dit:

    14 Un tableau de caractères peut être initialisé par un littéral de chaîne de caractères ou une chaîne UTF-8
    littéral, éventuellement entre accolades. Successives octets de la chaîne littérale (y compris les
    caractère de fin null si il ya de la place ou si le tableau est de taille inconnue) initialiser l'
    les éléments de la matrice.

    et

    21 Si il y a moins d'initialiseurs dans un corset-ci-joint la liste qu'il y a des éléments ou des membres
    d'un agrégat, ou moins de caractères dans une chaîne littérale utilisée pour initialiser un tableau de connu
    taille qu'il y a d'éléments dans le tableau, le reste de la somme doit être
    initialisé implicitement le même que les objets qui ont statique de la durée de stockage.

    Ainsi, le '\0' est ajouté, si il y a assez d'espace, et les caractères restants sont initialisés avec la valeur qu'une static char c; serait initialisé à l'intérieur d'une fonction.

    Enfin,

    10 Si un objet qui a automatique de la durée de stockage n'est pas initialisé explicitement, sa valeur est
    durée indéterminée. Si un objet qui a statique thread ou la durée de stockage n'est pas initialisé
    explicitement, alors:

    [--]

    • si il a de l'arithmétique, il est initialisé à (positif ou non signé) zéro;

    [--]

    Ainsi, char être un type arithmétique le reste du tableau est aussi la garantie d'être initialisé avec des zéros.

    InformationsquelleAutor Antti Haapala
  5. 3

    Fait intéressant à noter, il est possible d'initialiser les tableaux en quelque sorte à tout moment dans le programme, à condition qu'ils soient membres d'un struct ou union.

    Exemple de programme:

    #include <stdio.h>

struct ccont
{
  char array[32];
};

struct icont
{
  int array[32];
};

int main()
{
  int  cnt;
  char carray[32] = { 'A', 66, 6*11+1 };    //'A', 'B', 'C', '
    #include <stdio.h>
struct ccont
{
char array[32];
};
struct icont
{
int array[32];
};
int main()
{
int  cnt;
char carray[32] = { 'A', 66, 6*11+1 };    //'A', 'B', 'C', '\0', '\0', ...
int  iarray[32] = { 67, 42, 25 };
struct ccont cc = { 0 };
struct icont ic = { 0 };
/*  these don't work
carray = { [0]=1 };           //expected expression before '{' token
carray = { [0 ... 31]=1 };    //(likewise)
carray = (char[32]){ [0]=3 }; //incompatible types when assigning to type 'char[32]' from type 'char *'
iarray = (int[32]){ 1 };      //(likewise, but s/char/int/g)
*/
//but these perfectly work...
cc = (struct ccont){ .array='a' };        //'a', '\0', '\0', '\0', ...
//the following is a gcc extension, 
cc = (struct ccont){ .array={ [0 ... 2]='a' } };  //'a', 'a', 'a', '\0', '\0', ...
ic = (struct icont){ .array={ 42,67 } };      //42, 67, 0, 0, 0, ...
//index ranges can overlap, the latter override the former
//(no compiler warning with -Wall -Wextra)
ic = (struct icont){ .array={ [0 ... 1]=42, [1 ... 2]=67 } }; //42, 67, 67, 0, 0, ...
for (cnt=0; cnt<5; cnt++)
printf("%2d %c %2d %c\n",iarray[cnt], carray[cnt],ic.array[cnt],cc.array[cnt]);
return 0;
}
    ', '
    #include <stdio.h>
struct ccont
{
char array[32];
};
struct icont
{
int array[32];
};
int main()
{
int  cnt;
char carray[32] = { 'A', 66, 6*11+1 };    //'A', 'B', 'C', '\0', '\0', ...
int  iarray[32] = { 67, 42, 25 };
struct ccont cc = { 0 };
struct icont ic = { 0 };
/*  these don't work
carray = { [0]=1 };           //expected expression before '{' token
carray = { [0 ... 31]=1 };    //(likewise)
carray = (char[32]){ [0]=3 }; //incompatible types when assigning to type 'char[32]' from type 'char *'
iarray = (int[32]){ 1 };      //(likewise, but s/char/int/g)
*/
//but these perfectly work...
cc = (struct ccont){ .array='a' };        //'a', '\0', '\0', '\0', ...
//the following is a gcc extension, 
cc = (struct ccont){ .array={ [0 ... 2]='a' } };  //'a', 'a', 'a', '\0', '\0', ...
ic = (struct icont){ .array={ 42,67 } };      //42, 67, 0, 0, 0, ...
//index ranges can overlap, the latter override the former
//(no compiler warning with -Wall -Wextra)
ic = (struct icont){ .array={ [0 ... 1]=42, [1 ... 2]=67 } }; //42, 67, 67, 0, 0, ...
for (cnt=0; cnt<5; cnt++)
printf("%2d %c %2d %c\n",iarray[cnt], carray[cnt],ic.array[cnt],cc.array[cnt]);
return 0;
}
    ', ...    
  int  iarray[32] = { 67, 42, 25 };

  struct ccont cc = { 0 };
  struct icont ic = { 0 };

  /*  these don't work
  carray = { [0]=1 };           //expected expression before '{' token
  carray = { [0 ... 31]=1 };    //(likewise)
  carray = (char[32]){ [0]=3 }; //incompatible types when assigning to type 'char[32]' from type 'char *'
  iarray = (int[32]){ 1 };      //(likewise, but s/char/int/g)
  */

  //but these perfectly work...
  cc = (struct ccont){ .array='a' };        //'a', '
    #include <stdio.h>
struct ccont
{
char array[32];
};
struct icont
{
int array[32];
};
int main()
{
int  cnt;
char carray[32] = { 'A', 66, 6*11+1 };    //'A', 'B', 'C', '\0', '\0', ...
int  iarray[32] = { 67, 42, 25 };
struct ccont cc = { 0 };
struct icont ic = { 0 };
/*  these don't work
carray = { [0]=1 };           //expected expression before '{' token
carray = { [0 ... 31]=1 };    //(likewise)
carray = (char[32]){ [0]=3 }; //incompatible types when assigning to type 'char[32]' from type 'char *'
iarray = (int[32]){ 1 };      //(likewise, but s/char/int/g)
*/
//but these perfectly work...
cc = (struct ccont){ .array='a' };        //'a', '\0', '\0', '\0', ...
//the following is a gcc extension, 
cc = (struct ccont){ .array={ [0 ... 2]='a' } };  //'a', 'a', 'a', '\0', '\0', ...
ic = (struct icont){ .array={ 42,67 } };      //42, 67, 0, 0, 0, ...
//index ranges can overlap, the latter override the former
//(no compiler warning with -Wall -Wextra)
ic = (struct icont){ .array={ [0 ... 1]=42, [1 ... 2]=67 } }; //42, 67, 67, 0, 0, ...
for (cnt=0; cnt<5; cnt++)
printf("%2d %c %2d %c\n",iarray[cnt], carray[cnt],ic.array[cnt],cc.array[cnt]);
return 0;
}
    ', '
    #include <stdio.h>
struct ccont
{
char array[32];
};
struct icont
{
int array[32];
};
int main()
{
int  cnt;
char carray[32] = { 'A', 66, 6*11+1 };    //'A', 'B', 'C', '\0', '\0', ...
int  iarray[32] = { 67, 42, 25 };
struct ccont cc = { 0 };
struct icont ic = { 0 };
/*  these don't work
carray = { [0]=1 };           //expected expression before '{' token
carray = { [0 ... 31]=1 };    //(likewise)
carray = (char[32]){ [0]=3 }; //incompatible types when assigning to type 'char[32]' from type 'char *'
iarray = (int[32]){ 1 };      //(likewise, but s/char/int/g)
*/
//but these perfectly work...
cc = (struct ccont){ .array='a' };        //'a', '\0', '\0', '\0', ...
//the following is a gcc extension, 
cc = (struct ccont){ .array={ [0 ... 2]='a' } };  //'a', 'a', 'a', '\0', '\0', ...
ic = (struct icont){ .array={ 42,67 } };      //42, 67, 0, 0, 0, ...
//index ranges can overlap, the latter override the former
//(no compiler warning with -Wall -Wextra)
ic = (struct icont){ .array={ [0 ... 1]=42, [1 ... 2]=67 } }; //42, 67, 67, 0, 0, ...
for (cnt=0; cnt<5; cnt++)
printf("%2d %c %2d %c\n",iarray[cnt], carray[cnt],ic.array[cnt],cc.array[cnt]);
return 0;
}
    ', '
    #include <stdio.h>
struct ccont
{
char array[32];
};
struct icont
{
int array[32];
};
int main()
{
int  cnt;
char carray[32] = { 'A', 66, 6*11+1 };    //'A', 'B', 'C', '\0', '\0', ...
int  iarray[32] = { 67, 42, 25 };
struct ccont cc = { 0 };
struct icont ic = { 0 };
/*  these don't work
carray = { [0]=1 };           //expected expression before '{' token
carray = { [0 ... 31]=1 };    //(likewise)
carray = (char[32]){ [0]=3 }; //incompatible types when assigning to type 'char[32]' from type 'char *'
iarray = (int[32]){ 1 };      //(likewise, but s/char/int/g)
*/
//but these perfectly work...
cc = (struct ccont){ .array='a' };        //'a', '\0', '\0', '\0', ...
//the following is a gcc extension, 
cc = (struct ccont){ .array={ [0 ... 2]='a' } };  //'a', 'a', 'a', '\0', '\0', ...
ic = (struct icont){ .array={ 42,67 } };      //42, 67, 0, 0, 0, ...
//index ranges can overlap, the latter override the former
//(no compiler warning with -Wall -Wextra)
ic = (struct icont){ .array={ [0 ... 1]=42, [1 ... 2]=67 } }; //42, 67, 67, 0, 0, ...
for (cnt=0; cnt<5; cnt++)
printf("%2d %c %2d %c\n",iarray[cnt], carray[cnt],ic.array[cnt],cc.array[cnt]);
return 0;
}
    ', ...    
  //the following is a gcc extension, 
  cc = (struct ccont){ .array={ [0 ... 2]='a' } };  //'a', 'a', 'a', '
    #include <stdio.h>
struct ccont
{
char array[32];
};
struct icont
{
int array[32];
};
int main()
{
int  cnt;
char carray[32] = { 'A', 66, 6*11+1 };    //'A', 'B', 'C', '\0', '\0', ...
int  iarray[32] = { 67, 42, 25 };
struct ccont cc = { 0 };
struct icont ic = { 0 };
/*  these don't work
carray = { [0]=1 };           //expected expression before '{' token
carray = { [0 ... 31]=1 };    //(likewise)
carray = (char[32]){ [0]=3 }; //incompatible types when assigning to type 'char[32]' from type 'char *'
iarray = (int[32]){ 1 };      //(likewise, but s/char/int/g)
*/
//but these perfectly work...
cc = (struct ccont){ .array='a' };        //'a', '\0', '\0', '\0', ...
//the following is a gcc extension, 
cc = (struct ccont){ .array={ [0 ... 2]='a' } };  //'a', 'a', 'a', '\0', '\0', ...
ic = (struct icont){ .array={ 42,67 } };      //42, 67, 0, 0, 0, ...
//index ranges can overlap, the latter override the former
//(no compiler warning with -Wall -Wextra)
ic = (struct icont){ .array={ [0 ... 1]=42, [1 ... 2]=67 } }; //42, 67, 67, 0, 0, ...
for (cnt=0; cnt<5; cnt++)
printf("%2d %c %2d %c\n",iarray[cnt], carray[cnt],ic.array[cnt],cc.array[cnt]);
return 0;
}
    ', '
    #include <stdio.h>
struct ccont
{
char array[32];
};
struct icont
{
int array[32];
};
int main()
{
int  cnt;
char carray[32] = { 'A', 66, 6*11+1 };    //'A', 'B', 'C', '\0', '\0', ...
int  iarray[32] = { 67, 42, 25 };
struct ccont cc = { 0 };
struct icont ic = { 0 };
/*  these don't work
carray = { [0]=1 };           //expected expression before '{' token
carray = { [0 ... 31]=1 };    //(likewise)
carray = (char[32]){ [0]=3 }; //incompatible types when assigning to type 'char[32]' from type 'char *'
iarray = (int[32]){ 1 };      //(likewise, but s/char/int/g)
*/
//but these perfectly work...
cc = (struct ccont){ .array='a' };        //'a', '\0', '\0', '\0', ...
//the following is a gcc extension, 
cc = (struct ccont){ .array={ [0 ... 2]='a' } };  //'a', 'a', 'a', '\0', '\0', ...
ic = (struct icont){ .array={ 42,67 } };      //42, 67, 0, 0, 0, ...
//index ranges can overlap, the latter override the former
//(no compiler warning with -Wall -Wextra)
ic = (struct icont){ .array={ [0 ... 1]=42, [1 ... 2]=67 } }; //42, 67, 67, 0, 0, ...
for (cnt=0; cnt<5; cnt++)
printf("%2d %c %2d %c\n",iarray[cnt], carray[cnt],ic.array[cnt],cc.array[cnt]);
return 0;
}
    ', ...    
  ic = (struct icont){ .array={ 42,67 } };      //42, 67, 0, 0, 0, ...
  //index ranges can overlap, the latter override the former
  //(no compiler warning with -Wall -Wextra)
  ic = (struct icont){ .array={ [0 ... 1]=42, [1 ... 2]=67 } }; //42, 67, 67, 0, 0, ...

  for (cnt=0; cnt<5; cnt++)
    printf("%2d %c %2d %c\n",iarray[cnt], carray[cnt],ic.array[cnt],cc.array[cnt]);

  return 0;
}
    InformationsquelleAutor user3381726
  6. 0

    Je ne suis pas sûr mais j'ai souvent initialiser un tableau à ""
    dans ce cas, je n'ai pas besoin de vous préoccuper de la valeur null à la fin de la chaîne.

    main() {
    void something(char[]);
    char s[100] = "";

    something(s);
    printf("%s", s);
}

void something(char s[]) {
    //... do something, pass the output to s
    //no need to add s[i] = '
    main() {
void something(char[]);
char s[100] = "";
something(s);
printf("%s", s);
}
void something(char s[]) {
//... do something, pass the output to s
//no need to add s[i] = '\0'; because all unused slot is already set to '\0'
}
    '; because all unused slot is already set to '
    main() {
void something(char[]);
char s[100] = "";
something(s);
printf("%s", s);
}
void something(char s[]) {
//... do something, pass the output to s
//no need to add s[i] = '\0'; because all unused slot is already set to '\0'
}
    '    
}
    • Vous ne devrait pas vraiment faire usage de la implicite int la règle. Vous devez spécifier un type de main() (et vous devez également utiliser void, c'est à dire, int main(void) { ... }. C99 à se débarrasser de cette règle, de sorte que ce code ne compile pas pour le C99 et plus tard. L'autre chose à noter ici est que départ avec C99, si vous omettez return en main, il ya une automatique return 0; placé/implicite avant la } à la fin. Vous êtes faisant usage de l'implicite int règle qui ne travaille qu'avant C99, mais vous êtes faisant usage de l'implicite return qui ne fonctionne que avec le C99 et tard; ces deux sont évidemment contradictoires.
    InformationsquelleAutor Erric Rapsing