Déclarer un tableau de structures litéral

**CoderInTheDark** · 11/12/2025, 09h59

Bonjour,

Je pensais pouvoir déclarer un tableau de littéraux de structure comme ci-dessous.
Mais je ne trouve pas la bonne syntaxe. Je ne comprends pas où est mon erreur
Si quelqu'un sait
Cordialement

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
 
struct spectacle {*
char intitule[50];*
int nbPlace;*
};*
//struct spectacle tabSpectacles[10];*
 
//void init() {*
struct spectacle tabSpectacles = *{*
{spectacle {"En attendant goto", 10}},*
{spectacle {"Tant qu'il y aura des pommes", 4}},*
{spectacle {"}Notre pam de paris", 6}}*
* * };*

Répondre
Voir ce message dans son contexte

Se désabonner du forum* Se désabonner de cette discussion* Modifier vos préférences pour les récapitulatifs de messages de forum

**gerald3d** · 11/12/2025, 10h08

Bonjour,

Hormis les dépassements de tampon non gérés voici un petit exemple de déclaration fonctionnel :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#include <stdio.h>
 
typedef struct spectacle {
  char intitule[50];
  int nbPlace;
}t_spectacle;
 
int main (int argc, char **argv) {
 
  t_spectacle tabSpectacles [3] = {{"En attendant goto", 10},
				 {"Tant qu'il y aura des pommes", 4},
				 {"Notre pam de paris", 6}};
 
  for (int i=0; i < 3; i++)
    printf ("%s : %d\n", tabSpectacles[i].intitule, tabSpectacles[i].nbPlace);
 
  return 0;
}

Le résultat en console :

En attendant goto : 10
Tant qu'il y aura des pommes : 4
Notre pam de paris : 6

**CoderInTheDark** · 11/12/2025, 11h51

Merci

Ca fait tellement longtemps que je n'ai pas fait de C, et je suis pollué par mon Java.

Je veux sortir la déclaration du tableau en global .
Je déclare en dehors des fonctions au début.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
* t_spectacle tabSpectacles [];

Mais dans la fonction quand je veut le remplir avec :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
tabSpectacles = ....

Il y a une erreur

**gerald3d** · 11/12/2025, 12h26

Écrire t_spectacle tabSpectacles []; revient à déclarer un tableau vide sans taille. Soit tu déclares tout en global soit tu devras passer par l'allocation dynamique (dans le tas).

Un petit exemple d'allocation dynamique :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
typedef struct spectacle {
  char intitule[50];
  int nbPlace;
}t_spectacle;
 
t_spectacle *tabSpectacles;
 
void remplir_un_element (t_spectacle *tabSpectacles, int position, const char* intitule, int nbPlace) {
  memcpy (tabSpectacles[position].intitule, intitule, strlen (intitule));
  tabSpectacles[position].nbPlace = nbPlace;
}
 
int main (int argc, char **argv) {
 
  /* Allocation mémoire pour 3 éléments */
  tabSpectacles = malloc (3 * sizeof (t_spectacle));
 
  /* Remplissage des 3 éléments */
  remplir_un_element (tabSpectacles, 0, "En attendant goto", 10);
  remplir_un_element (tabSpectacles, 1, "Tant qu'il y aura des pommes", 4);
  remplir_un_element (tabSpectacles, 2, "Notre pam de paris", 6);
 
  for (int i=0; i < 3; i++)
    printf ("%s : %d\n", tabSpectacles[i].intitule, tabSpectacles[i].nbPlace);
 
  /* Libération mémoire */
  free (tabSpectacles);
 
  return 0;
}

Édit:
Sinon tu déclares tout en global :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
t_spectacle tabSpectacles [3] = {{"En attendant goto", 10},
				 {"Tant qu'il y aura des pommes", 4},
				 {"Notre pam de paris", 6}};
 
int main (int argc, char **argv) {
  for (int i=0; i < 3; i++)
    printf ("%s : %d\n", tabSpectacles[i].intitule, tabSpectacles[i].nbPlace);
 
  return 0;
}

**foetus** · 11/12/2025, 12h42

En gros

(Édit: barbecued par @gerald3d

)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
 
