Barème

Règlement

La réalisation de cet exercice est assujettie aux règles en vigueur dans l’école en matière de triche et de normalisation. Tricher vous expose à de graves sanctions.

Vous devez respecter les règles de normalisation suivantes : https://git.ecole-89.com/eriizu/coding_style/src/branch/main/norm.md

Le non-respect de la norme vous fera perdre une partie ou la totalité des points qui auraient pu être acquis, sur l’ensemble du rendu.

Instructions de rendu

Respectez à la lettre les noms de fichiers et leur emplacement dans le dépôt de rendu. S’il vous est demandé de rendre un fichier nommé hello.c sans qu’un nom de dossier soit précisé : rendez un fichier hello.c à la racine de votre dépôt.

La présence d’une étoile * signifie que le nom du fichier peut être n’importe lequel dès lors qu’il porte l’extension ou l’affixe (préfixe/suffixe) demandée. Elle signifie aussi qu’il est possible de rendre plusieurs fichiers.

La présence d’une double étoile ** signifie que les fichiers peuvent être placés n’importe où dans un dossier, y compris dans des sous-dossiers.

Pensez à faire des commits et des push fréquemment. Autrement nous ne pouvons pas vous aider à retrouver vos fichiers perdus.

Fonctions autorisées et interdites

Par défaut, toute fonction système (comme write) ou fonction des bibliothèques (comme printf ou puts) sont interdites.

À chaque exercice vous sera donné une liste de fonction autorisées, le cas échéant.

main de test

Chaque fois que vous devez rendre une fonction, vous devez aussi rendre un fichier *.main.c. Il s’agit du fichier qui doit contenir votre main de test.

Vous devez écrire des tests pour voir si votre fonction à le bon comportement.

Correction du code source en C

Tout le code source sera compilé avec les drapeaux suivants :

-Wall -Wextra -Werror

Testez votre code avec ces drapeaux pour que le compilateur vous informe de tout ce qui peut poser problème avec votre programme avant de le rendre.

Pour tester qu’un fichier sans main compile, vous devez le compiler contre un second fichier qui lui contient un main.

gcc -Wall -Wextra -Werror example.c example.main.c

Exercices

Interversion

Fichier·s à rendre : swap_int.c, swap_int.main.c Fonction·s autorisée·s : aucune

Écrivez une fonction qui prend 2 pointeurs sur des nombres entiers en paramètre et qui intervertit les valeurs pointées de sorte que l’exemple suivant fonctionne.

// [prototypes et includes tronqués]
int main(void)
{
	int tata;
	int toto;

	tata = 4;
	toto = 9651265;
	swap_int(&tata, &toto);
	if (tata == 9651265 && toto == 4) {
		puts("vous avez réussi");
	} else {
		puts("c'est le flop");
	}
	return (0);
}

strlen : calculer la taille d’une chaîne

Fichier·s à rendre : strlen.c, strlen.main.c Fonction·s autorisée·s : aucune

Implémentez la fonction stu_strlen qui se comporte comme strlen. Elle doit renvoyer le nombre de caractères utiles d’une chaîne de caractères.

unsigned int stu_strlen(const char *str);

puts : imprimer une chaîne

Fichier·s à rendre : puts.c, puts.main.c Fonction·s autorisée·s : write Compilé avec : strlen.c

Implémentez la fonction stu_puts dans puts.c. Elle doit se comporter comme puts, c’est à dire qu’elle doit afficher la chaîne de caractère reçue en paramètre, suivie d’un retour à la ligne et renvoyer le nombre de caractères qu’elle a imprimé.

Si l’écriture échoue renvoyez -1. Notez que si write échoue, il vous renverra -1.

strcpy : copier le contenu d’une chaîne

Fichier·s à rendre : strcpy.c, strcpy.main.c Fonction·s autorisée·s : aucune

Écrivez la fonction stu_strcpy qui copie la chaîne source dans un espace mémoire destination. Elle doit renvoyer l’adresse destination. La copie doit être faite caractère par caractère.

Exemple de main de test :

#include <stdio.h>

