Code "corrigé"

codeleandre.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAX 80

typedef char tchaine[MAX];

char *lire(char  *chaine)
{
	//les variables de même type sur la même ligne.
	int i=0;
	int test = 0;//nom de variable pas explicite, soit tu donne un meilleur nom, soit tu commentes
	int fn; //pareil
	int n; //on suppose que 'n' est une variable de 'parcours' (comme i et j), mais précise
	int lg=strlen(chaine); // nom de variable ..

	//tu utilises 'i' dans la boucle while, mais la valeur de 'i' ne change jamais
	// soit c'est une erreur, soit tu peux remplacer 'i' par sa valeur (qui est fixe et n'a pas changé)
	// depuis sa déclaration -> 0.
	while(chaine[i]==' ')
	{
		n=i;
		while(chaine[n]!='\0')
		{
		  	chaine[n]=chaine[n+1];
		 	n++;
		}
	}

	// la longueur de la chaine a changé quand tu arrives ici. Vu que tu as bien updaté
	// la valeur de lg après le for, mais que ça doit être fait plusieurs fois, je te propose simplement
	// d'utiliser strlen(chaine) au lieu de stocker dans lg (vu que cette valeur est succeptible de changer à chaque tour
	// de boucle). Du coup tu notes par exemple for(i=0; i<=strlen(chaine); i++)

	for (i=0;i<=lg;i++)
		{
			if (test==1)
			{
				i=i-1;
				test=0;
			}
			if((chaine[i]==' ') && (chaine[i+1]==' '))
			{
				n=i;
				while(chaine[n]!='\0')
				{
		 		 	chaine[n]=chaine[n+1];
		 			n++;
		 			test=1;
				}
			}
		}

		lg = strlen(chaine);

		if (chaine[lg-1]==' ') // peut faire plus court
		{
    	chaine[lg-1]=chaine[lg];//pas très cool, si ce que tu veux faire c'est mettre un '\0', alors mets le
    	//chaine[strlen(chaine)] = '\0'
    	}




	return chaine;
}

int strpos(char * m, char *chaine)
{
	// les variables en dessous sont de même type, y'a moyen de tout écrire sur une ligne
	int lg = strlen(chaine); //nom de variable pas explicite
	int lgm = strlen(m); //là non plus
	int i;
	int n;

		for (i = 0; i < lg; i++)
			{

				for(n=0; chaine[i+n] == m[n]; n++)
				{

					if(n==lgm-1) //moyen de faire plus court
					{
						return i;
					}
				}
			}
		return -1;
}


char *strmin(char *chaine)
{
	int i=0;
	for (i = 0; chaine[i] != '\0'; i ++)// c'est que de la rigueur, mais pas d'espace entre i et ++
	{
		if (chaine[i] >= 65 && chaine[i]<=90) //possibilité de faire plus court
		{
			chaine[i] = chaine[i] + 32; //possibilité de faire plus court
		}

	}
	return chaine;
}

int VIDE(char *chaine) // à remplacer par un macro de préprocesseur
{
	if(chaine[0]=='\0') //plus court
	{
		printf("la chaine est vide\n");// jamais demandé d'afficher le résultat
	}
	else 
	{
		printf("la chaine n'est pas vide\n"); //idem
	}

	//Il manque une valeur de retour ! Type de fonction -> int !
}

int EGAL(char *chaine, char *chaine2) //à remplacer par un macro de préprocesseur
{
	//Je commente quand même, même si la fonction va disparaître

	//même nom de var
	int i=0;
	int j=0;
	int test = 0;


while(chaine[i] !=  '\0')
{
	if (chaine[i] != chaine2[j]) //possibilité de faire + court
	{
		test = 1;
	}

	i++; //pourquoi 2 variables différentes alors qu'elles ont la même valeur tout le temps ?
	j++;
}

	if (test == 0)//on peut faire plus court
	{
		printf("les deux chaines sont identiques.\n"); // mais on a jamais demandé d'afficher le résultat
	}
	else 
	{
		printf("les deux chaines ne sont pas identiques.\n"); //idem
	}

	//Il manque une valeur de retour ! -> le type de la fonction est int
}