typedef struct s_spectacle {
  char intitule[50];
  int nbPlace;
} t_spectacle;
 
 
int main()
{
  t_spectacle* list_spectacles = NULL;
 
  list_spectacles = malloc(3 * sizeof(t_spectacle));
 
  if (list_spectacles != NULL) {
    unsigned char i;
 
    list_spectacles[0].nbPlace = 10;
    strcpy(list_spectacles[0].intitule, "En attendant goto");
 
    list_spectacles[1].nbPlace = 4;
    strcpy(list_spectacles[1].intitule, "Tant qu'il y aura des pommes");
 
    list_spectacles[2].nbPlace = 6;
    strcpy(list_spectacles[2].intitule, "Notre pam de paris");
 
    for(i=0; i < 3; ++i) {
       printf ("%s : %d\n", list_spectacles[i].intitule, list_spectacles[i].nbPlace);
    }
 
    free(list_spectacles); list_spectacles = NULL;
  } else {
    printf("main - error: malloc\n");
  }
 
 
  return 0;
}

Cela s'est le mode facile parce que les chaînes sont en dur

Sinon pour chaque chaîne, compter le nombre de caractères (strlen), allouer la chaîne + 1, strcpy ou strncpy, finir la chaine avec le caractère final '\0' et à la toute fin libérer la chaine.

Il faudrait dans ce cas faire des fonctions qui accompagnent ta structure, qui font le travail : s_spectacle_copy(char*, int), s_spectacle_init(), s_spectacle_free(), ...

**gerald3d** · 11/12/2025, 14h55

Tout à fait d'accord avec toi @foetus. Je n'ai pas voulu trop surcharger le code pour juste exposer un principe simple. De toute façon dés qu'on traite des chaînes de caractères avec des allocations mémoires la rigueur est de mise

.

**henderson** · 12/12/2025, 10h10

Au cas où :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
 
typedef struct spectacle {
  char *intitule;
  int nbPlace;
}t_spectacle;
 
t_spectacle tabSpectacles[3] = {{"En attendant goto", 10},
				 {"Tant qu'il y aura des pommes", 4},
				 {"Notre pam de paris", 6}};

**CoderInTheDark** · 19/12/2025, 11h26

Ok par contre je ne comprends pas pourquoi je n'arriive pas à parcourir ou récupérer un élément.

Pour le "for " je tiens compte de la taille des structures.

Et je n'arrive pas à récupérer un élément et pointer avec le "." sur le champs

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
#include<stdio.h>
 
struct spectacle {
char intitule[50];
int nbPlace;
};
struct spectacle tabSpectacles[10];
void init() 
{
struct spectacle tabSpectacle[] = {
{"En attendant Gotot", 10},
{"Tant qu'il y aura des pommes", 4},
{"Le cercle des petes dix par ru", 7},
{"L'inspecteur a ri", 9},
{"Notre spame de Paris", 6}
};
}
 
void afficher() 
{
	int length = (sizeof(tabSpectacles) / sizeof(tabSpectacles[0]));
 
 
//for(int i=0;i < sizeof(tabSpectacles);i++) 
	for(int i=0;i < length;i++) 
{
printf("%i - %s %i \n", i, tabSpectacles[i].intitule, tabSpectacles[i].nbPlace);
 
}
}
 
//spectacle getSpectacle(int idSpectacle) {
//	return tabSpectacles[idSpectacle]; 
//}
 
bool quantiteEstDisponible(int idSpectacle, int quantiteDemandee) 
{
	//getSpectacle(idSpectacle);
 
	//leSpectacle = tabSpectacles[idSpectacle];
	//int quantiteDisponible = leSpectacle.nbPlace;
	int quantiteDisponible = tabSpectacles[idSpectacle].nbPlace;
 
	if(quantiteDemandee > quantiteDisponible) {
		return false;
	} else {
		return true;
	}
}
 
bool retirerPlace(int idSpectacle, int quantiteDemandee) 
{
	if(quantiteEstDisponible(idSpectacle, quantiteDemandee)) {
		tabSpectacles[idSpectacle].nbPlace  = tabSpectacles[idSpectacle].nbPlace - quantiteDemandee;
 
		return true;
			} else {
		return false;
	}
}
 
int main(int argc, char** argv) 
{
	init();
afficher();
 
return 0;
}

**henderson** · 19/12/2025, 11h48

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
 
int NbSpectacles = 10;
struct spectacle tabSpectacles[NbSpectacles];
 
 
for(int 0; i < NbSpectacles; i++)
	{
	//...
	}

**dalfab** · 20/12/2025, 11h18

Envoyé par CoderInTheDark

Ok par contre je ne comprends pas pourquoi je n'arriive pas à parcourir ou récupérer un élément.

Pour le "for " je tiens compte de la taille des structures.

Et je n'arrive pas à récupérer un élément et pointer avec le "." sur le champs

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
#include<stdio.h>
 
