Partage

exercice recréer la fonction strstr

Sujet résolu

17 avril 2006 à 12:35:50

bonjour,
j'ai voulu recréer la fonciton strstr mais ça ne marche pas et je ne comprends pas pourquoi (aucune erreur est détecté, le fonction pour trouver la longueur sont bonne.):

int main(int argc, char *argv[])
{
char *suiteChaine = NULL;

// On cherche la première occurrence de "test" dans "Texte de test" :
suiteChaine = rechercher_Chaine_Dans_Chaine("Texte test de test", "test");
if (suiteChaine != NULL)
{
printf("Premiere occurence de test dans Texte de test : %s\n", suiteChaine);
}

return 0;
}

long rechercher_Chaine_Dans_Chaine(char chaine[], char chaineARechercher[])
{
long i, k, longueurChaine = 0, longueurChaineARechercher = 0, *valeurRetournee = NULL, testOK = 0;
int continuerTest = 1;

longueurChaine = longueur_Chaine(chaine);
longueurChaineARechercher = longueur_Chaine(chaineARechercher);

for(i = 0; i < longueurChaine && continuerTest; i++)
{
for(k = 0; k < longueurChaineARechercher; k++)
{
if(chaine[i+k] == chaineARechercher[0+k])
{
testOK++;
}
}

if(testOK == longueurChaineARechercher)
{
valeurRetournee = chaine + i;
continuerTest = 0;
}

}

return valeurRetournee;
}

-ed-

17 avril 2006 à 12:39:44

Citation : patxiku

j'ai voulu recréer la fonciton strstr mais ça ne marche pas et je ne comprends pas pourquoi (aucune erreur est détecté, le fonction pour trouver la longueur sont bonne.):

Ton code ne compile pas.

Il est incomplet. Merci de poster un code complet, sinon, on ne sait pas ce que tu as oublié.

Le type retourné par rechercher_Chaine_Dans_Chaine() est incorect. Il devrait être char * ou char const *.

Je ne comprends pas ton algorithme. Peux-tu l'expliquer ?

Music only !

Anonyme

17 avril 2006 à 12:51:56

if(testOK == longueurChaineARechercher)
{
valeurRetournee = chaine + i;
continuerTest = 0;
}

Ton problème vient surement de la valeur que tu retourne :
valeurRetournee = chaine + i;

Normalement tu dois retourner un char*, là tu retourne un long* (alors que dans ton prototype tu dis que tu retourne un long).

J'ai un peu le même problème mais pour la fonction strchr, je ne sais pas comment il faut faire pour la valeur de retour.

patxiku

17 avril 2006 à 13:37:24

voi-ci le code qui compile:

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

char* rechercher_Chaine_Dans_Chaine(char chaine[], char chaineARechercher[]);

int main(int argc, char *argv[])
{
char *suiteChaine = NULL;

// On cherche la première occurrence de "test" dans "Texte de test" :
suiteChaine = rechercher_Chaine_Dans_Chaine("Texte test de test", "test");
if (suiteChaine != NULL)
{
printf("Premiere occurence de test dans Texte de test : %s\n", suiteChaine);
}

return 0;
}

char* rechercher_Chaine_Dans_Chaine(char chaine[], char chaineARechercher[])
{
long i, k, longueurChaine = 0, longueurChaineARechercher = 0, *valeurRetournee = NULL, testOK = 0;
int continuerTest = 1;

longueurChaine = strlen(chaine); //je récupère les longueurs de chaine1
longueurChaineARechercher = strlen(chaineARechercher); //je récupère les longueurs de chaine2

for(i = 0; i < longueurChaine && continuerTest; i++) //la boucle vérifie tous les caractères de la chaine1
{
for(k = 0; k < longueurChaineARechercher; k++) //la boucle vérifie si les caractères de la chaine2 sont dans chaine1 et si ils sont à la suite
{
if(chaine[i+k] == chaineARechercher[0+k]) //pour vérifier si tout les caractères de chaine1 sont à la suite dans chaine1 il faut que testOK soit égal à la longueur de la chaine2
{
testOK++;
}
}

if(testOK == longueurChaineARechercher)
{
valeurRetournee = chaine + i;// si c'est le cas en envoi l'adresse du premier caractèe de chaine2 trouvé dans chaine1
continuerTest = 0;//et on arrête la boucle
}

}

return valeurRetournee;
}

