Memo C

De Avided.info
Révision de 8 novembre 2013 à 09:48 par Bass (discussion | contributions)

(diff) ← Version précédente | Voir la version courante (diff) | Version suivante → (diff)
Aller à : navigation, rechercher


Bibliotheque

inclure les bibliothèques

On utilise les bibliothèques en indiquant au préprocesseur d'inclure le fichier d'en-têtes de la bibliothèque désiré :

- le caractère "#" indique un instruction pour le préprocesseur - l'instruction "include" indique qu'il faut inclure le fichier mise en paramètre. - le fichier a inclure est indiqué en paramètre entre les caractères "<>"

Les indispensables

#include <stdio.h>
#include <stdlib.h>

Les incontournables

#incluse <math.h>
#incluse <time.h>

fonction main​

Cette fonction un peux spécial. Elle est exécuté lors du lancement du programme. Elle est donc obligatoire.

Syntaxe:

int main(void)
 { 
   return 0;
 }

Les commentaires

// petit commentaire sur une ligne, intégré depuis l’existence de C++
/* un commentaire sur plusieurs ligne commence par 
"/*" et finit par "*/" 
comme ce texte */

Les variables

  • Elles sont nommées par des lettres, des chiffres ou le caractère "_".
  • Elles doivent commencer par une lettre.
  • Elles doivent déclarées et il est conseillé de les valoriser par une valeur par défaut.
  • Si tel n'est pas le cas, elles en ont une valeur qui est la valeur que l'adresse mémoire contenait dans une utilisation antérieur. En effet les adresses mémoires ne sont pas vidé de leur valeur à leur libération.
  • Si elles sont d'un meme type elle peuvent etre réuni sur une meme ligne

separé par des virgules Syntaxe

int var = 1 var2 = 2;

les variables doivent etre typées

char = -128 à 127

int = grand chiffre entier long = idem a int float = chiffre réel de "- nombre a 38 zéros" à "+ nombre à 38 zéros"

double = chiffre réel de "- nombre à 380 zéros" à + "nombre à 380 zéros"</div>

Unsigned

char, int et long peuvent etre utilser avec unsigned

dans ce cas, les negatifs ne sont pas admis, mais on doubles la capacités des positifs. 'syntaxe : '

unsigned char = 0 a 255

La portée des variables (A REVOIR)

  • globale => fortement déconseillé.

Il existe plusieurs type de variable global. Pour être global, une variable ne doit jamais être déclare dans une fonction. elles peuvent être misent dans les headers. Le mot clef "extern" Elles sont visibles dans tous le projet les variables "extern" ne sont pas initialise, elles sont juste visible

extern int variable;
  • static

Elles sont aussi global, mais à toutes les fonctions d'un même fichier. leur porté est limite au fichier dans lequel elle est déclare

static int variable = 0;

Une variable static ne sera initialiser qu'une seul fois a la 1er exécution de la fonction. La valeur que la variable aura prise sera garder pour la prochaine exécution de la fonction static peux aussi être mis a une fonction. La fonction ne sera disponible que pour le fichier dans lesquels est.

Afficher un messsage

printf("Message%d le %d affiche le contenue de la variable apres cette virgure", variable);
Pour plusieurs variable indiquer les%d ou%f puis apres

la "," indiquer les variables en respectant l'ordre d'apparition en les

séparant par des ",".
Syntaxe:
printf("Message%d avec%d variables dans le message%.2f", num_message, nb_de_variable, var_decimal);
Pour les chiffres:

%d => affiche un nombre entier %f => affiche un nombre decimal %.3d => affiche un entier sur 3 chiffres

%.2f => affiche un decimal avec 2 chiffres apres la ,
pour les autres:

%c => affiche un caractere

%s => affiche une chaine de caractere

Demander une information à l'utilisateur

Apres ce code la variable nombre contien un entier

printf("Entrez un nombre: ");
scanf("%d", &nombre);

Operation

Addition: +

Soustraction: -

Multiplication: *

Division: /

Modulo: %


Syntaxe:
int var = 0; 
var = 1 + 2;
printf("l'addition de 1+2 = %d", var);

Si vous voulez des résultats en décimal.

Il faut que la variable soit d'un type acceptant le décimal (ex: double) Indique%f dans le message mais aussi indiquer les chiffres des calcules avec en décimal (ex: 2.0)

et non en entier (ex:2)
Syntaxe:
double resultat = 0;
resultat = 5.0 / 2.0;
printf ("5 / 2 =%f", resultat);