struct spectacle {
char intitule[50];
int nbPlace;
};
struct spectacle tabSpectacles[10];
void init() 
{
struct spectacle tabSpectacle[] = {
{"En attendant Gotot", 10},
{"Tant qu'il y aura des pommes", 4},
{"Le cercle des petes dix par ru", 7},
{"L'inspecteur a ri", 9},
{"Notre spame de Paris", 6}
};
}
 
void afficher() 
{
	int length = (sizeof(tabSpectacles) / sizeof(tabSpectacles[0]));
 
 
//for(int i=0;i < sizeof(tabSpectacles);i++) 
	for(int i=0;i < length;i++) 
{
printf("%i - %s %i \n", i, tabSpectacles[i].intitule, tabSpectacles[i].nbPlace);
 
}
}
 
//spectacle getSpectacle(int idSpectacle) {
//	return tabSpectacles[idSpectacle]; 
//}
 
bool quantiteEstDisponible(int idSpectacle, int quantiteDemandee) 
{
	//getSpectacle(idSpectacle);
 
	//leSpectacle = tabSpectacles[idSpectacle];
	//int quantiteDisponible = leSpectacle.nbPlace;
	int quantiteDisponible = tabSpectacles[idSpectacle].nbPlace;
 
	if(quantiteDemandee > quantiteDisponible) {
		return false;
	} else {
		return true;
	}
}
 
bool retirerPlace(int idSpectacle, int quantiteDemandee) 
{
	if(quantiteEstDisponible(idSpectacle, quantiteDemandee)) {
		tabSpectacles[idSpectacle].nbPlace  = tabSpectacles[idSpectacle].nbPlace - quantiteDemandee;
 
		return true;
			} else {
		return false;
	}
}
 
int main(int argc, char** argv) 
{
	init();
afficher();
 
return 0;
}

Bonjour,

La notation type nom_de_tableau[taille_facultative] = { liste_de_valeur }; crée et initialise un tableau. C'est le seul moyen d'initialiser un tableau sous cette forme. La définition et l'initialisation sont au même point.

Ton code définit le tableau ligne 7, et la fonction init() définit et initialise un autre tableau!.

Tu dois, soit initialiser ligne 7 (donc ici en global), soit utiliser un autre moyen pour mettre à jour ton tableau global.
Par exemple:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
void  init() {
   struct spectacle  tabSpectacleLocal[] = {
      {"En attendant Gotot", 10},
      {"Tant qu'il y aura des pommes", 4},
      {"Le cercle des petes dix par ru", 7},
      {"L'inspecteur a ri", 9},
      {"Notre spame de Paris", 6}
   };
 
   memcpy( tabSpectacles, tabSpectacleLocal, sizeof tabSpectacleLocal );  // init des 5 premiers
 
   // facultatif : force à zéro les autres
   const int  totalNb = sizeof tabSpectacles / sizeof(struct spectacle);
   const int  localNb = sizeof tabSpectacleLocal / sizeof(struct spectacle);
   if ( localNb < totalNb )
      memset( tabSpectacles + localNb, 0, sizeof(struct spectacle) * (totalNb - localNb) );
}

**CoderInTheDark** · 20/12/2025, 12h18

Merci j'ai trouvé une solution.
Maintenant je le copie dans la fonction init de la version locale ver la version globale

J'ai fait du C entre 2000 et 2005 avant de passer à java.
Et ça fait un brut, surtout quand on t'impose le c standard.
C'est bien pour le bas niveau ou la prog système

Mais là je suis un peu perdu

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
 
#include<stdio.h>
#include <stdbool.h>
 
int nbSpec;
int specSelect = 9999;
 
 
struct spectacle {
    char intitule[50];
    int nbPlaces;
};
 
struct spectacle tabSpectacles[10];
 
void init() 
{
    struct spectacle tabTemp[] = {
        {"En attendant Godot", 10},
        {"Tant qu'il y aura des pommes", 4},
        {"Le cercle des poètes disparus", 7},
        {"L'inspecteur a ri", 9},
        	};
 
			for(int i=0;i < sizeof(tabTemp) / sizeof(tabTemp[0]); i++) {
tabSpectacles[i] = tabTemp[i];
			}
 
nbSpec = sizeof(tabTemp) / sizeof(tabTemp[0]); 
}
 
void afficher() 
{
    printf("Liste des spectacles :\n");
 
    for (int i = 0; i < nbSpec;i++) {
        printf("%d - %s (%d places)\n", i, tabSpectacles[i].intitule, tabSpectacles[i].nbPlaces);
    }
}
 