-ed-

17 avril 2006 à 14:34:26

Citation : patxiku

voici le code qui compile:

OK. Il faut réinitialiser testOK à 0 avant de parcourir la chaine recherchée. D'une manière générale, réduire la portée des variables, ça simplifie le codage et ça évite ce genre d'erreur... Ne pas hésiter non plus à qualifier les invariants de 'const'. Attention aussi à ne pas dépasser les 76/80 colonnes...

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

static char const * rechercher_Chaine_Dans_Chaine(char const chaine[]
, char const chaineARechercher[])
{
char const *valeurRetournee = NULL;
long const longueurChaine = strlen(chaine);
long const longueurChaineARechercher = strlen(chaineARechercher);
int continuerTest = 1;
long i;

//la boucle vérifie tous les caractères de la chaine1
for (i = 0; i < longueurChaine && continuerTest; i++)
{
/* la boucle vérifie si les caractères de la chaine2 sont
* dans chaine1 et si ils sont à la suite
*/
long testOK = 0;
long k;

for (k = 0; k < longueurChaineARechercher; k++)
{
/* pour vérifier si tout les caractères de chaine1 sont à la
* suite dans chaine1 il faut que testOK soit égal à la
* longueur de la chaine2
*/

if (chaine[i + k] == chaineARechercher[k])
{
testOK++;
}
}

if (testOK == longueurChaineARechercher)
{
/* si c'est le cas en envoi l'adresse du premier caractère
* de chaine2 trouvé dans chaine1
*/
valeurRetournee = chaine + i;
continuerTest = 0; //et on arrête la boucle
}
}

return valeurRetournee;
}

int main(int argc, char *argv[])
{
char *suiteChaine = NULL;

// On cherche la première occurrence de "test" dans "Texte de test" :
suiteChaine = rechercher_Chaine_Dans_Chaine("Texte test de test", "test");

if (suiteChaine != NULL)
{
printf("Premiere occurence de test dans Texte de test : '%s'\n", suiteChaine);
}

return 0;
}

Music only !

patxiku

17 avril 2006 à 20:06:08

j'ai deux question:
-pourquoi mieu vaut-il mettre des constantes?
-pourquoi utilises-tu static pour définir le type de la fonciton?

-ed-

17 avril 2006 à 21:32:26

Citation : patxiku

j'ai deux question:
-pourquoi mieu vaut-il mettre des constantes?
-pourquoi utilises-tu static pour définir le type de la fonciton?

const ne signifie pas 'constant' (ce serait trop simple !), mais 'accès en lecture seule' (read-only). Ce ne sont pas des '[expressions ]constantes' mais des 'invariants', c'est à dire soit des variables contenant des valeurs qui ne changent pas, soit des pointeurs sur des variables non modifiables.

Rappel : une chaine de caractère n'est pas modifiable. La fonction doit donc accepter l'adresse de tels objets.
Le qualificateur 'static' permet de limiter la portée de la fonction. En effet, dans le fichier qui contient main() (surtout c'est le seul de l'application) la seule fonction exportable est main(). Les autres fonctions sont, par définition, sont 'privées' et peuvent donc être qualifiées de 'static', ce qui limite leur portée au module (unité de compilation) courant.

Music only !

patxiku

17 avril 2006 à 21:47:16

mais à quoi ça sert ça optimise le programme?
j'ai essayé avec ton code est ça marche pas de plus j'ai plein d'erreurs que je n'avais pas avant elle apparaissent dans les autres fonctions que j'avais déjà faites.
main.c

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

int main(int argc, char *argv[])
{
char *suiteChaine = NULL;

// On cherche la première occurrence de "test" dans "Texte de test" :
suiteChaine = rechercher_Chaine_Dans_Chaine("Texte de test", "test");

if (suiteChaine != NULL)
{
printf("Premiere occurence de test dans Texte de test : '%s'\n", suiteChaine);
}

return 0;
}

main.h

char copier_Chaine(char chaine[], char copieChaine[]);

long longueur_Chaine(const char* chaine);

