template et recursivité

Je cherche a faire un template qui recherche une chaine de caractere (le motif) (const) dans un tableau de char. Le but est de faire comme si j'ecrivais :

Code:

---

1 2 3 4

if ( T[0] != motif[0] ) return false; if ( T[1] != motif[1] ) return false; if ( T[2] != motif[2] ) return false; return true;

---

pour un mot de trois lettres

Code:

---

1 2 3 4 5 6 7

template<const char * motif> MotifPresent(char * T) { if ( *motif == 0 ) return true; if ( (*motif) != (*T) ) return false; else return MotifPresent<motif+1>(T+1); }

---

mais le compilo me sort l'erreur suivante pour le <motif+1>

Citation:

---

"l'argument doit etre une expression constante"

---

l'astuce consisterait a passer aussi un int stockant le nombre de parametre mais la, probleme il faut que je le donne moi meme et j'aurais voulu me contenter de l'appel suivant :

Code:

---

MotifPresent<"Hello">(T);

---

ps : autre question au sujet de la compil des templates sous builder : je les mets dans les headers et je les integre chaque fois que j'en ai besoin. Pour les classes dans la version builder 5, les fonctions membres templates doivent etre transformées en classe template (il me semble) je n'en suis pas totalement sur, est-ce mieux gérer dans cbc 6 ? 7 ?

Les paramètres templates ne peuvent être que des types ou des constantes entières, pas de pointeur. Mais je doute de l'interêt des templates pour une telle fonction.

En plus ta fonction est incorrecte (à moins que j'ai mal compris son but) car elle retournera vrai seulement si le début de la chaîne passée en paramètre est identique à la sous-chaîne.

Et à part ça, il existe des fonctions standards qui font ça très bien, pas la peine de réinventer la roue.

Citation:

---

En plus ta fonction est incorrecte (à moins que j'ai mal compris son but) car elle retournera vrai seulement si le début de la chaîne passée en paramètre est identique à la sous-chaîne.

---

oui c'etait bien cela, j'ai fait gicler la boucle

Citation:

---

Et à part ça, il existe des fonctions standards qui font ça très bien, pas la peine de réinventer la roue

---

auxquelles penses tu ? Mon tableau fait 20 megas, je previens !! Je veux pas une fonction standard mettant 10 sec la ou ma fonction médiévalle met 1sec...

Je suis preneur de toute remarque !! Il s'agit effectivement d'un sujet bateau de string replacement.

Il faudrait que tu donnes plus de précisions, quel est le contexte ? Qu'est-ce que tu fais exactement avec tes chaînes ? Tu peux tenter d'utiliser std::string et ses fonctions membres (find, replace, ...), ou alors un set<string> par exemple.

un chaine de 10Meg correspondant a du texte. Il s'agit de données issues de l'ocr et je fais de la recherche automatique d'erreur et des statistiques. La version finale se sert effectivement d'un dictionnaire, mais dans la phase intermédiaire par exemple ou je regarde si les mots du texte sont valides et ou je retire les abréviations je travaille avec un char * de 10 meg.

La question concernait en fait la partie ou je substitue des abréviations "Fig." par Figure car je ne veux pas voir apparaitre de "." qui soit autre chose que des "." de fin de phrase. Donc la requete sur le tableau doit eviter les realloc pour chaque mot trouvé, si possible...

Je pense que le mieux est donc de séparer tes mots dans un conteneur (si bien sûr les traitements ne concernent toujours qu'un seul mot à la fois). Ainsi lorsque tu substitues un mot, c'est seulement la mémoire pour celui-ci qui est (potentiellement) reallouée et non tes 10 Mo.

Ou alors, si tu as une idée plus ou moins précise de la mémoire supplémentaire que tu vas utiliser, tu peux la réserver dès le début.

Dans tous les cas le char* brut me parait une mauvaise idée.

D'ailleurs on s'éloigne de ton problème original de templates (qui est a priori résolu), je te conseille de poster un nouveau sujet, dans le forum C++ cette fois, où tu pourras avoir d'autres bons conseils :wink:

Je cherche a faire une fonction efficace qui verifie si le motif "XXX" est bien present dans la chaine "XXXYYUII". Je travaille avec un grand tableau de char 10Meg venant d'un ocr. J'ai abandonné l'idée de découper tout par mots car certaines erreurs d'ocr se glissent : par exemple supression d'un espace apres un ".". J'ai donc conserve le texte brut et je fais plusieurs requetes pour détecter les erreurs.

Dans la foulée je remplace les abréviations Fig. par les vrais termes : Figure et ainsi de suite. Je voulais juste faire une fonction tres efficace qui recoit en parametres le tableau et le motif. Le plus efficace pour moi aurait ete d'avoir qqc du genre

Code:

---

1 2 3 4 5 6 7

bool Find(char * t, char * motif) { if ( t[0] != motif[0] ) return false; if ( t[1] != motif[1] ) return false; ... return true; }

---

le probleme est que je ne peux pas ecrire cela car motif est de taille non connue a l'avance, je voulais essayer qqc avec un template en passant la longueur en parametre, mais ca crie :

Code:

---

1 2 3 4 5 6 7 8 9

char MOTIF[n][l]   template<int num,int l> bool MotifPresent(char * T) { if ( l == 0 ) return true; if ( T[l] != MOTIF[num][l] ) return false; return MotifPresent<num,l-1>(T); }

---

Le compilo part en vrille complete

Je sens que je vais me faire incendier, je sors mon gillet pare-balles

Sujets fusionnés dans le forum C++


http://membres.lycos.fr/bigboomshaka...ar-gif-311.gif Enjoy yourself !

Si ta chaine est chargée dans une std::string (tout à fait faisable) (tu peux te débrouiller pour ne jamais la copier et donc ne pas perdre en perf) tu peux alors utiliser std::string::find.

Si tu as un énorme char*, la solution "efficace" (sans copie vers une std::string, ou sans utilisation d'un wrapper à la std::string mais sans copie) est de dérouler le find -> faire un while sur tous les éléments de ta chaine pour lancer un strcmp à chaque fois.

Code:

---

1 2 3 4 5 6 7 8 9

char const * find(char const *in, char const * what) { assert(in); assert(what); size_t n = strlen(what); for ( ; *in ; ++in) if (!std::strncmp(in,what,n)) // interface à vérifier return in; return 0; }

---

Et ô miracle, ça existe déjà et ça s'appelle std::strstr

Les templates n'aident en rien dans tel algo.

S'il y a potentiellement beaucoup de chaînes différentes à rechercher dans la chaîne initiale, il peut être intéressant d'utiliser des algorithmes spécifiques, basés sur une machine à états/ un parseur, afin d'éviter de parcourir la chaîne plusieurs fois.

ok merci !!

alors pour m'amuser j'ai testé, morale :

Ma fonction qui reinvente la roue, programmée en un jour : 60ms

La fonction strncmp, programmé en 0 sec : 40 ms

Ma nouvelle fonction ecrite avec une macro : 20 ms