bool quantiteEstDisponible(int idSpectacle, int quantiteDemandee) 
{
    int quantiteDisponible = tabSpectacles[idSpectacle].nbPlaces;
    return quantiteDemandee <= quantiteDisponible;
}
 
bool retirerPlace(int idSpectacle, int quantiteDemandee) 
{
    if (quantiteEstDisponible(idSpectacle, quantiteDemandee)) {
        tabSpectacles[idSpectacle].nbPlaces -= quantiteDemandee;
        return true;
    } else {
        return false;
    }
}
 
void ajouterPlaces(int idSpectacle, int quantiteDemandee) 
{
 
        tabSpectacles[idSpectacle].nbPlaces += quantiteDemandee;
        }
 
		int menu(){
			int choix;
			printf("Menu \n");
 
			if(specSelect != 9999) {
				printf("Spectacleselectionne: %i %s %i \n", specSelect, tabSpectacles[specSelect].intitule, tabSpectacles[specSelect].nbPlaces);
				}  
				else 
				{
							printf("Pas de spectacles selectionné \n");
 
										printf("1 selectionner un spectacle \n");
										printf("2 Afficher les spectacles \n");
				}
 
										if(specSelect != 9999) {
				printf("3 Réserver des places \n");
				printf("4 Ajouter des  places \n");
				printf("\n 0 Quitter \n");
				}
 
				printf("Entrez votre choix \n");
				scanf("%d", &choix);
 
				return choix;
		}
 
int main(int argc, char** argv) 
{
    //init();
    //afficher();
 
	//printf("Retirer place spec 3, 3 places \n");
	//printf("Réponse : %i \n", retirerPlace(3, 01));
 
	//afficher();
 
 	//printf("Retirer place spec 3, 3 places \n");
	//printf("Réponse : %i \n", retirerPlace(3, 11));
 
	//afficher();
 
    //ajouterPlaces(3, 10);
 
	//afficher();
 
	int choix = 99;
 
	while(choix != 0) {
	choix = menu();
 
	printf("Votre choix %i \n", choix);
	}
 
    return 0;
}

**gerald3d** · 21/12/2025, 10h41

Par principe les déclarations en global sont en général à proscrire. Elles peuvent cependant dans certains cas rares être inéluctables (programmation sur matériel embarqué...).

Pourquoi à proscrire ?

Lorsque le code devient important il devient très difficile de déboguer si une erreur survient. Comme plusieurs fonctions peuvent manipuler ces données qui génère l'erreur ? Ton code actuel ne compte que quelques lignes à fin de test, comme nous faisons tous. Mais lorsque tu vas intégrer ces principes dans ton projet tu risques vite de t'arracher les cheveux

.

**CoderInTheDark** · 22/12/2025, 12h57

Ouep ce n'est pas bo les variables globales, surtout en procédural.
Mais comme les codes du projets à rendre sont petits ça devrait aller.

Il y a si longtemps que je n'ai pas fait de C, et en plus j'ai plus fait de C++ que de C.
En objet tu peu encapsuler et moins pollué.

Mais là j'ai besoin d'une seule variable globale.
Et en plus là c'est juste pour faire mon tp sur mon cours sur les appels systèmes Linux.

Toutefois il y a une question avec les threads, et là il y a de la concurrence et ça veut dire que les variables globale peuvent être dans un état incohérent.
Je ne sais pas si je vais devoir faire une section critique.

Merci de m'avoir remis sur les rails, et bonne fêtes ;D

J'ai fait un premier pas en faisant un ".h", c'est plus claire.
Et je me suis limité à une seule variables globale.

**dalfab** · 22/12/2025, 13h49

Envoyé par CoderInTheDark

Toutefois il y a une question avec les threads, et là il y a de la concurrence et ça veut dire que les variables globale peuvent être dans un état incohérent.
Je ne sais pas si je vais devoir faire une section critique.

Pour les threads, ce qu'il faut gérer, c'est l'accès de plusieurs threads à une même entité quelle qu'elle soit. Dans ce cas il faut gérer une protection de l'accès. Les données globales peuvent nécessiter une protection (un simple #include permet de la voir et c'est "tentant" d'y accéder), mais une locale peut être vue et accédée par plusieurs threads (dès que son adresse est prise, il faut se méfier!) avec le même risque de conflit.

Déclarer un tableau de structures litéral

C

Discussions similaires

Partager

Partager