diff --git a/C11.1.c b/C11.1.c
new file mode 100644
index 0000000..5dc7ff3
--- /dev/null
+++ b/C11.1.c
@@ -0,0 +1,11 @@
+#include <stdio.h>
+
+int main(){
+	
+	int x = 42;
+	
+	// Le cast déclenche un warning, et effectivement, un poiteur vers un entier et un entier représentent deux choses différentes.
+	printf("La variable dénotée 'x' contient la valeur %d stoquée à l'adresse %d\n",x,(int)&x);
+	
+	return 0;
+}
diff --git a/C11.5.c b/C11.5.c
new file mode 100644
index 0000000..1d964b9
--- /dev/null
+++ b/C11.5.c
@@ -0,0 +1,18 @@
+#include <stdio.h>
+#include <assert.h>
+
+void swap(int* a, int* b){
+	
+	int c = *a;
+	*a = *b;
+	*b = c;
+	
+}
+
+int main(){
+	int a, b, olda, oldb;
+	scanf("%i %i", &a, &b);
+	olda = a; oldb = b;
+	swap(&a, &b);
+	assert(a == oldb && b == olda);
+}
diff --git a/C11.md b/C11.md
new file mode 100644
index 0000000..0d8bf63
--- /dev/null
+++ b/C11.md
@@ -0,0 +1,43 @@
+#C 11
+
+### Exercice 2
+Description ligne par ligne du programme:
+
+1. la case mémoire 'a' prend la valeur 3
+2. la case mémoire 'p1' prend en valeur l'adresse de la case mémoire 'a'
+3. la case mémoire 'b' prend la valeur stoquée dans 'a' (donc 3)
+4. la case mémoire 'p2' prend en valeur l'adresse de la case mémoire 'b' (différente de celle de 'a')
+5. la case mémoire 'a' prend la valeur 5
+6. la valeur stoquée dans la case mémoire dont l'adresse est stoquée en case 'p1' (donc 'a') est incrémentée (passe de 5 à 6)
+7. la case mémoire 'b' prend la valeur 8
+8. la case mémoire dont l'adresse est stoquée en 'p2' (donc 'b') prend la valeur 12.
+9. la case mémoire 'p1' prend pour valeur l'adresse stoquée dans la case mémoire 'p2' (donc l'adresse de 'b')
+10. la case mémoire dont l'adresse est stoquée en 'p1' (donc 'b' maintenant) prend la valeur 15.
+
+État final: p1=p2=&b et a=6 et b=15
+
+### Exercice 3
+Ce programme produit des *warnings* à la compilation sur des erreurs de cast. En effet, un pointeur vers un flottant (&x) essaye de rentrer dans un pointeur vers un flottant, ce qui a techinquement la même taille, mais qui exprime souvent une erreur de conception.
+
+Sinon, le programme affiche l'entier représenté par la suite de bits corerspondant à la représentaton en binaire du flotant 2.4. En l'ocurence `1075419546`.
+
+### Exercice 4
+
+Description ligne par ligne du programme:
+
+1. Une case 'a' est réservée à un entier.
+2. L'adresse de 'a' est stoquée dans une autre case mémoire 'addr'
+3. Une nouvelle case memoire est créee pour y stoquer le resultat de l'appel à la fonction
+
+f
+0. Le paramètre est passée en valeur. Ce qui signifie que x contient la valeur qui lui a été donnée en paramètre, donc l'adresse de la case mémoire 'a'.
+1. La valeur contenue dans la case mémoire dont l'adresse est stoquée dans la case mémoire 'x' est définie à 0.
+2. La case mémoire 'x' est définie à 0 (ne pointe plus vers aucune case mémoire) (le pointeur NULL).
+3. Renvoie la valeur présente dans la case mémoire 'x'.
+
+Donc a=0, addr=&a, addr2=NULL.
+
+### Exercice 6
+
+`scanf` prend des pointeurs afin de pouvoir «retourner» plusieurs valeurs. Avec des valeurs, on aurait accès qu'à la valeur de retour de scanf, pas très utile.
+
diff --git a/C12.c b/C12.c
new file mode 100644
index 0000000..e9e9cc3
--- /dev/null
+++ b/C12.c
@@ -0,0 +1,71 @@
+ 
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+#define N 5
+#define NumLength (10+4+1)
+#define IntLength (8)
+
+typedef struct personne personne;
+struct personne{
+	int age;
+	char* initiales;
+	char* num;
+};
+
+void description(personne* p){
+	
+	printf("%s, agé de %d ans est joignable au %s \n",p->initiales, p->age, p->num);
+	
+}
+
+void demander(personne* p){
+	
+	int age;
+	char initiales[IntLength];
+	char num[NumLength];
+	
+	printf("Création d'une nouvelle personne : \n");
+	printf("Initiales : ");
+	scanf("%s", initiales);
+	printf("Âge : ");
+	scanf("%d", &age);
+	printf("Numéro de téléphone : ");
+	scanf("%s", num);
+	
+	p->initiales = initiales;
+	p->age = age;
+	p->num = num;
+	
+}
+
+int lesmeme(personne* p1, personne* p2){
+	
+	return (p1->age==p2->age) && (strcmp(p1->initiales, p2->initiales)==0) && (strcmp(p1->num, p2->num)==0);
+	
+}
+
+
+int main(){
+	
+	personne persos[N];
+	
+	for(int i=0;i<N;i++){
+		demander(persos+i);
+		description(persos+i);
+	}
+	
+	for(int i=1;i<N;i++){
+		for(int j=0;j<i;j++){
+			if(lesmeme(persos+i,persos+j)){
+				printf("Alerte doublon !\n");
+				description(persos+i);
+			}
+		}
+	}
+	
+	
+}
+
+
diff --git a/C12.md b/C12.md
new file mode 100644
index 0000000..aa8cd92
--- /dev/null
+++ b/C12.md
@@ -0,0 +1,23 @@
+# C 12 
+
+### Exercice 2
+
+1)
+
+```
+--------------
+|  1  |  2  |
+------------
+|     |  3  |
+|     |-----|
+|     |  4  |
+-------------
+|  6  |  5  |
+-------------
+```
+1. Pointeur vers le père
+2. Pointeur vers la mère
+3. Chainage des frères et sœurs coté du père
+4. Chainage des frères et sœurs coté de la mère
+5. Pointeur vers le premier enfant
+6. Chainage de tous les personnages
diff --git a/CP12.1.c b/CP12.1.c
new file mode 100644
index 0000000..cd931a7
--- /dev/null
+++ b/CP12.1.c
@@ -0,0 +1,35 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+
+int main(){
+	
+	int n;
+	
+	printf("Nombre de valeurs : ");
+	scanf("%d", &n);
+	
+	int* vals = (int*)malloc(n*sizeof(int));
+	
+	for(int i=0;i<n;i++){
+		printf("Quel est le %ième entier ? ",i);
+		scanf("%d",(vals+i));
+	}
+	
+	int b = 1;
+	
+	for(int i=1;i<n;i++){
+		for(int j=0;j<i;j++){
+			if(*(vals+i)==*(vals+j))
+				b = 0;
+		}
+	}
+	if(b)
+		printf("Les %i éléments que vous avez donnés sont distincts.\n",n);
+	else
+		printf("Il y a deux éléments égaux dans les %i éléments que vous m'avez donnés\n", n);
+	
+	free(vals);
+	
+	return 0;
+}
diff --git a/CP12.8.c b/CP12.8.c
new file mode 100644
index 0000000..7abadea
--- /dev/null
+++ b/CP12.8.c
@@ -0,0 +1,116 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+int** zerosMat(int h, int w){
+	int** arr = (int**)malloc(h*sizeof(int*)+1);
+	if(arr==NULL)return NULL;
+	
+	for(int i=0;i<h;i++){
+		arr[i] = (int*) calloc(w,sizeof(int));
+		if(arr[i]==NULL)return NULL;
+	}
+	arr[h] = NULL; // Pour indiquer la fin du tableau
+	
+	return arr;
+}
+
+void redimMat(int** mat, int nh, int nw){
+	
+	// Récupération de la hauteur pour libération en cas de rétrécissement.
+	int h=0;
+	while(mat[h]!=NULL)h++;
+	if(nh<h)for(int i=nh;i<h;i++)free(mat[i]);
+	
+	// Lignes
+	int** narr = (int**)realloc(mat, nh*sizeof(int*)+1);
+	if(narr==NULL){
+		free(mat);
+		return;
+	}
+	int nulled = 0;
+	for(int i=0;i<nh;i++){
+		if(narr[i]==NULL)
+			nulled = 1; // À partir de maintenant, on alloue.
+		if(nulled){
+			narr[i] = calloc(nw,sizeof(int));
+			if(narr[i]==NULL)return;
+		} else {
+			narr[i] = (int*) realloc(narr[i], nw*sizeof(int));
+			if(narr[i]==NULL){
+				free(mat[i]);
+				return;
+			}
+		}
+	}
+	narr[nh] = NULL;
+	
+	
+}
+
+void freeMat(int** mat){
+	for(int i=0;mat[i]!=NULL;i++)
+		free(mat[i]);
+	
+	free(mat);
+}
+
+int main(){
+	
+	int** mamatrice;
+	int h,w;
+	char c;
+	int p1, p2, p3;
+	// Bon, j'ai mal lu le sujet, j'ai fait des matrices rectangulaires ...
+	
+	printf("Quelle taille initiale à votre matrice ? ");
+	scanf("%d %d",&h,&w);getchar();
+	
+	mamatrice = zerosMat(h,w);
+	
+	printf("Votre matrice a été initialisée avec des zéros !\n");
+	printf("'r # #' pour redimenssionner, 'g # #' pour récupérer la valeur, 's # # #' pour la définir, 'q' pour quitter\n");
+	
+	while(1){
+		printf("Commande ? ");
+		c = getchar();
+		getchar();// On bouffe l'espace
+		
+		switch(c){
+			case 'r':
+				scanf("%d %d",&p1,&p2);
+				redimMat(mamatrice, p1, p2);
+				h = p1;
+				w = p2;
+				printf("La matrice a été redimensionnée à la taille %d x %d\n",p1, p2);
+				
+				break;
+			case 'g':
+				scanf("%d %d",&p1,&p2);
+				if(0<=p1 && p1<h && 0<=p2 && p2<w)
+					printf("La valeur de la matrice en [%d,%d] est %d\n",p1, p2, mamatrice[p1][p2]);
+				else
+					printf("L'entrée est mal formée, les coordonées sont hors de la matrice\n");
+				break;
+			case 's':
+				scanf("%d %d %d",&p1,&p2,&p3);
+				
+				mamatrice[p1][p2] = p3;
+				
+				if(0<=p1 && p1<h && 0<=p2 && p2<w){
+					printf("La valeur de la matrice en [%d,%d] a été définie en %d\n",p1, p2, p3);
+				}else
+					printf("L'entrée est mal formée, les coordonées sont hors de la matrice\n");
+				break;
+				
+				break;
+			case 'q':
+				goto fend;
+			
+		}
+		getchar();
+	}
+	
+	fend: freeMat(mamatrice);
+	return 0;
+	
+}
diff --git a/CP12.md b/CP12.md
new file mode 100644
index 0000000..b3dbd3e
--- /dev/null
+++ b/CP12.md
@@ -0,0 +1,37 @@
+#C 12
+
+### Exercice 2
+
+La pile: mémoire rapide sur le principe du premier arrivé dernier sorti. Dedans est stoqué les variables transmises à travers les fonctions. Il y en a donc une par thread.
+
+Le tas contient toutes les variables qui sont définies dynamiquement avec malloc. L'accès est plus lent puisque toutes les adresse doivent être «retenus».
+
+### Exercice 3
+Le programme ne pose pas de problème. La mémoire est alouée avant l'execution du programme. La commande `int carte[10000][10000]` indique la taille mémoire à réserver avant l'execution.
+
+### Exercice 4
+Ce programme va plus poser problème parce que les valeurs des paramètres seront stoqués dans la pile. Les 100_000_000 valeurs de paramètres. Dans la pile. Elle a une taille limitée donnée par le système d'exploitation.
+
+### Exercice 5
+
+La taille utilisée sur la pile varie à chaque appel à des fonctions, afin de stoquer la valeur des paramètres (passage en valeur). La taille du tas peut elle aussi varier, notemment à travers les appels à `malloc`.
+
+
+### Exercice 6
+`malloc` demande au système d'explotation de lui réserver un espace memoire de taille arbitraire (des octets contigüs). Si accépté, la fonction renvoie un pointeur vers une adresse mémoire correspondant au premier octet de l'allocation. Cette adresse peut ensuite être cast en un pointeur afin de pouvoir faire de l'arithmétique cohérente avec la taille des entiers utilisés.
+
+### Exercice 7
+La fonction free indique au système d'exploitation que l'emplacement qui avait précedement été réservé avec `malloc` peut être libéré. Le programme n'a donc plus accès aux données et l'OS peut réallouer la portion. C'est très important afin d'éviter une fuite de mémoire, c'est à dire que la totalité de la mémoire ait été réservée et non libérée même si plus utilisée par un programme mal fait.
+
+### Exercice 9
+
+Rien n'assure que notre grille soit contiguë en mémoire. Les pointeurs vers les pointeurs des lignes sont eux contigüs, ainsi que les données dans chaque ligne, mais rien de plus ne peut être assuré. En effet, d'autres appels à *alloc ont pû être effectués pendant la génération de la matrice, ou pendant son redimensionnement.
+
+J'aurais pû effectivement faire un seul calloc au début, avec quelque chose ressemblant à :
+
+```
+int * data = calloc(h*w, sizeof(int))
+
+for(int i=0;i<h;i++)
+  arr[i] = data + w*i;
+```