====== Fiche rapide de rappels en C ======
Il s'agit ici d'une fiche rapide de rappels sur **une partie** des notions vues en cours. Ce n'est en aucun cas un cours complet! Cette fiche sert surtout de référence pour retrouver rapidement les syntaxes et quelques notions élémentaires.
===== Les variables =====
Déclaration d'une variable :
<code C>
type nom_variable;
type nom_variable=valeur;
type var1,var2,var3;
type var1=x,var2y,var3=z;
</code>
==== Les types courants vus pour l'instant ====
  * pour des nombres entiers on utilise le type **int**;
  * pour les nombres à virgule, on utilise **float**;
  * nous avons également vu **double** pour les nombres à virgule.

En pratique cela donnera par exemple :
<code C>
//déclaration d'un entier : 
int x;
//déclaration d'un entier et assignation de valeur : 
int y=5;

//déclaration d'un nombre à virgule avec float : 
float k;
//déclaration et assignation d'un float :
float pi=3.14159;

//déclaration d'un nombre à virgule avec double et assignation de valeur :
double pi2=3.1415962;
</code>
==== Choix du nom des variables ====
  - Les noms de variables en C commencent toujours par une lettre;
  - les caractères accentués sont interdits;
  - pas d'espaces dans les noms;
  - certains caractères spéciaux comme **_** (//underscore//) sont autorisés;
  - les noms des variables sont uniques au sein d'un programme;
  - une variable ne doit pas avoir le même nom qu'une fonction.

==== Opérations sur les variables ====
On peut effectuer les opérations arithmétiques habituelles:

<code C>
//déclaration de nos variables
int a1=5,a2=4,a3,a4;
float k;

//addition
a3=a1+5;
//soustraction
a4=a2-a3;
//multiplication
a1=a1*a2;
//division
k=2.5654/0.007;
//division par un entier
k=(a1+a3)/(float)a2;
</code>

Pour la division, on s'assurera que le diviseur est différent de 0. De plus, si l'on divise par un entier, on pourra ajouter **(float)** devant le diviseur pour forcer à le considérer comme un nombre à virgule. Dans le cas contraire, on effectue une division euclidienne : 3/2=1, et il reste 1.

On pourra également ajouter l'opérateur modulo (%), qui donne le reste de la division euclidienne : 
<code C>
int reste=3%2;
//ici reste vaut 1, car en 3 je trouve une fois deux, et il reste un.
</code>

===== Les fonctions usuelles =====
Au sein d'un programme on fera souvent des affichages et des saisies. Pour l'instant nous utiliserons deux fonctions : **printf()** pour l'affichage, **scanf()** pour la saisie.

==== Affichage avec printf() ====
On peut afficher du texte et des variables en utilisant la fonction **printf()**. Il est également possible d'effectuer des affichages composés pour afficher des variables dans du texte. Voyons quelques exemples : 

<code C>
#include <stdio.h>

int main()
{
int a=0;
float pi=3.1415;
//affichage de texte:
printf("Ce texte sera affiché dans le terminal");
//affichage d'une variable entière seule : 
printf("%d",a);
//affichage d'une variable de type float seule : 
printf("%f",pi);
//affichage de texte et d'une variable : 
printf("La valeur de pi est de %f. Ceci est une valeur approximative.",pi);
//affichage de texte avec un retour à la ligne en utilisant \n
printf("le caractère spécial antislash-n permet un retour à la ligne.\n");
printf("on peut en mettre autant que voulu : \n\n\n Ici, nous avons sauté 2 lignes vides en plus du retour à la ligne.");

//affichage avec plusieurs variables:
printf("a vaut %d et pi vaut %f.\n",a,pi);
//mêmes variables dans l'autre sens : 
printf("pi vaut %f et a %d\n",pi,a);
return 0;
}
</code>


==== Saisie avec scanf() ====
La fonction **scanf()** est très puissante et peut être utilisée pour effectuer des saisies au clavier. Il faudra généralement confirmer la saisie en appuyant sur entrée. Voici quelques exemples d'utilisation : 
<code C>
#include <stdio.h>

int main()
{
int a=0;
float p=0;

//saisie d'un entier:
scanf("%d",&a);
//saisie d'un float : 
scanf("%f",&p);

//il est préférable de mettre un affichage avant le scanf pour que l'utilisateur sache ce qu'on attend de lui : 
printf("veuillez saisir un nombre entier : ");
scanf("%d",&a);

printf("veuillez saisir un nombre réel : ");
scanf("%f",&p);
return 0;
}
</code>


===== Les instructions conditionnelles =====
Dans notre programme, on peut vouloir faire une chose ou une autre en fonction d'une variable.
Par exemple, si le solde d'un compte est inférieur à 0, on affichera un message dans ce sens.
Pour cela on utilisera des instructions conditionnelles, avec principalement **if**, **else** et **else if**.

L'utilisation minimale se fait comme suit :

<code C>
#include <stdio.h>
int main()
{
int solde=0;
printf("veuillez saisir le solde du compte : ");
scanf("%d",&solde);

if(solde<0)
//si le solde est strictement inférieur à 0
{
  printf("votre compte est à découvert.\n");//on affiche le message
}
return 0;
}
</code>

Ici on affichera un message uniquement quand le solde est négatif.
Si l'on souhaite ajouter un message dans les autres cas, on utilisera l'instruction else : 
<code C>
#include <stdio.h>
int main()
{
int solde=0;
printf("veuillez saisir le solde du compte : ");
scanf("%d",&solde);

if(solde<0)
//si le solde est strictement inférieur à 0
{
  printf("votre compte est à découvert.\n");//on affiche le message
}
else
{
  printf("vous n’êtes pas à découvert\n");
}
return 0;
}
</code>
Notez qu'**il n'y a JAMAIS de else sans if**.

Si l'on a plus de cas, on peut utiliser autant de fois l'instruction else if que souhaité : 
<code C>
#include <stdio.h>
int main()
{
int solde=0;
printf("veuillez saisir le solde du compte : ");
scanf("%d",&solde);

if(solde<0)
//si le solde est strictement inférieur à 0
{
  printf("votre compte est à découvert.\n");//on affiche le message
}
else if(solde == 0)
{
  printf("votre compte est vide, vous n'avez plus un sou!");
}
else
{
  printf("vous n’êtes pas à découvert\n");
}
return 0;
}
</code>
Notez qu'on peut avoir autant de **else if** que voulu, mais un seul **else**, et celui ci vient toujours en dernier dans pour ce bloc if.

==== Les conditions simples ====
Voyons la liste des conditions simples courantes.
=== strictement inférieur ===
<code C>
//si a est strictement inférieur à b
if(a<b)
{
  printf("a<b.\n");
}
</code>

=== strictement supérieur===
<code C>
//si a est strictement inférieur à b
if(a<b)
{
  printf("a<b.\n");
}
</code>

=== inférieur ou égal ===
<code C>
//si a est strictement inférieur à b
if(a<=b)
{
  printf("a<b.\n");
}
</code>

=== supérieur ou égal ===
<code C>
//si a est strictement inférieur à b
if(a>=b)
{
  printf("a<b.\n");
}
</code>

=== égalité ===
<code C>
//si a est strictement inférieur à b
if(a==b)
{
  printf("a<b.\n");
}
</code>
Notez bien le double signe d'égalité!

=== différent de ===
<code C>
//si a est strictement inférieur à b
if(a!=b)
{
  printf("a<b.\n");
}
</code>
==== Les conditions composées ====
On peut combiner plusieurs conditions, en utilisant les opérateurs logiques **ET** et **OU**.
Exemples : 
=== opérateur logique ET ===
<code C>
//si a vaut 0 et que b est inférieur à 10
if(a==0 && b<10)
{
  printf("a=0 et b plus petit que 10.\n");
}
</code>
Il s'agit du caractère **et commercial** (&) qui se trouve sur la touche **1** des touches numériques au dessus des lettres. 

=== opérateur logique OU ===
<code C>
//si a vaut 0 OU bien si b est inférieur à 10
if(a==0 || b<10)
{
  printf("a=0 et/ou b est plus petit que 10.\n");
}
</code>
Il s'agit du caractère pipe (tuyau, en anglais) (|) qui se trouve sur la touche **6** des touches numériques au dessus des lettres, accessible en pressant la touche Alt Gr + la touche 6 en question.

On peut combiner ces opérateurs à volonté. Par exemple si l'on souhaite que **a** soit compris entre 0 et 42 (inclus), ou que **b** soit négatif, je ferai comme suit : 
<code C>
//si 0<a<=42 OU bien si b est inférieur à 0
if(a>0 && a<=42 || b<10)
{
  //faire quelque chose 
}
</code>

===== Les boucles =====
En programmation, nous aurons souvent besoin de répéter une opération un certain nombre de fois. Pour cela, nous utiliserons les boucles, qui permettent de répéter des instructions autant que souhaité. Les deux boucles étudiées sont **for** et **while**.

==== Boucle for ====
La boucle for permet de répéter un nombre précis de fois une instruction, même s'il est possible de passer outre ce comportement classique. En pratique, si l'on souhaite par exemple afficher les nombres de 1 à 100, on ferra comme suit : 

<code C>
#include <stdio.h>
int main()
{
int i;
for (i=1;i<=100;i++)
{
  printf("i vaut %d\n",i);
}
return 0;
}
</code>
Dans les parenthèses du for, on trouve trois blocs séparés par un point virgule.
  - Le premier initialise la variable de boucle, ici à 1;
  - le second bloc sera la condition qui permet à la boucle de continuer. Tant que c'est vrai, on continue. Donc ici, on continue jusqu'à ce que i dépasse 100;
  - le dernier bloc permet de spécifier la modification sur la variable de boucle à chaque tour(ici on l'incrémente de 1).

Notre boucle commencera à i=1, et continuera tant que i sera inférieur ou égal à 100, et à chaque tour i augmentera de 1. Les instructions entre les accolades du for seront celles qui seront exécutées à chaque tour. Nous afficherons donc ici les nombres de 1 (inclus) à 100 (inclus).
i++ est une forme compactée de i=i+1, et il est possible de faire varier i comme on le souhaite, par exemple i=i*2, i=i-2, etc...

===== Les fonctions =====
Les fonctions permettent en quelques sortes d'ajouter du vocabulaire à notre langage C. Ainsi, nous utilisons déjà les fonctions printf() et scanf(), mais il nous est possible d'en créer d'autres.
==== Les noms de fonctions ====
Les noms de fonctions respecteront les mêmes contraintes que celles des noms de variables. De plus une fonction et une variable ne peuvent jamais avoir le même nom au sein d'un même programme.
==== Déclarer une fonction ====
Le prototype générique de la déclaration d'une fonction sera donc le suivant : 
<code C>

type nomfonction(type1 param1,type2 param2,...,typeN paramN)
{
  //instructions effectuées par la fonction
}
</code>
Entre les parenthèses, on mettra les paramètres. On peut avoir autant de paramètres que voulu, ou aucun (dans ce cas, on ne met rien entre les parenthèses).

Le type de la fonction correspond au type de valeur retournée. Si notre fonction renvoie un entier, il sera int par exemple. Il s'agit donc des mêmes types que ceux utilisés pour les variables. Si la fonction ne renvoie rien, elle sera de type **void**.

Pour retourner une variable ou une valeur, on utilisera le mot clef **return**.

==== Exemples de fonctions ====
Une fonction qui fait la somme de deux entiers : 
<code C>
int somme(int a, int b)
{
  int c=a+b;
  return c;
}
</code>
On peut aussi l'écrire comme suit : 
<code C>
int somme(int a, int b)
{
  return a+b;
}
</code>

Une fonction qui ne renvoie rien
<code C>
void etat_solde(int solde)
{
  if(solde>0)
  {
    printf("Vous avez des économies sur votre compte\n");
  }
  else if(solde==0)
  {
    printf("votre compte est vide\n");
  }
  else
  {
    printf("Vous avez des dettes!\n");
  }
}
</code>
Exemple de fonction sans paramètre et qui ne retourne rien : 
<code C>
void analyse_nombre()
{
  int a=0;
  printf("veuillez saisir un nombre entier");
  scanf("%d",&a);
  if(a>0)
  {
    printf("le nombre est strictement positif.\n");
  }
  else
  {
    printf("Le nombre est négatif ou nul.\n");
  }
}
</code>

http://grimaag.univ-ag.fr/~sregis/CoursTPL1S1/TP1_SE.pdf