Bonjour,
je vous explique ! j'ai crée une structure qui contient un tableau genre dans le .h
je veux initialiser cette structure dans le .cCode:struct cell { int tab[MAX_B]; // MAX_B vaut 256 }
ya la possibilité de faire tab[256]={0,0,.....,0} mais il faut taper 0 256 fois! je vous demande s'il ya une autre alternative ! merci d'avance
Dernière modification par JPL ; 03/10/2011 à 23h06.
Hello,
Oui tu peux le faire :
à chaque déclaration de variables. Il est donc préféreable d'écrire une fonction pour ça, ce sera plus lisible est moins générateur de bugs.Code:struct cell { int tab[MAX_B]; // MAX_B vaut 256 } struct cell var = { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 } ;
Malheureusement non, il n'y a pas d'autre solution, mais tu peux quand même utiliser une technique comme celle-ci pour avoir une écriture plus compacte...ya la possibilité de faire tab[256]={0,0,.....,0} mais il faut taper 0 256 fois! je vous demande s'il ya une autre alternative !
Bonjour,
je n'ai plus écrit une line de C depuis mes études, mais je peux probablement t'aider néanmoins :
- si tu veux initialiser tout ton tableau à une certaine valeur, tu dois certainement faire une boucle qui parcourt chaque élément du tableau et qui y met du contenu.
Si tu voulais initialiser chaque valeur d'un tableau à "5", tu écrirais ceci en Java :
Il te suffit de transformer ceci avec la syntaxe du C et le tour est joué - ça doit être extrêmement simple à faire.Code:int[] tableau = new tableau[266]; for (int i = 0 ; i < tableau.length ; i++){ tableau[i] = 5; // ou n'importe quelle valeur d'initialisation.. }
- note tout de même (à vérifier en C), mais c'est plus pour la petite histoire, que lorsque tu instancie un tableau de primitifs, tous les primitifs prennent une valeur par défaut. Par exemple en Java la valeur par défaut d'un "int" vaut "0" (je ne connais pas l'équivalent en C). Mais il faut en général et par précaution éviter d'utiliser cette valeur par défaut, j'écris juste ceci pour la culture généraleSi tu fais l'équivalent avec des objets, chaque objet ne sera pas initialisé et vaudra donc "null".
Bonne journée
Edit : vu la réponse des deux personnes ci-dessus (je me suis fait devancer), j'en conclus que ce que je dis n'est pas possible dans le monde du C (je trouve ça étonnant mais enfin bon..)
Edit2 : est-ce que quelqu'un pourrait m'expliquer pourquoi une boucle ne ferait pas l'affaire ?
Hello,Envoyé par vae-
(...)
- note tout de même (à vérifier en C), mais c'est plus pour la petite histoire, que lorsque tu instancie un tableau de primitifs, tous les primitifs prennent une valeur par défaut. Par exemple en Java la valeur par défaut d'un "int" vaut "0" (je ne connais pas l'équivalent en C). Mais il faut en général et par précaution éviter d'utiliser cette valeur par défaut, j'écris juste ceci pour la culture générale
Bonne journée
Pour ne pas générer des bugs inutiles, il vaut mieux en C (et ailleurs cela reste une bonne pratique ...) toujours initialiser manuellement les valeurs des tes variables avant de les utilliser.
Bonjour,
D'abord, en C, une variable n'est JAMAIS initialisée par défaut.
On m'objectera que quand on est en mode debug, généralement les variables sont initialisées, c'est le programme de debug qui les initialise et non le C.
Pour initialiser un tableau, la meilleure pratique est
Mais dans le cas présent, je ne vois pas vraiment l'intérêt de créer une structure, à moins que la structure contienne d'autre membres.Code:struct cell { int tab[MAX_B]; // MAX_B vaut 256 }MaStruct; ... ... for (int i =0; i<MAX_B; i++) MaStruct.tab[i]=0;
Autre question : tel que c'est présenté, il est probable que MAX_B soit déclaré dans in #define.
Par contre si cette valeur n'est pas ferme et définitive il vaut mieux faire une allocation mémoire.
Je crois que ce n'est pas exigé par la norme, donc au bon vouloir du compilateur utilisé... De mémoire, il me semble bien que GCC initialise les variables à 0, mais j'ai un souvenir d'un GCC 3 et des brouettes pour ARM sans libc qui n'initialisait pas les variables...D'abord, en C, une variable n'est JAMAIS initialisée par défaut.
Bien sûr que c'est possible en C!!! Mais le but de la manoeuvre est d'avoir une initialisation statique (au moment de la compilation) et non dynamique (à l'execution). Une boucle est déroulée à l'execution.j'en conclus que ce que je dis n'est pas possible dans le monde du C (je trouve ça étonnant mais enfin bon..)
Sans trop entrer dans les détails, c'est ça. La norme (C99) dit simplement :
Maintenant, à moins d'avoir des contraintes extrêmes en terme de perfomance (et encore ...) il n'y a aucunes raisons de ne pas initialiser par une boucle.If an object that has automatic storage duration is not initialized explicitly, its value is
indeterminate. If an object that has static storage duration is not initialized explicitly,
then:
— if it has pointer type, it is initialized to a null pointer;
— if it has arithmetic type, it is initialized to (positive or unsigned) zero;
— if it is an aggregate, every member is initialized (recursively) according to these rules;
— if it is a union, the first named member is initialized (recursively) according to these
rules.
Ou alors, il faut mettre le tableau en static et l'initialiser au démarrage du programme, c'est à dire dans le main ou dans une fonction d'initialisation. Il pourra être modifié mais l'initialisation se fera une fois pour toutes.
Bonjour, après avoir chercher un peux sur le net ! j'ai trouver qu'on peut faire initialiser le tableau avec le fonction ''memset'' c'est plus simple je pense.
bonne journée à vous.
Bonjour,
Oui, c'est vrai. Mais il faut savoir que memset est une fonction rarement utilisée, elle fait partie des fonctions de gestion de mémoire, qui ne sont habituellement utilisées que par les programmeurs expérimentés.
Donc, je me répète, pour l'initialisation d'un tableau que ce soit static ou non, la méthode à employer est for (int i =0; i < etc...
Petit complément pour être précis, l'instruction for est une instruction de base du C, alors que memset est une fonction.
C'est positivement une connerie, car à quoi cela sert-il d'initialiser un tableau dont on est certain qu'on va le remplir avant de le lire...
c'est un gaspillage de ressource souvent inutile.
il aurait mieux valu mettre en place une déclaration itérative genre:
static int un[55]={1, ...};
et pourquoi pas d'autres variations (répétition d'un pattern, suites, ...)
et surtout, (tout en restant dans la norme), avoir la possibilité de déclarer un tableau sans initialisation préalable genre:
static unknown int[66];
Jusqu'ici tout va bien...
Bonjour,
Je ne suis pas du tout d'accord.Comment pouvez-vous être certain que vous allez remplir ce tableau.C'est positivement une connerie, car à quoi cela sert-il d'initialiser un tableau dont on est certain qu'on va le remplir avant de le lire...
c'est un gaspillage de ressource souvent inutile.
La question posée n'était pas sur l'opportunité ou pas d'initialiser ou pas un tableau, mais de la manière de le faire.
Quant au reste de votre intervention, je n'ai pas vraiment compris, mais comme notre ami questionneur est débutant, il vaut mieux énoncer des idées claires :
Comme tout variable en C, un tableau doit être déclaré int tab[256].
Il peut être initialisé, et c'est préférable : for (int i=0; i<256; i++) tan[i]=0;
Il peut garder les mêmes valeurs tout au long du programme, même s'il est déclaré dans une fonction, si il a été déclaré avec le mot clé static.
Comme le dit DlzLogic quand on apprend le C il faut apprendre à initialiser toute variable déclarée. Cela doit devenir un réflexe, que ce soit un int i=0; ou un truc* variable; variable=initialiserTruc();
Dire que memset doit être réservé aux pros est à mon avis excessif, c'est une fonction standard qui me semble apropriée dans ce cas.
Quant à l'ajout de sucre syntaxique proposé par polo974, cela restera du sucre, . Si C ne le fait pas c'est justement pour ça, on s'attend à ce que l'utilisateur initialise ces variables.
Bonjour,
C'est vrai, j'ai dit qu'à mon avis l'utilisation de memset est plutôt réservée au pro. Ceci résulte de 4 constats
1- les quelques fonctions mem.. sont regroupées et le fichier d'entête mem.h (mais sont déclarées aussi dans string.h) Ces deux fichiers d'entête sont rarement utilisés.
2- le code source est en assembleur (dans mon compilateur). Donc, il est optimisé pour un processeur donné.
3- petite anecdote, quand je débutais en C une de mes connaissances expliquait qu'en assembleur, il y a avait un ordre de mise à zéro d'une zone, et que cela n'existait pas en C
4- une recherche d'exemple d'utilisation de memset dans mon package n'a rien donné.
Il y a enfin une dernière raison, memset initialise un nombre d'octets, un tableau int tab[256] occupe combien d'octets ? (bien-sûr, interdit à Photon de me répondre)
Ok, donc pas besoin de se faire assister par un automatisme arbitraire (pourquoi ZERO ? ? ?).
Rare sont mes programme qui ne l'appellent pas... C'est un peu le rouleau du peintre en bâtiment, ensuite, on prend une brosse pour les détails.Dire que memset doit être réservé aux pros est à mon avis excessif, c'est une fonction standard qui me semble apropriée dans ce cas.Attention, c'est un sucre pour contourner l'amertume de l'init d'office à une valeur arbitraire des variables statiques.Quant à l'ajout de sucre syntaxique proposé par polo974, cela restera du sucre, . Si C ne le fait pas c'est justement pour ça, on s'attend à ce que l'utilisateur initialise ces variables.
Il y a des cas où on ne peut pas se permettre de bouffer des watts et du temps pour faire des trucs inutiles.
Toujours sur la non initialisation d'office.
Quand on bosse beaucoup avec des pointeurs, on apprend vite à assurer ses init
Bien sûr, on peut aussi vouloir programmer "à la basic", pas de déclaration explicite qui font qu'à la moindre faute de frappe ou oubli, une nouvelle variable est créée, le programme tourne mais pas comme espéré... Mais ce n'est pas la philo initiale du C.
De plus C impose seulement une préinit des static mais pas du reste (plus couteux en ressource...), donc, quelque-part, il y a tout de même une incohérence.
Attention également, question init mémoire:
comme un système multi utilisateurs doit assurer une confidentialité entre ceux-ci, il y a obligatoirement un remplissage des blocs mémoires par l'OS avant livraison à l'usager. Donc un programme qui fonctionne bien sur un OS peut complètement planter sur un microcontrôleur sans OS...
Bref, tout ça pour dire qu'il vaut mieux positionner ses variables avant de les utiliser, et ne pas se reposer sur de présupposées init d'office.
Jusqu'ici tout va bien...
J'ai rien compris.
