91 lines
3.3 KiB
Markdown
91 lines
3.3 KiB
Markdown
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;
|
|
```
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|