char concatener_Chaines(char chaine1[], char chaine2[]);

int test_Chaines_Identiques(char chaine1[], char chaine2[]);

char* rechercher_Caractere_Dans_Chaine(char chaine[], int caractereARechercher);

char* rechercher_Caracteres_Dans_Chaine(char chaine[], char caracteresARechercher[]);

static char * rechercher_Chaine_Dans_Chaine(char const chaine[] , char const chaineARechercher[]);

fonction_string.c

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

long longueur_Chaine(const char* chaine)
{
long nombreDeCaracteres = 0;
char caractereActuel = 0;

do
{
caractereActuel = chaine[nombreDeCaracteres];
nombreDeCaracteres++;
}
while(caractereActuel != '\0'); // On boucle tant qu'on n'est pas arrivé à l'\0

nombreDeCaracteres--; // On retire 1 caractère de long pour ne pas compter l'\0

return nombreDeCaracteres;
}

char* copier_Chaine(char chaine[], char copieChaine[])
{
long longueurChaine = 0, i;

longueurChaine = longueur_Chaine(chaine); //on récupère la longueur du tableau

for(i = 0; i <= longueurChaine; i++)
{
copieChaine[i] = chaine[i];
}

return copieChaine;
}

char* concatener_Chaines(char chaine1[], char chaine2[])
{
long i, longueurChaine1, longueurChaine2, longueurNouvelleChaine;

longueurChaine1 = longueur_Chaine(chaine1);
longueurChaine2 = longueur_Chaine(chaine2);
longueurNouvelleChaine = longueurChaine1 + longueurChaine2;

for(i = 0; i < longueurChaine2; i++)
{
chaine1[i+longueurChaine1] = chaine2[i];
}

return chaine1;
}

int test_Chaines_Identiques(char chaine1[], char chaine2[])
{
long i, longueurChaine1, longueurChaine2;
int test = 0;

longueurChaine1 = longueur_Chaine(chaine1);
longueurChaine2 = longueur_Chaine(chaine2);

if(longueurChaine1 == longueurChaine2)
{
for(i = 0; i < longueurChaine1; i++)
{
if(!(chaine1[i] == chaine2[i]))
{
test ++;
}
}
}
else
test++;

return test;
}

char* rechercher_Caractere_Dans_Chaine(char chaine[], int caractereARechercher)
{
long i, longueurChaine = 0, *valeurRetournee = NULL;

longueurChaine = longueur_Chaine(chaine);

for(i = 0; i < longueurChaine; i++)
{
if(chaine[i] == caractereARechercher)
{
valeurRetournee = chaine + i;
}
}

return valeurRetournee;
}

char* rechercher_Caracteres_Dans_Chaine(char chaine[], char caracteresARechercher[])
{
long i, k, longueurChaine = 0, longueurCaracteresARechercher = 0, *valeurRetournee = NULL;
int continuerTest = 1;

longueurChaine = longueur_Chaine(chaine);
longueurCaracteresARechercher = longueur_Chaine(caracteresARechercher);

for(i = 0; i < longueurChaine; i++)
{
for(k = 0; k < longueurCaracteresARechercher && continuerTest; k++)
{
if(chaine[i] == caracteresARechercher[k])
{
valeurRetournee = chaine + i;
continuerTest = 0;
}
}

}

return valeurRetournee;
}

static char * rechercher_Chaine_Dans_Chaine(char const chaine[] , char const chaineARechercher[])
{
char const *valeurRetournee = NULL;
long const longueurChaine = strlen(chaine);
long const longueurChaineARechercher = strlen(chaineARechercher);
int continuerTest = 1;
long i;

//la boucle vérifie tous les caractères de la chaine1
for (i = 0; i < longueurChaine && continuerTest; i++)
{
/* la boucle vérifie si les caractères de la chaine2 sont
* dans chaine1 et si ils sont à la suite
*/
long testOK = 0;
long k;

for (k = 0; k < longueurChaineARechercher; k++)
{
/* pour vérifier si tout les caractères de chaine1 sont à la
* suite dans chaine1 il faut que testOK soit égal à la
* longueur de la chaine2
*/

if (chaine[i + k] == chaineARechercher[k])
{
testOK++;
}
}

if (testOK == longueurChaineARechercher)
{
/* si c'est le cas en envoi l'adresse du premier caractère
* de chaine2 trouvé dans chaine1
*/
valeurRetournee = chaine + i;
continuerTest = 0; //et on arrête la boucle
}
}

return valeurRetournee;
}

