Variable mémoire dépassement

"quelque chose comme 700 millions et des poussières": n'hésite pas à partager le nombre exact que tu obtiens.

CHAR(n) est un type de données qui respecte de la longueur dont n caractères stockée même si la longueur du texte est inférieure à n, il y aura alors un remplissage à blanc.
Exemple :
« toto » en CHAR(12) donne :

"toto "
VARCHAR(n) est un type de données de longueur variable avec au maximum n caractères stockée + stockage de la longueur du texte (en général sur 2 octets) et pas de remplissage à blanc.
Exemple « toto » en VARCHAR(12) donne :

04"toto"
AVANTAGES / INCONVÉNIENTS :
VARCHAR économise de l’espace si la longueur des données peut être grande et la taille du texte très fluctuante. Or plus on économise l’espace meilleures seront les performances .
Mais si la données est voisine de la taille maximale ou fais toujours la taille maximale, alors avec les 2 octets pour stocker la taille c’est le contraire qui se produit.
Par exemple pour un code postal, c’est stupide car il y aura toujours 5 caractères (en France) => VARCHAR = 7 octets, CHAR = 5 octets

En sus, la recherche d’une colonne VARCHAR est plus complexe que la recherche d’une colonne CHAR au sein de la ligne composant la table. Son accès est donc plus lent, car il faut parcourir toutes les colonnes précédentes du fait de la longueur variable. Alors qu’avec une longueur fixe, il suffit de calculer l’offset par rapport au début de la ligne pour trouver immédiatement l’emplacement du premier caractère de la colonne de type CHAR (en fait pour optimiser les accès aux données, la plupart des SGBDR constituent les lignes des tables avec les colonnes de taille fixe en premier et les colonnes de taille variable en dernier de façon à ce que le repérage des colonnes de type fixe soit immédiat.

Exemple complet de manipulations de variables

#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
..................

...

merci, le moment venu, de marquer la discussion comme résolue.