projprog/C8.md

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;