​Si vous utiliser des entiers dans des divisions.

la division est interprété de la façon suivante

Combien de fois 2 dans 5 = 2.
Le modulo est le reste de cette division 5% 2 = 1

Incrémenter Nombre + 1 (n+1)

nombre++

//* Décrémenter - Nombre - 1 (n-1)

nombre--

modifier une variable existante par un calcul sur elle même. +, -,

  • et% / fonctionne sur ce raccourci
variable = variable * 2;
Ce peut être raccourcie
variable *= 2

Mots reservés

La liste des mots suivant ne doit pas etre utilisée

auto
break
case
char
const
continue
default
do
double
else
enum
extern
float
for
goto
if
int
long
register
return
short
signed
sizeof
static
struct
switch
typedef
union
unsigned
void
volatile
while
A partir de C99
inline
_Bool
restrict
_Complex
_Imaginary

biblioteque de math

#include <math.h>

les fonctions de cette biblioteque

fabs => valeur absolue |n| = valeur positive d'une valeur

ceil => arondi superieur floor => arondi inferieur pow => puissance .pow(nombre, puissance). sqrt => racine carré/ double resultat = 0; resultat = sqrt(nombre); / renvoie un double sin, cos, tan => sinus, cosinus, tangente / / renvoie un double asin, acos, atan => arc sinus, arc cosinus, arc tangente / renvoie un double exp => exponentielle / renvoie un double log => logarithme népérien

log10 => logarithme de base 10

les conditions

== egalité

> superieur a < inferieur a >= superieur ou egal <= inferieur ou egal

!= diferent de

if

    if ( var1 > var2 ) {
     printf("%d et + grand que %d", var1, var2);
    }
    else if ( var1 == var2 ) {
     printf("%d et %d sont egaux", var1, var2 );
    }
    else {
     printf("%d est plus petit que %d", var1, var2);
    }

Plusieurs conditions à la fois

|| => ou // if ( var1 > var2 || var1 < var3 ) //

l'une ou l'autre && => et // if ( var1 > var2 && var1 < var3 ) // l'une et l'autre ! => non // if (!( var1 > var2 )) // ne doit pas etre

vrai
BOOLEEN

Notion importante, car tres utilisée en fait, les conditions sont transformé par une valeur booléene, 0 = faux, 1 (different de 0) valeur des conditions (inverse des code retour du shell) Une condition est vrai si son resultat est 1 (different de 0) Une condition est faux si son resultat est 0

Il est possible d'obtenir ce chiffre de la maniere suivante.
int majeur;
majeur = age >= 18; // si age est superieur ou egal a 18 alors majeur vaudra 1 si non 0

switch

Equivalent a - if / else if / else if / else

le break est obligatoire. Si elle est homise, les cases suivant celle

correspondante serons aussi executer.
switch (variable)
{
case 1:
  instruction si variable=1;
  break;
 case 2:
  instruction si variable=2;
  break;
 default:
  instruction si variable vaux aucun case;
  break;
}

ternaire

une condition ternaire permet de faire une condition simple sur

une ligne

equivalent a if (condition) var=val1 else var=val2
syntaxe:
var = (condition)? val1: val2

Les Boucles

while

Repeter jusqu'a ce que la condition soit vrai
syntaxe:
while (/* Condition */)
{
// Instructions à répéter
}
exemple:
int compteur = 0;
while (compteur < 10)
{
  printf("La variable compteur vaut%d\n", compteur);
  compteur++;
}

do while

idem a while, mais est executer au moins une fois.

en faite la condition est controle en fin de code et non en debut de code.

autre particularité, il y a un ";" apres la condition
syntaxte:
int compteur = 0;
do
{
  printf("La variable compteur vaut%d\n", compteur);
  compteur++;
} while (compteur < 10);

for

For permet de condencer l'ecriture d'un while
int compteur;
for (compteur = 0; compteur < 10&; compteur++)
{
  printf("La variable compteur vaut%d\n", compteur);
}

Les fonctions

une fonction demande dans la plus part des cas une entréé, et une

sortie elle effectue un traitement sur l'entré et fournie une sortie. Les fonctions doivent etre typé Le typage definit la sortie

si il n'y a pas de sortie la fonction doit etre typé "void"

Creation

