# Rappels de langage C

# Pointeurs

```C
struct S {
    int x;
    int y
}

struct S v
v.x
struct S * p
p -> x
(*p).x // Plus correct mais plus long
```

Déclarer

```C
char* ch = "OULA" // Ici on a une variable ch en mémoire qui est l'adresse  d'un endroit en mémoire ReadOnly ou il  y est écrit "OULA"

charch[]="OULA" // Ici on déclare la constante OULA en tant que variable locale.
// Ici char* ch ="OULA" correspond à une adresse. A EVITER.
```

**Si on tente de modifier une variable dans une zone ReadOnly, on a erreur à l'exécution**

<p align="center">
  <img src="./Rappels/Images/binary_build.png">
</p>


# Passages d'arguments

Pour une fonction, si on souhaite modifier la valeur d'une variable en la passant en argument d'une fonction, il est impératif de passer l'adresse de la variable en argument et non pas sa valeur.

```C
void fonction(int i){ i++;}
int j=5;
fonction(j);
printf("%d",j); // OUTPUT : 5;

//SI ON REMPLACE LA FONCTION DE CETTE FACON 

void fonction(int* i){ i++;}
fonction(&j);
printf("%d",j); // OUTPUT : 6;

```

# printf
```C
%d // int
%f // float
%c // char
%s // chaine de charactères

int i;
char ch;
char* str;
printf("%d, %c, %s", i , ch , str);
```

# Structures
##
```C
struct s {
  int e;
  char ch[4];
} tab;

// Ici le type est struct s et on crée une variable tab de type struct s

typedef struct {
  int e;
  char ch[4];
}tab;

// Ici le type est tab et on ne crée en aucun cas une variable.
```
# Opérateurs Logiques

```C
&  // logique bits à bits
&& // bits à bits

|  // OU Logique Bitsà bits
|| // OU Logique

^  // OU bit à bit exclusif
^^ // OU Bits à bit
```