utilisation de structures en C

Déclaration de structure en c

• Déclaration de structure

  Accès aux membre de la structure

tableau de structure en c

• 1. Déclaration de structure en C/C++

  Les structures sont des collections de données regroupées dans une entité logique. Il y a une distinction nette à faire entre la définition de structure et la déclaration de variable.

  ....
  #define taille_tableau 10  //Défini la taille du tableau des structures clients
  
  
   .............. définition d'une structure nommé enr
   struct enr 
   {
  		char   code[20];
  		char   matiere[30];
  		float  note;
   };
   struct enr fiche1;  // décalaration d'une variable fiche1 de type structure enr
   struct enr tablecode[20]; // un tableau de structure de type enr
   struct enr *ptr;		// un pointeur vers la structure enr
   
   .............. définition d'une structure nommé client
  
   //-- la structure CLIENT
  struct client
  {
   char ref[10+1];
   char nom[20+1];
   char prenom[20+1];
   char adresse[40+1];
   char cp[5+1];
   char ville[15+1];
   char tel[10+1];
  
  };
  
  //------Tableau de structure CLIENT
  struct client tab_client[taille_tableau]; 
  
  
  // variable globale compteur du nombre de client dans la base
  int nbre_client=0;	
  // structure de données comme paramétre d'entrée de la fonctione crire_client()
  void ecrire_client(struct client tmp) // Déclaration de la fonction Saisie des clients
  void saisie_client();         //Saisie des clients
  void affiche_client();        //Affiche les clients
   ...
   
  
  ...
  

  2. Accès aux membre de la structure en C/C++

  Un membre d'une structure est accédé par (nom_variable.nom_membre). Un membre d'une structure peut également être accédé par l'intermédiaire d'un pointeur (nom_pointeur->nom.membre).

   ........... Voir déclaration de structure plus haut
   
   struct enr *ptr;
   struct enr fiche1;
   
   int main()
   {
   
   
   .......................... Accès aux membre de la structure par une variable fiche1.................
   fiche1.note = 15.5;
   strpcy(fiche1.code, "MAT145");
   strpcy(fiche1.matiere, "Francais");
   printf("%s \n",fiche1.matiere);
   ...
   ........................... Accès aux membre de la structure par un pointeur ...................
   ptr = &fiche1		/* mettre l'adresse de fiche1 dans le pointeur ptr */
   ptr->note = 18.5;
   strcpy(ptr->code,"Laurent");
   strpcy(ptr->matiere, "Maths");
   printf("%s %f \n",ptr->matiere, ptr->note);
   ...
  
   ...........Accès aux membre de la structure par des fonctions. ...................
   .......
  
  	// appel fonction saisie de donneés client ;
  		saisie_client();	// saisie un premier client
  	 
  		gotoxy(20,47);     system("pause");
  		saisie_client();	// saisie un 2 client
  		affiche_client()		// affiche la liste des clients
  		getch();
  		return 0;
  }	 
  // fin programme principal 
   
   ......
  // *****Saisie de données CLIENT*****
   
   void saisie_client()
  {
  	struct client tmp_client;	//Déclaration de la structure temporaire client 
  	
  
  
  	char tel[20];	 
  	int x=25;		 // coordonnée de la Ligne x y
  	int y=13;		 
  	system("cls");
  	gotoxy(27,3);		 printf("- SAISIR UNE FICHE CLIENT -");	
  	fflush(stdin);	 //On vide la mémoire tampon
      gotoxy(x,y);    printf("Reference : ");     gets(tmp_client.ref);
  	gotoxy(25,47);   printf("                                  ");	
  	gotoxy(x,y+3);   printf("Nom : ");  		gets(tmp_client.nom);
  	gotoxy(x,y+6);   printf("Prenom : ");       gets(tmp_client.prenom);
  	gotoxy(x,y+9);   printf("Adresse : ");      gets(tmp_client.adresse);
  	gotoxy(x,y+12);   printf("Code postal : "); gets(tmp_client.cp);
  	gotoxy(x,y+15);	  printf("Ville : ");       gets(tmp_client.ville);
  	gotoxy(x,y+18);     printf("Telephone : "); gets(tel);
  
  	strcpy(tmp_client.tel,tel);	//On copie la variable tel dans la structure temporaire
  
  	// fonction ecrire_client()
  	//On écrit dans la base. Pour cela on envoi la structure temporaire de CLIENT	
  	ecrire_client(tmp_client); 
   }
   
   .....
   **************************************
  *****Enregistre les données CLIENT*****
  // une structure de données comme paramètre de la fonction ecrire_client()
  **************************************/
  void ecrire_client(struct client tmp)
  {	
   //Ecrit les données de la structure temporaire passé en paramètre (tmp)
   // dans la structure réelle de la base	
   strcpy(tab_client[nbre_client].ref,tmp.ref);
   strcpy(tab_client[nbre_client].nom,tmp.nom);
   strcpy(tab_client[nbre_client].prenom,tmp.prenom);
   strcpy(tab_client[nbre_client].adresse,tmp.adresse);
   strcpy(tab_client[nbre_client].cp,tmp.cp);
   strcpy(tab_client[nbre_client].ville,tmp.ville);
   strcpy(tab_client[nbre_client].tel,tmp.tel);
  
   gotoxy(23,40);textcolor(10);printf("Le client a ete ajoute dans la base");
   nbre_client++;	//Ajout d'un client dans la base
  
  }
  ............
  *****Afficher les clients*****
   parcourir un tableau de structure de données
  ****************************
  void affiche_client()
  {
  int i;		//Compteur de boucle
  int x=20;	//Represente la coordonnée de la Ligne
  int y=15;	//Represente la coordonnée de la Colonne
  
        for(i=0; i< nbre_client;i++)
  	  {
         system("cls");
         gotoxy(28,3);     printf("- AFFICHER LES CLIENTS -");
         gotoxy(x,y);      printf("Reference : %s ",tab_client[i].ref);
         gotoxy(x,y+3);    printf("Nom : %s ",tab_client[i].nom);
         gotoxy(x,y+6);    printf("Prenom : %s ",tab_client[i].prenom);
         gotoxy(x,y+9);    printf("Adresse : %s ",tab_client[i].adresse);
         gotoxy(x,y+12);   printf("Code postal : %s ",tab_client[i].cp);
         gotoxy(x,y+15);   printf("Ville : %s ",tab_client[i].ville);
         gotoxy(x,y+18);   printf("Telephone : %s ",tab_client[i].tel);
         gotoxy(30,40);    printf("Client %d sur %d",i+1,nbre_client);
         gotoxy(20,47);    system("pause");
         }
  } //fin affiche_client
  ..................
  ...