char* premier(char* ch) 
{
	int i;
	// On a définit MAX = 80 dans les directives de préprocesseur, c'est pour éviter
	// de devoir changer tous les 80 si jamais t'as envie de changer le max.
	// Donc on évite les valeurs comme ça. (mets plutôt MAX)
	char premier[80]; //char premier[MAX];
	for (i = 0; ch[i] != ' '; ++i) //plus court ET que se passe t'il s'il n'y a pas d'espace ??? ... boucle infinie
	{
		premier[i] = ch[i];
	}
	return premier;
} 


int main()
{
	tchaine chaine,m; //Pourquoi 2 lignes pour le même type ?
	tchaine chaine2;

	printf("rentrer une chaine de caractère : \n");
	// Ci dessous, y'a moyen de condenser un peu. le nom "lire()" sous-entend que la chaine n'a pas encore été lue
	// C'est très bien sauf que tu lui passes une chaine déjà lue. Donc à première vue (même si le code est bon)
	// on peut penser que ton code est faux car il va lire 2 fois une chaine.
	// Pourquoi ne pas simplement intégrer gets à ta fonction lire ?
	gets(chaine);
	lire(chaine);

	printf("la chaine apres la fonction lire est :%s.\n",chaine); //pas très clair, préférer "la chaine nettoyée"
	printf("quelle mot rechercher vous ?\n");
	//pourquoi ne pas appliquer la fonction lire sur le mot 'm' ? au moins tu es sûr que cette chaine 'm' est "clean"
	// (nettoyée des espaces indésirables)
	gets(m);

	printf("premier caractère de votre mot est en %d position \n",strpos(m,chaine));
	strmin(chaine);
	printf("Le remplacement des caractères en majuscules par des minuscules nous donne : %s\n",chaine);
	VIDE(chaine);
	printf("rentrer une chaine de caractère : ");
	gets(chaine2);
	EGAL(chaine, chaine2);

	printf("Le premier mot de la chaine est : %s\n", premier(chaine));



	




; //il doit se faire chier tout seul non ?

	//même pas un return pour lui tenir compagnie

}

/*
	
	C'est globalement pas mal, et ça marche (malgré qq problèmes mais ça arrive)
	Ce qu'il faut que tu fasses, c'est faire tout le tuto et lire tout de A à Z et faire tous les exos
	du tuto OpenClassroom sur le C !
	Surtout la partie sur les variables, les fonctions, les pointeurs, les conditions, les boucles, et les tableaux (oui je sais à peu près tout en fait)

	Pour améliorer ton code, sache que

			if(bidule) {
				une seule instruction;
			}

	peut se réduire en

			if(bidule)
				une seule instruction;

	mais pas

			if(bidule) {
			 une instruction;
			 une autre instruction;
			}

	c'est que si y'a qu'une instruction
	ça marche aussi avec le else, le for, et le while

	ensuite

			int a;
			int b;
			int c;

	peut se réduire en 

			int a,b,c;

	pareil si

			int a = strlen(chaine);
			int b = 0;
			int c;

	ça équivaut à

			int a = strlen(chaine), b = 0, c;

	Par contre :

			int* a;
			int* b;
			int* c;

	ne se réduit pas en 
			int* a,b,c;
	mais en
			int *a, *b, *c; (signe pointeur devant chaque variable);


	ensuite

	une fonction de type X renvoie une valeur de type X dans TOUS LES CAS.
	Tu dois prévoir chaque cas et chaque cas doit renvoyer une valeur du type de la fonction. (void = pas de type, donc pas de renvoie de valeur)

    ensuite

    une condition vaut 1 si elle est vraie, 0 si elle est fausse, ET PAS SEULEMENT DANS UN IF, WHILE, etc
	
	donc si tu marques

			int a = 54, b = 54, c;
			c = (a==b);

	c vaut 1

	Si tu mets 

			int a = 12, b = 54, c;
			c = (a==b);

	c vaut 0


	DONC

	marquer

			if (chaine[i] != chaine2[j])
			{
				test = 1;
			}

	revient à faire

			test = (chaine[i] != chaine2[j])

	puis qu'on ne fait rien d'autre que test=1 si la condition est vrai


	Je sais pas si j'ai fait le tour de tout, mais corrige déjà ça, ce sera pas mal ;)
*/