Citation : erreur

Compiling: main.c
main.h:13: warning: 'rechercher_Chaine_Dans_Chaine' used but never defined
Compiling: fonction_string.c
fonction_string.c: In function `rechercher_Caractere_Dans_Chaine':
fonction_string.c:86: warning: assignment from incompatible pointer type
fonction_string.c:90: warning: return from incompatible pointer type
fonction_string.c: In function `rechercher_Caracteres_Dans_Chaine':
fonction_string.c:107: warning: assignment from incompatible pointer type
fonction_string.c:114: warning: return from incompatible pointer type
fonction_string.c: In function `rechercher_Chaine_Dans_Chaine':
fonction_string.c:157: warning: return discards qualifiers from pointer target type

-ed-

17 avril 2006 à 22:06:39

Citation : patxiku

mais à quoi ça sert ça optimise le programme?
Oui, et ça permet de meilleurs contrôles de la part du compilateur.

j'ai essayé avec ton code est ça marche pas de plus j'ai plein d'erreurs que je n'avais pas avant elle apparaissent dans les autres fonctions que j'avais déjà faites.
</code>
main.h

static char * rechercher_Chaine_Dans_Chaine(char const chaine[] , char const chaineARechercher[]);

Il ne faut peut être pas faire n'importe quoi ! J'ai passé du temps à expliquer pourquoi on pouvait mettre le 'static', et la première chose que tu fais, tu romps la regle. J'avais dit dit "fonction non exportée". Or là, la fonction rechercher_Chaine_Dans_Chaine() est exportée, puis qu'elle est définie dans un fichier et utilisée dans un autre. Il faut être un peu logique. J'ai fait l'optimisation sur le code que j'avais entre les mains. A toi de faire les adaptations avec le code réel. Retire ce 'static' illogique.

D'autre part, dans fonction_string.c, il manque #include "main.h" pour assurer la cohérence entre les prototypes (.h) et les définitions des fonctions (.c).

Grâce à ce stratagème, j'ai déjà relevé 2 erreurs de type de retours... (char au lieu de char*)

Je propose cette organisation du code (attention, les prototypes ont été adaptés et les paramètres de 'copier' ont été inversés pour être identiques à ctrcpy().

/* mystring.h */
#ifndef H_MYSTRING
#define H_MYSTRING

char* copier_Chaine(char copieChaine[], char const chaine[]);
long longueur_Chaine(char const chaine[]);
char *concatener_Chaines(char chaine1[], char const chaine2[]);
int test_Chaines_Identiques(char const chaine1[], const char chaine2[]);
char* rechercher_Caractere_Dans_Chaine(char const chaine[], int caractereARechercher);
char* rechercher_Caracteres_Dans_Chaine(char const chaine[], char const caracteresARechercher[]);
char * rechercher_Chaine_Dans_Chaine(char const chaine[] , char const chaineARechercher[]);

#endif /* guard */

/* mystring.c */
#include "mystring.h"

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

long longueur_Chaine(char const chaine[])
{
long nombreDeCaracteres = 0;
char caractereActuel = 0;

do
{
caractereActuel = chaine[nombreDeCaracteres];
nombreDeCaracteres++;
}
while (caractereActuel != '\0'); // On boucle tant qu'on n'est pas arrivé à l'\0

nombreDeCaracteres--; // On retire 1 caractère de long pour ne pas compter l'\0

return nombreDeCaracteres;
}

char* copier_Chaine(char copieChaine[], char const chaine[])
{
long longueurChaine = 0, i;

longueurChaine = longueur_Chaine(chaine); //on récupère la longueur du tableau

for (i = 0; i <= longueurChaine; i++)
{
copieChaine[i] = chaine[i];
}

return copieChaine;
}

char* concatener_Chaines(char chaine1[], char const chaine2[])
{
long i, longueurChaine1, longueurChaine2, longueurNouvelleChaine;

longueurChaine1 = longueur_Chaine(chaine1);
longueurChaine2 = longueur_Chaine(chaine2);
longueurNouvelleChaine = longueurChaine1 + longueurChaine2;

for (i = 0; i < longueurChaine2; i++)
{
chaine1[i + longueurChaine1] = chaine2[i];
}

return chaine1;
}

int test_Chaines_Identiques(char const chaine1[], char const chaine2[])
{
long i, longueurChaine1, longueurChaine2;
int test = 0;

longueurChaine1 = longueur_Chaine(chaine1);
longueurChaine2 = longueur_Chaine(chaine2);

if (longueurChaine1 == longueurChaine2)
{
for (i = 0; i < longueurChaine1; i++)
{
if (!(chaine1[i] == chaine2[i]))
{
test ++;
}
}
}
else
test++;

return test;
}

char* rechercher_Caractere_Dans_Chaine(char const chaine[], int caractereARechercher)
{
long i, longueurChaine = 0, *valeurRetournee = NULL;

longueurChaine = longueur_Chaine(chaine);

for (i = 0; i < longueurChaine; i++)
{
if (chaine[i] == caractereARechercher)
{
valeurRetournee = chaine + i;
}
}

return valeurRetournee;
}

char* rechercher_Caracteres_Dans_Chaine(char const chaine[], char const caracteresARechercher[])
{
long i, k, longueurChaine = 0, longueurCaracteresARechercher = 0, *valeurRetournee = NULL;
int continuerTest = 1;

longueurChaine = longueur_Chaine(chaine);
longueurCaracteresARechercher = longueur_Chaine(caracteresARechercher);

for (i = 0; i < longueurChaine; i++)
{
for (k = 0; k < longueurCaracteresARechercher && continuerTest; k++)
{
if (chaine[i] == caracteresARechercher[k])
{
valeurRetournee = chaine + i;
continuerTest = 0;
}
}

}

return valeurRetournee;
}

char * rechercher_Chaine_Dans_Chaine(char const chaine[] , char const chaineARechercher[])
{
char const *valeurRetournee = NULL;
long const longueurChaine = strlen(chaine);
long const longueurChaineARechercher = strlen(chaineARechercher);
int continuerTest = 1;
long i;

//la boucle vérifie tous les caractères de la chaine1
for (i = 0; i < longueurChaine && continuerTest; i++)
{
/* la boucle vérifie si les caractères de la chaine2 sont
* dans chaine1 et si ils sont à la suite
*/
long testOK = 0;
long k;

for (k = 0; k < longueurChaineARechercher; k++)
{
/* pour vérifier si tout les caractères de chaine1 sont à la
* suite dans chaine1 il faut que testOK soit égal à la
* longueur de la chaine2
*/

if (chaine[i + k] == chaineARechercher[k])
{
testOK++;
}
}

if (testOK == longueurChaineARechercher)
{
/* si c'est le cas en envoi l'adresse du premier caractère
* de chaine2 trouvé dans chaine1
*/
valeurRetournee = chaine + i;
continuerTest = 0; //et on arrête la boucle
}
}

return valeurRetournee;
}

/* main.c */
#include "mystring.h"

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

int main(int argc, char *argv[])
{
char *suiteChaine = NULL;

// On cherche la première occurrence de "test" dans "Texte de test" :
suiteChaine = rechercher_Chaine_Dans_Chaine("Texte de test", "test");

if (suiteChaine != NULL)
{
printf("Premiere occurence de test dans Texte de test : '%s'\n", suiteChaine);
}

return 0;
}

Music only !

Anonyme

17 avril 2006 à 22:08:42

C'est bon enlève les const et le static et ce sera bon. Je suis arrivé au même chapitre dans le cours et je n'ai pas encore lu quelque chose là dessus.

patxiku

17 avril 2006 à 22:18:51

dsl, je n'y avais pas fait attention car je ne me suis pas bien empreigné de l'utilisation de static.

-ed-

17 avril 2006 à 22:24:50

Citation : darkagonik

C'est bon enlève les const et le static et ce sera bon. Je suis arrivé au même chapitre dans le cours et je n'ai pas encore lu quelque chose là dessus.

A ma connaissance, 'const' a été expliqué par M@téo. Pas 'static', OK.

Music only !