Memento C

Séparateurs et commentaires

Le séparateur est le ; il n'est aps recquis après une }.

Les comentaires simples en fin de ligne par //

Les commentaires multilignes par /* .... */

Types, Variables, pointeurs, opérations

Variables

Déclaration par : int a=3,b,c; (initalisation possible à la création).

Une variable local à une fonction déclarée static conservera sa valeur entre deux appeles à la fonction.

const int n=3; la compilation remplacera n par 3

Les tableaux

char t[50] pour déclarer de t[0] à t[49] un tableau est un pointeur.

Attention : il n'y a pas de contrôle de la validité de l'indice.
t[60]=3 placera 3 en mémoire ... on ne sait où.

Tableaux dynamiques :

int *tableau= malloc(10*sizeof(int));
tableau[5]=3 ;
free(tableau);

Pointeurs

int *x; créer une variable contenant l'adresse d'une variable contenant un int.

Si int y=3; alors x=&y est le pointeur sur la variable y

*x est alors la variable y

Alors que les fonctions ne peuvent donner qu'un seul résultat, placer des pointeurs dans leurs entêtes permet d'affecter plusieurs variables depuis une fonction.

Types de base

`void`	vide
`char`	-128 à 127
`int`	-2 147 483 648 à 2 147 483 647
`float`	-3.4 x 10 puissance 38 à 3.4 x 10 puissance 38
`double`	-1.7 x 10 puissance 308 à 1.7 x 10 puissance 308

unsigned char perd son signe et va de 0 à 255.

Conversion par n=(int)x ne garde que la partie entière ou x=(float)n.

Type structuré

typedef struct Coord tCoord;
struct Coordonnees
{
    int x;
    int y;
};

définit la structure Coord et le type tCoord
On peut donner le même nom à la strucutre et au type.

typeCoordonnes p; sera affecté par p.x=3 et p.y=2

typeCoordonnes p={2,3}; est réservé à l'nitialisation.

Opérations

+,*,/ (division euclidienne si entre entiers),% (reste de la division euclidienne)

n++, n-- incrémentation et décrémentation de 1

Réafectation : n+=3 pour n=n+3 idem *= ou -=

bibliothèque #include <math.h> :

ceil le plus petit entir plus grand ou égal que
floor partie entière
pow(a,b)=a^b puissance

Aléatoires : géré par include<stdlib.h> et include<time.h>( pour l'initialisation par time())

srand(time(NULL)); pour intitialiser
rand() au hasard dans l'intervalle [[0,RAND_MAX]]
Pour un entier au hasard dans [[min,max]] : rand() % (max-min+1) + min

comparaisons : ==, !=, >, >=égal, différent, supérieur, ou égal

logiques : && et ; || ou ; ! négation

de chaines par string.h

Conditions

conditions simples

if (condition){ instructions;}

conditions successives

if (condition){instructions;} // sans ; avant le else !
else if (autre condition){instructions;}
else {instructions;}

tests successif sur une même valeur

switch (nomDeVariable)
{
	case 2:
		instructions pour 2;
	break;
	case 8:
		instructions pour 8;
	break;
	default:
		instructions pour les autres valeurs;
	break;
}

Boucles

`While`

tant que : while (condition){ instructions; }

`do ... while`

do {instructions;} while (condition)

`for`

for (i=debut;i<fin;i++){ instructions;}

Lecture / ecriture

Ecriture sur la «sortie standard» (écran)

printf("Le resultat est : %f \n", x); le contenu de x est affiché au format des float

`%f`	`%lf`	`%s`	`%d`	`%x`
`float`	`double`	chaine	`int`	exadécimal

Lecture à l'«entreé standard» (clavier)

C'est un pointeur qu'il faut fournir à la fonction de saisie scanf
scanf("%d", &n);
Mais attentionscanf("%s",&chaine); où int chaine[20] remplira le tableau au dela des 20 caractères (plus un de fin de chaine) sans controle !

Fonctions

type nomDeLaFonction (type prametre; type *parametre){ ...return valeur ...} s'arrète sur le return

Lecture et ecriture dans un fichier

Bibliothèques #include <stdio.h> et #include <stdlib.h>

le type :

FILE *fichier=NULL

ouverture

fichier = fopen("test.txt", "r+"); vérifier la bonne ouverture par if (fichier != NULL)

`"r"`	`"w"`	`"a"`	`"r+"`	`"w+"`	`"a+"`
lecture	écriture écrase	ajout à la fin	lecture et écriture.	ecriture et lecture écrase	lecture ajout

fermeture

Pour refermer le fichier : fclose(fichier);

ecriture

int fputc(int caractere, FILE* pointeurSurFichier); ecrit un caractère.

int fputs(const char* chaine, FILE* pointeurSurFichier); ecrit une chaine

fprintf(fichier, "Le Monsieur qui utilise le programme, il a %d ans", age); permet l'utlisation des masques

Lecture

La lecture décale le pointeur de fichier à l'élément suivant.

int fgetc(FILE* pointeurDeFichier); lit un caractère et renvoie EOF quand le bout du fichier est atteint.

char* fgets(char* chaine, int nombreDeCaracteresALire, FILE* pointeurSurFichier); lit une ligne au maximum à la fois.

while (fgets(chaine, TAILLE_MAX, fichier) != NULL) // On lit le fichier tant qu'on ne reçoit pas d'erreur (NULL)
        {
            printf("%s", chaine); // On affiche la chaîne qu'on vient de lire
        }

fscanf(fichier, "%d %d %d", &score[0], &score[1], &score[2]); lit une chaîne formatée suivant le masque de lecture.

Déplacement

long ftell(FILE* pointeurSurFichier); position actuelle du pointeur

int fseek(FILE* pointeurSurFichier, long deplacement, int origine); positionne le curseur à un endroit précis
origine parmi SEEK_SET (début du fichier) SEEK_CUR (courante) SEEK_END (fin)

rewind(fichier)repositionne le pointeur au début.

Renommer

rename, remove pour effacer

Lecture sécurisée

site du zero

Directives de compilations `#`

#include < bibliotheque.h > pour les bibliothèques système

#include "maBibli.h" pour les fichiers du dossier projet. Ils doivent être signalés à l'EDI.
On crée des fichiers d'entêtes .h et on rejette les définition des foncitons dans des fichiers .c

#define LARGEUR_FENETRE 800 utilisé avec int lf=LARGEUR_FENETRE dans le programme

Pour éviter les inclusions récurrentes :

#ifndef DEF_NOMDUFICHIER // Si DEF_NOMDUFICHIER n'a pas été définie` le fichier n'a jamais été inclus
#define DEF_NOMDUFICHIER // On définit DEF_NOMDUFICHIER pour que la prochaine fois le fichier ne soit plus inclus
 Contenu du  fichier .h
#endif

il y a un langage de macros.