char *stu_strcpy(char *dest, const char *src);

int main(void)
{
	char *str_a;

	str_a = malloc(7 * sizeof (char));
	if (!str_a)
		return 1;
	puts(stu_strcpy(str_a, "hello!"));
	str_a[0] = 'b';
	str_a[4] = 'a';
	puts(str_a);
	return (0);
}

Sortie attendue :

hello!
bella!

atoi : extraire un nombre d’une chaîne

Fichier·s à rendre : atoi.c, atoi.main.c Fonction·s autorisée·s : aucune

Écrivez la fonction stu_atoi. Elle prend en paramètre une chaîne de caractère et renvoie un int. Son métier est d’extraire un nombre de la chaîne de caractères.

Elle doit pouvoir fonctionner sur des nombres positifs, négatifs ou nuls.

Elle doit s’arrêter lorsqu’elle rencontre autre chose qu’un chiffre.

#include <stdio.h>

int stu_atoi(const char *);

int main(void)
{
	int result;

	result = stu_atoi("123");
	printf("%d\n", result);
	result = stu_atoi("123abc");
	printf("%d\n", result);
	result = stu_atoi("-123");
	printf("%d\n", result);
	result = stu_atoi("");
	printf("%d\n", result);
}

Sortie attendue

123
123
-123
0

strcmp : comparer deux chaînes

Fichier·s à rendre : strcmp.c, strcmp.main.c Fonction·s autorisée·s : aucune

Écrivez stu_strcmp qui compare deux chaînes de caractères. Elle renvoie 0 si les deux chaînes ont le même contenu. Autrement, à la première différence, elle renvoie autre chose que 0.

Son prototype est :

int stu_strcmp(const char *s1, const char *s2);

strchr : rechercher un caractère

Fichier·s à rendre : strchr.c, strchr.main.c Fonction·s autorisée·s : aucune

Écrivez stu_strchr qui recherche dans la chaîne passée en 1er paramètre, le caractère passé en 2nd paramètre. Si le caractère est trouvé, renvoyez son adresse dans la chaîne. Autrement renvoyez NULL.

strdup : allocation et copie d’une chaîne

Fichier·s à rendre : strdup.c, strdup.main.c Fonction·s autorisée·s : malloc Compilé avec : strlen.c

Écrivez la fonction stu_strdup. Elle doit prendre en paramètre une chaîne de caractères, allouer de la mémoire, y copier la chaîne passée en paramètre (pensez stu_strcpy) et renvoyer la copie.

Si malloc échoue, renvoyez NULL.

strcat : concaténations de chaînes

Fichier·s à rendre : strcat.c, strcat.main.c Fonction·s autorisée·s : aucune Compilé avec : strlen.c, strcpy.c

Écrivez la fonction stu_strcat. Elle doit prendre en paramètre deux chaînes de caractères. Elle doit copier le contenu de la deuxième chaîne et le mettre à la suite de la première.

La chaîne passée en premier paramètre doit être dans une zone mémoire suffisant grande pour stocker le contenu des deux chaînes + un terminateur nul. Ça n’est pas à votre fonction de vérifier si la zone mémoire est assez grande, c’est le rôle de l’appellant.

Renvoyez la première chaîne.

Exemple de main de test :

int main()
{
	char *str1 = malloc(sizeof (char) * 7);
	if (!str1)
		return 1;
	stu_strcpy(str1, "abc");
	char *str2 = "def";
	puts(stu_strcat(str1, str2));
}

Sortie attendue :

abcdef

strdupcat : concaténation et allocation

Fichier·s à rendre : strdupcat.c, strdupcat.main.c Fonction·s autorisée·s : malloc Compilé avec : strlen.c, strcpy.c, strcat.c

Écrivez la fonction strdupcat, elle doit prendre en paramètre deux chaînes de caractères, allouer une zone mémoire suffisamment grande pour y stocker ces deux chaînes et un terminateur nul, et y copier le contenu des deux chaînes.

int main(void)
{
	char *str = strdupcat("abc", "def");
	puts(str);
	free(str);
}

Sortie attendue :

abcdef