Syntax:
type nomFonction(parametres)
{
// Insérez vos instructions ici;
</div><div><span style="font-weight: bold">Exemple</span>: avec une variable en parametre</div><div>double fr2euro(double francs)
{
double euros = 0;
euros = francs / 6.55957;
return euros;
// return francs / 6.55957; 
// cette ligne peux remplacer les 3 ci-dessus.
}

return

Si vous renvoyez la valeur avec return, il ne faut pas oublier de

recuperer la valeur retourné dans une variable
ou printer l'appel de la fonction
Exemple:
VALRETURN = foncquiutiliseReturn(param1);
printf("%d", foncquiutiliseReturn(param1) );

utilisation de la fonction

Syntaxe: utilisation de la fonction (on dit appel de la fonction )
nomFonction(parametre1, pamrametre2);
Un fonction comme une variable
Une fonction peut etre utilisée comme une variable
printf("le retour de fonction est%d\n", fonction(parametre));
Ou même dasn un switch
switch (fonction())

les prototypes

les prototypes permettent d’écrire c'est fonction après leur appel

dans le code. Il suffit d'indique après les includes la premier ligne de la fonction avec un ";" a la fin de la ligne Quoi qu'il arrive il est toujours conseillé de prototype vos fonction les variables dans la partie parametre, ne sont pas obligatoire, seul les types sont obligatoir ex:(int, double)

  • Les prototypes sont souvent délocaliser dans les fichiers header

"fic.h". c'est ces fichiers que l'on indique au pre-processeur par les #include <fic.h> Nous pouvons donc cree pour chaque fichier ".c" de nos programme, un fichier ".h" contenant les prototypes de notre fichier source puis indiqué l'include au début de notre fichier source.c

  1. include "fic.h" // remarque les doubles cote au lieu de chevrons. Ils
indiques un fichier dans le répertoire du projet.
Exemple :
double fr2euro(double francs);
double fr2euro(double);

Les pointeurs

Un pointeurs est utilisé pour contenir l'adresse mémoire d'une variable.

Il doit être typé de avec le même type que cette variable. Il est conseillé de valoriser les pointeurs au moment de leurs initialisations

L’équivalent de 0 pour une pointeur est NULL en majuscule.

Initialiser un pointeur

int *pointeur = NULL;
int* pointeur = NULL;
int *pointeur1 = NULL, *pointeur2 = NULL;
Syntaxe:
int age = 10;
int
*pointeurSurAge; // 1) Signifie "Je crée un pointeur"</div><div>pointeurSurAge = &age; // 2) Signifie "pointeurSurAge est une variable qui contient l'adresse de la variable age"</div><div>printf("%d", $pointeurSurAge); // Imprime l'adresse mémoire de la variable age</div><div>printf("%d", *pointeurSurAge); // Imprime la valeur de la variable age</div><div>
printf("%p", &pointeurSurAge); // Imprime l'adresse mémoire de la variable pointeurSurAge</div><div>
Le principal interrer des pointeurs est de pouvoir depuis une

fonction modifier une variable ayant une porté limité Quand il n'est pas possible de modifier la valeur d'une variable, il est possible de le modifier via sont pointeur directement dans son

adresse memoire.

Exemple:

Cette exemple montre aussi comment il faire pour détourné l'impossibilité de retourner plusieurs valeurs depuis une fonction.

on declare la fonction
void triplePointeur(int *pointeurSurNombre);
int main(int argc, char *argv[])
{
 int nombre = 5;
 triplePointeur(&nombre);
 // On envoie l'adresse de nombre à la fonction
 printf("%d", nombre);
 // On affiche la variable nombre. La fonction a directement modifié la valeur de la variable car elle connaissait son adresse
 return 0;
}
La fonction triplePointeur utilisant le pointeur
void triplePointeur(int *pointeurSurNombre

{
 *pointeurSurNombre *= 3;
 // On multiplie par 3 la valeur de la variable nombre
}
Il est aussi possible de passer par une variable contenant l'adresse mémoire pour le passer a la fonction
// pointeur prend l'adresse de nombre
int *pointeur = &nombre; 
On envoie pointeur (l'adresse de nombre) à la fonction
triplePointeur(pointeur);
Dans ce cas le pointeur existe dans le main, il est donc possible

d’écrire le print différemment, même si cela ne change rien

printf("%d", *pointeur);
Même chose pour la fonction scanf

C'est grâce au pointeur que la fonction valorise la bonne adresse mémoire et non une copie de la variable et la méthode suivante fonctionne car on envoie l'adresse mémoire de

notre variable depuis une variable-pointeur
int nombre = 0;
int *pointeur = &nombre;
scanf("%d", pointeur);

LES TABLEAUX

Un tableau prend un espace contiguë de mémoire

Toutes les valeurs d'un même tableau sont du même type. Le table devra être déclaré avec ce type. Il est obligatoire d'indiquer la taille du tableau à la déclaration (nombre de case mémoire réservé)

int tableau[4];

Les indices d'un tableau sont de 0 a (Nombre_d_indice - 1) 0 1 2 3 pour notre tableau

Valoriser les éléments du tableau

tableau[0] = 12;
tableau[1] = 30;

En fonction de l'utilisation, tableau peut vous renvoyer sont adresse ou sont tableau. D'ordre général, si tableau est sur la gauche de l'instruction tableau => est un pointeur vers l'adresse mémoire de la 1er case du tableau

  • tableau => vous donnera la 1er valeur du tableau par pointeur

=> ascendant a tableau[0]

  • (tableau + 1) => vous donnera la 2eme valeur du tableau par
pointeur => ascendant donc à tableau[1]

Tableau taille dynamique

Le C99 autorise cela, mais pas en C89. c'est la variable en indice qui ne passe pas.

int taille = 5;
int tableau[taille];

Il est tous de même possible de créer des tableaux a taille variable en C89 qui sont plus sure et fonctionne dans tous les cas. il faut pour cela passer par l'allocation mémoire.

parcourir une tableau

Afficher le contenue d'un tableau

for (i = 0; i < 4; i++
{
 printf("%d\n", tableau[i])
}

Initialisation du tableau

pour initialiser des valeurs 0 par exemple

for (i = 0; i < 4; i++)
{
 tableau[i] = 0;
}
Une méthode plus rapide Elle copie dans l'ordre les nombres de gauche dans chaque indice.
int tableau[4] = {0, 0, 0, 0};
Encore plus rapide

Cette dernier méthode, Indique le 1er indice. Si il n'y a pas assez de valeur pour remplir tous les indices,

tous les autres indices du tableau sont valorisés à 0.
int tableau[4] = {0};

envoyer un Tableau dans une Fonction

Tableau est un pointeur vers le tableau, mais la fonction ne

connais pas la taille. Donc 2 paramètres a la fonction

appel de la fonction
affiche(tableau, 4);

fonction

void affiche(int *tableau, int tailleTableau)
{
 int i;
 for (i = 0; i < tailleTableau&; i++)
 {
 printf("%d\n", tableau[i]);
 }
}
Une méthode plus lisible pour créer la fonction avec un pointeur sur tableau
cela permet de voir du 1er coup d'oeil que ce n'est pas un simple pointeur, mais un pointeur vers un tableau
  void affiche(int tableau[], int tailleTableau)


Caractères et char

Le type char permet de stocker des nombres allant de -128 à 127,

unsigned char des nombres de 0 à 255. Il y a une table que votre ordinateur utilise pour convertir les lettres en nombres et inversement. On peut donc utiliser le type char pour stocker UNE lettre. 'A' est remplacé à la compilation par la valeur correspondante (65 en l'occurrence). On utilise donc les apostrophes pour obtenir la valeur d'une lettre.

permet de récupérer la valeur numérique du caractère A
char lettre = 'A';

imprime un caractère

printf("%c\n", lettre);

recuperer un caractere de l'utilisateur

  scanf("%c", &lettre);
  printf("%c\n", lettre);

Les chaines de caractères

les chaines de caractère sont des tableaux de type CHAR

il contient une lettre par cellule du table

la dernière cellule doit obligatoirement contenir "\0"
char chaine[5];
Afficher la chaîne de caractère contenue dans le tableau chaîne
printf("%s", chaine);
Méthode d'attribution d'une chaîne dans un tableau. cette méthode ne fonctionne qu'a l'initialisation.
char chaine[] = "Salut";
L’équivalent dans une code.
char chaine[6];
chaine[0] = 'S';
chaine[1] = 'a';
chaine[2] = 'l';
chaine[3] = 'u';
chaine[4] = 't';
chaine[5] = '\0';
récupérer une chaîne depuis un utilisateur

pb on ne connait pas la taille de la chaîne il faut donc déclarer une taille de tableau assez grande pour recevoir

la chaîne complète + le dernier caractère
  char prenom[100];
  scanf("%s", prenom);

Manipuler des chaines de caracteres

Bibliotheque<string.h>
#include <string.h>
strlen: calculer la longueur d'une chaîne sans le \0 a la fin
longueurChaine = strlen(chaine);
strcpy: copier une chaîne dans une autre
char* strcpy(char* copieDeLaChaine, const char* chaineACopier);
strcat: concaténer 2 chaînes chaine2 est ajouter a la suite de chaine1
char* strcat(char* chaine1, const char* chaine2);
strcmp: comparer 2 chaînes

renvoir 0 si identique nombre positif si chaine1 > chaine2

negatif si chaine1 < chaine2
int strcmp(const char* chaine1, const char* chaine2);
strchr et strrchr: rechercher un caractère

remarque: ont utilse "int" pour la variable qui contient le caracter cela ne pose pas de pb, car le caractere reste un nombre la fonction strchr renvoie le pointeur du 1er caractere correspondant la fonction strrchr renvoie le pointeur du dernier caractere

correspondant ou NULL si non trouve pour les 2 fonctions
char* strchr(const char* chaine, int caractereARechercher);
strpbrk: premier caractère de la liste recherche l'un des caracteres de la liste
char* strpbrk(const char* chaine, const char* lettresARechercher);
strstr: rechercher une chaîne dans une autre
char* strstr(const char* chaine, const char* chaineARechercher);
sprintf: écrire dans une chaîne

fait partie de la biblioteque stdio.h au lieu de renoyer a l'ecran comme printf, renvoie dans une chaine

On écrit "Tu as 15 ans" dans chaine: int age 15;
sprintf(chaine, "Tu as%d ans!", age);


Le preprocesseur

le preprocesseur une une etape qui s'effectue par le compilateur juste avant la compilation.

Les directives du preprocesseur commence par le caractère "#" la directive que nous avons deja vue est la directive include

#include <stdlib.h>

Les directives

include

Elle permet d'ajouter le contenue du fichier indiqué au code. Cela permet de mieux organiser le projet et dans de gros projet il n'est pas nécessaire de copier collé tous ce code dans chacun des fichiers du projet qui le nécessiterait

le paramètre d'une directive "include" doit être mis entre "<stdlib.h>" pour les fichiers devant etre sur la machine qui vas compiler et doit etre mis entre "fichier.h" pour les fichier du projet.

#include <stdlib.h>
#include "programme.h"

define

Permet de définir une constante mais sans utiliser de mémoire. La chaîne de caractère "MA_CONSTANTE" sera remplacé par la valeur dans le code source avant compilation. Ils sont souvent indiqué dans les fichiers.h ce qui permet d’accéder a cette constante depuis toutes les fonctions

#define MA_CONSTANTE 3

Ils sont souvent utiliser pour définir la taille de tableaux

#define TAILLE_MAX 300

Il est possible de faire des calcules dans les instructions define

#define MA_CONSTANTE_1 3
#define MA_CONSTANTE_2 2
#define RESULTAT_CONSTATNTE ( MA_CONSTANTE_1 * MA_CONSTANTE_2 )

Constantes prédéfinie

  • elles commence et finisse par 2 caractère "_"
__LINE__ : donne le numéro de la ligne actuelle.
__FILE__ : donne le nom du fichier actuel.
__DATE__ : donne la date de la compilation.
__TIME__ : donne l'heure de la compilation.
  • Elles peuvent être utilisées pour la gestions de erreurs
printf("Erreur a la ligne %d du fichier %s\n", __LINE__, __FILE__);
printf("Ce fichier a ete compile le %s a %s\n", __DATE__, __TIME__);

Les macros

Astuces

GENERER UN NOMBRE ALEATOIRE

#include <time.h>
srand(time(NULL));
nombreMystere = (rand()% (MAX - MIN + 1)) + MIN;

​Compter le nombre de caractere d'une chaine

int longueurChaine(const char* chaine)
{ int nombreDeCaracteres = 0;
char caractereActuel = 0;
do
 { caractereActuel = chaine[nombreDeCaracteres];
 nombreDeCaracteres++;
 }
 while(caractereActuel!= '\0'); 
// On boucle tant qu'on n'est pas arrivé à l'\0
 nombreDeCaracteres--; 
// On retire 1 caractère de long pour ne pas compter l'\0
 return nombreDeCaracteres;

Compilation

Par convention le code source d'un programme est stoker dans un fichier avec .c en extension.

Il suffira d’exécuter le compilateur avec le fichier en argument. Vous obtenez un fichier "a.out" qui peut-être exécuter

cc fichier.c

L'option -o avec un argument vous permet de modifier le nom du fichier de sortie dans l'exemple suivant, le fichier "a.out" sera remplacé par "fichier"

cc fichier.c -o fichier

Références

[http://fr.wikibooks.org/wiki/Programmation_C]