C8
=

### Exercice 1

```
#include <stdio.h>

int main(){
        printf("Taille de char : %d\n", sizeof(char));
        printf("Taille de short : %d\n", sizeof(short));
        printf("Taille de int : %d\n", sizeof(int));
        printf("Taille de unsigned : %d\n", sizeof(unsigned));
        printf("Taille de long long int : %d\n", sizeof(long long int));
        printf("Taille de float : %d\n", sizeof(float));
        printf("Taille de double : %d\n", sizeof(double));
        printf("Taille de char[3] : %d\n", sizeof(char[3]));
        printf("Taille de int[7] : %d\n", sizeof(int[7]));
}
```


```
#include <stdio.h>
#include <limits.h>
#include <float.h>
int main(){

        printf("Valeur minimale de char : %hhd\n",CHAR_MIN);
        printf("Valeur maximale de char : %hhd\n",CHAR_MAX);
        printf("Valeur minimale de short : %hd\n",SHRT_MIN);
        printf("Valeur maximale de short : %hd\n",SHRT_MAX);
        printf("Valeur minimale de int : %d\n",INT_MIN);
        printf("Valeur maximale de int : %d\n",INT_MAX);
        printf("Valeur minimale de unsigned : %u\n",0);
        printf("Valeur maximale de unsigned : %u\n",UINT_MAX);
        printf("Valeur minimale de long long int : %lld\n",LLONG_MIN);
        printf("Valeur maximale de long long int : %lld\n",LLONG_MAX);
        printf("Valeur minimale de float : %e\n",FLT_MIN);
        printf("Valeur maximale de float : %e\n",FLT_MAX);
        printf("Précision de float : %e\n",FLT_EPSILON);
        printf("Valeur minimale de double : %e\n",DBL_MIN);
        printf("Valeur maximale de double : %e\n",DBL_MAX);
        printf("Précision de double : %e\n",DBL_EPSILON);

}
```

Pour les types entiers signés, leur valeur maximale est le nombre correspondant à `011111..111` (avec n-1 `1` avec n le nombre de bits sur lequel est codé le type, donc 2^(n-1)-1. La valeur minimale est elle `1000...000` avec n-1 `0` où le premier bit a un poids négatif, donc -2^(n-1).

Pour les entiers signés la valeur maximale est `11111.111` avec n `1`, donc 2^n-1.

Pour les flottants, le nombre minimal correspond la valeur la plus basse que peut prendre la mantisse (et 0 pour la valeur), donc 1,0 * 2^(-2^(m-1)) avec m le nombre de bits de la mantisse. Le nombre maximal est l'inverse, valeur la plus haute de la mantisse et de la valeur, donc environ 2.0*2^(2^(m-1)-1).
La précision est le plus petit nombre encodable strictement au dessus de 1. Il s'agit de 1.00000000..001 avec (n-1) zéros, avec n le nombre de bits de la valeur. La précision est donc de 2^(-n+1).


### Exercice 2
- Pour coder le nombre `2 147 412 111`, une variable de type `int` est suffisante. 

- Pour coder le nombre `3 294 957 194`, une variable de type `unsigned int` suffit. Si on veut toujours supporter les négatifs, il faut alors se tourner vers de variables plus grandes, comme `long` (a.k.a. `long int`).

- Pour coder le nombre `2 000 000 000`, une variable de type `int` suffit.


### Exercice 3
1. 13 (`int`)
2. 'B' (`int`)
3. 75 (`int`)
4. 160 (`int`)
5. 132 (`long int`)
6. 32.5 (`double`)
7. 0 (`int`)

### Exercice 4
Le `(int)` pertmet de convertin (*cast*) le flottant `` en entier, de la manière souhaitée par le compilateur. `y` est ensuite remit dans un flottant mais garde sa «valeur» entière. `z` vaut donc `round(y) + 4.5`.

### Exercice 5
```
        int a = 0b0110100010100101;
        int b = 0b0111101001100001;
	int c = a ^ b;
```