C / Pascal / Visual Basic / SQL / Php / JavaScript / Java / C++   

• Les Variables.
• Les Opérateurs.
• Afficher / Lire.
• Les Conditions.
• Switch.
• Les Répétitions.
• Break, Continue et Goto.
• Les Tableaux.
• Fonctions/Procédures.
• Les Chaînes de Caractères.
• Les Structures.
• Les Pointeurs.
• La Strucutre Générale d'un Programme en C.

- types prédéfinis existants :     short, int, long, float,char.

- constantes :     #define.

- déclaration : elle se fait en début de programme (variables globales) ou en début de fonction (variables locales).
                         type nom_var;

- affectation : on peut affecter (initialiser) les variables dès leur déclaration ou bien pendant le programme.
                         type nom_var = valeur;

- afficher :     printf(code_format, nom_var);.

- lire :     scanf(code_format, &nom_var);.

où code_format :
• %d <--> var de type int,
• %f <--> var de type float,
• %e <--> var de type float en notation exponentielle,
• %c <--> var de type char.

Attention : il faut autant de code_format que de nom_var...!!!

- affectation :      =.
- numériques :      + , - , * , / , mod.
- incrémentation :     ++.
- décrémentation :     --.
- comparaison :     = = , < , > , <= , >= , !=.
- logiques et, ou, non :     && , || , !.

			if(condition)
				{
				instructions;
				...
				}
			else
				{
				instructions;
				...
				}
		

			switch(nom_var)
				{
				case val1 :
					instructions;
					break;
				case val2 :
					instructions;
					break;
				...
				default :
					instructions;
					break;
				}
		

Attention : il faudra mettre des cotes ' si val est du type char

- Boucle s'exécutant au moins une fois :

			do
				{
				instructions;
				...
				}
			while(condition);
		

- Boucle où la condition est d'abord vérifiée :

			while(condition)
				{
				instructions;
				...
				}
		

- Boucle à compteur dont le pas est régulié :

			for(i=0;i<=nb;i=i+1)
				{
				instructions;
				...
				}
		

- break : utilisé afin d'arrêter le déroulement d'un if, d'un switch ou d'un while.

- continue : utilisé afin de continuer - reprendre le déroulement d'un if, d'un switch ou d'un while.

- goto : utilisé afin de renvoyer à un autre endroit du programme.

Il faudra d'abord définir une "étiquette" : nom_etiquette : { instructions; ... } .

- déclaration :     tableau à 1 dimension : type nom_var[nb_cases];.
                          tableau à 2 dimensions : type nom_var[nb_lignes][nb_colones];.

- initialisation :      par liste :nom_var[nb_cases] = {var1, var2, ...};.
                           grâce à une boucle for ou while .

- 2 familles :

1. les fonctions : ne renvoient aucun résultat.


2. les procédures : renvoient un ou plusieurs résultat(s).


Attention : le simple fait d'écrire quelque chose à l'écran est considéré comme un résultat.

- déclaration fonction :

	nom_fonction(var1, var2,..)
			{
			instructions;
			...
			return var5;
			}
		

- déclaration procédure :

		void nom_procedure(var1, var2,..)
			{
			instructions;
			...
			}
		

- appel fonction :     nom_var = nom_fonction(...);.

- appel procédure :    nom_var = nom_procédure(...);.

- appel fonction prédéfinie : ces fonctions existent déjà soit car elles sont dans des packages du C,
soit car vous les avez développées dans un autre fichier.
Vous devez donc appeler ce fichier/package :#include nom_fonction.

sont sous la forme d'un tableau de caractères terminé par '\0'

- déclaration :    char nom_chaine[nb];.

- saisie clavier :  gets(nom_chaine);.

- affichage :        puts(nom_chaine);.

- comparaison :  strcmp(chaine1,chaine2);.

- recopier :         strcpy(destination,source);.

- longueur :         strlen(nom_chaine);.

- concaténation : strcat(destination,source);.

Les structures sont les équivalents des objets en Java, C++...
- déclaration : on décrit d'abord la structure...

		struct nom_structure
			{
			type nom_var1;
			type nom_var2;
			...
			}
		

... puis on déclare une ou plusieurs variables de type struct :
   struct nom_structure s1, s2, ... ;.

- utilisation :        s1.var1 = valeur;.

- initialisation :  struct nom_structure s1={123,'aer',...};.

Un pointeur est une variable qui contient une adresse.
A cette adresse, on trouve une variable de type char, entier, float....

- déclaration : type * nom_var;

- initialisation :  nom_var = &nom_var1;.
On dit que nom_var pointe sur nom_var1.
- modification : on peut modifier la valeur d'une variable grâce à son pointeur.


		ex : int n = 20;
		     int p;
			 int *adr;
			 
			 adi = &n;
			 p = *adi;
			 		=> p = 20
			 *adi = 30;
			 		=> n = 30
		

	#include 
	char lettre;
	int tab[6];
	struct enreg
		{
		int a;
		float b;
		}
		
	main()
		{
		struct enreg x;
		
		x.a = 1;
		x.b = 1.25;
		printf("\navant appel fct : %d %e", x.a, x.b);
		fct(&x);
		scanf(%c, lettre);
		}
		
	void fct(struct enreg s)
		{
		s.a = 0;
		s.b = 1;
		printf("\dans fct : %d %e", s.a, s.b);
		init_tableau(tab);
		if(tab[2] == 6)
			{
			printf("vérifié");
			s.a = tab[2];
			}
		else
			{
			printf("non vérifié");
			s.a = 0;
			}
		}
	
	init_tableau(table)
		{
		for(i=0;i<6;i++)
			{
			table[i] = 0;
			}
		return tab;
		}