Remplacer un fragment dans une chaine de caracteres

Version imprimable

25/09/2006, 09h29
VinceBassman

Remplacer un fragment dans une chaine de caracteres

Bonjour,

Je suis a la recherche d'une fonction en C++ pour remplacer un fragment par un autres dans une chaine de caracteres...
Les fragments n'ont pas forcement la meme longueur.
Par exemple:
char *s = "je cherche une fonction";
char *old = "cherche une fonction";
char *new = "'ai trouve!";
// printf de s donne "je cherche une fonction"
string_replace(s,old,new);
// printf de s donne "j'ai trouve une fonction"

Si qqun peut me donner un coup de main, ca serait sympa!
Merci d'avance,
VB.
25/09/2006, 09h36
Médinoc

Déjà, ta question parait incohérente.
Ensuite, on ne pond pas de code sur demande, comme indiqué dans les règles du forum. Tu présentes ton code, et peut-être qu'on t'aidera à corriger les erreurs...

Bon ben je ne vois pas en quoi c'est incoherent, mais bon, je vais simplifier: je souhaite remplacer 'abc' par 'defghij' dans une chaine de caracteres.
Voila ma fonction:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
 
// Replaces a fragment of a string by another one
char *strstr_rep(char *source, const char *oldfrag, const char *newfrag) {
        char *original = source;
 
printf("INFO --> old fragment: -%s-\n", oldfrag);
printf("INFO --> new fragment: -%s-\n", newfrag);
        char temp[1024];
        int old_length = strlen(oldfrag);
        int i,j,k,l,place=-1;
 
        for (i=0; source[i] && (place == -1); ++i) {
                for (j=i,k=0; source[j] == oldfrag[k]; j++,k++) {
                        if (!oldfrag[k+1]) {
                                place = i;
                        }
                }
        }
        if (place != -1) { 
                // First part of string source is not modified, until place-1
                for (j=0; j < place; j++) {
                        temp[j] = source[j];
                }
                // Insert newfrag from index place
                for (i=0; newfrag[i]; i++,j++) {
                        temp[j] = newfrag[i];
                }
                // Last part of string
                for (k=place+old_length; source[k]; k++,j++) {
                        temp[j] = source[k];
                }
                temp[j] = '\0';
                for (i=0; source[i]=temp[i]; i++) { }
        }
printf("INFO --> modified string: -%s-\n", original);
        return(original);
}

et voila comment je l'appelle:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
const char deffilename = "${RAZ}/@@essai";
char *newdeffilename = new char[strlen(deffilename) + 1];
strcpy(newdeffilename, deffilename);
printf("\nINFO --> this is a copy:-%s-\n", newdeffilename);
if (strchr(newdeffilename, '@')) {
        printf("\nINFO --> this is a metafile:-%s-\n", newdeffilename);
        const char *RAZ_VAR;
        if ((RAZ_VAR = getenv("RAZ")) != 0 && *RAZ_VAR) {
                if (!strncmp(newdeffilename,"${RAZ}",6)) {
                        strstr_rep(newdeffilename,"${RAZ}",RAZ_VAR);
                        printf("\nINFO --> after subsitution, new:%s-!!!\n",newdeffilename);
                }
        }
}

Et en sortie, je me tape un bus error... Donc je voulais savoir s'il n'existe pas une fonction toute faite faisant partie des librairies C/C++ qui fait le meme boulot --> je n'ai jamais demande explicitement qu'on me ponde du code!!!!

Merci d'avance pour vos idees,
VB.

25/09/2006, 10h21
Médinoc
Ah oui, parce qu'en plus tu bosses en char*...
Tu devrais déjà voir s'il n'y a rien qui marcherait mieux dans la classe std::string...

Et relis ta question: string_replace("je cherche une fonction", "cherche une fonction", "ai trouvé!") doit-il retourner "je ai trouvé! une fonction" ou plutôt "je ai trouvé" ? :roll:

Déjà, ton code appelant est trop compliqué pour un test. Tu devrais juste tenter d'appeler ta fonction avec rien d'autre autour...

Ensuite, je ne vois aucune allocation, alors que ta fonction:
1. Modifie potentiellement la taille de la chaîne, potentiellement en augmentation;
2. Ecrit sur la chaîne originale qui peut être sur une zone en lecture seule (heureusement, ce n'est pas le cas).
Le code char *str="abc" est extrêmement dangereux car les chaînes littérales sont généralement placées dans une zone de mémoire en lecture seule: Toute tentative d'écriture provoque donc au mieux un plantage, au pire un mauvais résultat. Une chaîne dont le contenu (et non la taille) est modifiable se déclare char[] str="abc". Une chaîne littérale devrait toujours être déclarée char const *str="abc" (si tu as GCC, ajouter l'option -Wwrite-strings te permettra d'éviter ce genre d'erreurs).
Bien sûr, en C++, l'usage des std::string peut avantageusement remplacer ces problèmes, le contenu d'une std::string étant toujours alloué dynamiquement...

Edit: Petite correction...
25/09/2006, 10h25
frenchi

Salut,

Le code que tu présentes n'est pas du C++, mais du C.

Sinon, en C++ il y a les std::string qui simplifie la vie pour ce qui est des manipulations de chaîne de caractères, Il existe aussi la fonction str_replace qui remplace une chaine de caractere par une autre .
25/09/2006, 10h36
VinceBassman

Merci pour tes conseils...
En fait string_replace("je cherche une fonction", "cherche une fonction", "'ai trouvé!") devrait retourne "j'ai trouve!", tu as raison, je me suis un peu emballe dans le premier post...
Par contre, la chaine de caracteres que je veux modifier a ete definie par:
char *newdeffilename = new char[strlen(deffilename) + 1];
Ca n'est pas une allocation?

VB.
25/09/2006, 12h12
Ti-R

Citation:

Envoyé par frenchi

Salut,

Le code que tu présentes n'est pas du C++, mais du C.

Sinon, en C++ il y a les std::string qui simplifie la vie pour ce qui est des manipulations de chaîne de caractères, Il existe aussi la fonction str_replace qui remplace une chaine de caractere par une autre .

Son code est plus du C++ que du C car il utilise new !
C'est "l'ancienne" manière de coder du C++. Et oui les std::string simplifie la vie ;)

Citation:

Envoyé par VinceBassman

char *newdeffilename = new char[strlen(deffilename) + 1];
Ca n'est pas une allocation?

?
Si...
?:aie:
25/09/2006, 12h49
frenchi

Citation:

Son code est plus du C++ que du C car il utilise new !
C'est "l'ancienne" manière de coder du C++. Et oui les std::string simplifie la vie

J'avais pas vu le new :)
Les printf m'ont perturbés, désolé!
25/09/2006, 16h52
Médinoc

C'est une allocation dans la fonction appelante : Il n'y a rien pour cela dans la fonction appelée. Le 1 est donc toujours valide.
Par contre, je vire mon "Et c'est le cas", car c'est vrai que dans le cas présent, la chaîne n'est pas dans une zone mémoire en lecture seule.

Et new ou pas new, je trouve que c'est quand même plus du C que du C++.
S'il y avait un strdup() à la place, ça ne ferait pas de différence...

Et RAZ_VAR (qui est loin d'être une constante, donc que fait-elle en majuscule?) est de longueur inconnue, potentiellement plus grande que ${RAZ}.

PS: strcmp() ne retourne pas un booléen (il y a au moins trois valeurs possibles), aussi je trouve que comparer explicitement à zéro serait plus explicite que le test du '!'...
25/09/2006, 22h51
Luc Hermitte

Rien ne garanti que l'appelant de ta fonction n'ait pas fait un malloc plutôt qu'un new. Du coup, comment savoir comment tu dois détuire en cas de besoin de réallouer pour agrandir ? Tu ne peux pas.

Tu codes en C++, std::string est ton amie.

Quelque chose dans ce gout peut être ?

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
 
std::string str_replace(char* str1, char* str2, char* str3)
{
  std::string s_chaine(str1);
  std::string s_ancien(str2);
  std::string s_nouveau(str3);
 
  std::size_t index = s_chaine.find(s_ancien, 0);
  s_chaine.erase(index, s_ancien.length());
  s_chaine.insert(index, s_nouveau);
 
  return s_chaine;
}

PS: Lachez les chiens ^^

26/09/2006, 15h11
loufoque

std::string a une fonction membre replace.

Citation:

Envoyé par NewbiZ

Quelque chose dans ce gout peut être ?

Ou plus simplement :
Code:

1 2 3 4 5 6 7 8 9 10 std::string str_replace(char* str1, char* str2, char* str3) { std::string s_chaine(str1); std::string s_ancien(str2); std::size_t index = s_chaine.find(s_ancien, 0); s_chaine.replace (index, s_ancien.length(), str3); return s_chaine; }
Tu peux faire encore plus cours en utilisant strlen.

Avec strlen() et un peu de const-correctness;

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
std::string str_replace(
 char const * sczChaine, 
 char const * sczAncien, 
 char const * sczNouveau
 )
{
  std::string sShaine(str1);
 
  std::size_t index = sChaine.find(sczAncien, 0);
  if(index != std::string::npos)
    sShaine.replace(index, strlen(sczAncien), sczNouveau);
 
  return sChaine;
}

(Attention, je n'ai pas testé).

26/09/2006, 20h22
loufoque

Argh des préfixes de variables pas beaux
26/09/2006, 21h03
Médinoc
Ça dépend, j'ai évolué depuis la "bad hungarian notation"façon MS à la "good ungarian notation" :
Je n'utilise pas "dw" pour DWORD qui est un vulgaire type entier.
Mais j'ai des types qui aident:
- s pour une chaîne qui fait tout tout seul (toutes les classes de chaînes, notamment)
- sz pour une chaine C, qu'il faut donc gérer soi-même
- scz pour une chaîne C constante
- Parfois, n pour les nombres, mais assez rarement
- i pour des index
- cb/cch peuvent être utiles quand on travaille en unicode ou en TCHAR
- Et systématiquement, p ou pc pour les pointeurs (histoire de ne pas s'emmêler les pinceaux pour les niveaux d'indirections, ce que font souvent les débutants)...
26/09/2006, 21h41
Luc Hermitte

http://www.joelonsoftware.com/articles/Wrong.html
26/09/2006, 22h43
Médinoc

Merci, c'est justement la page qui m'avait ouvert les yeux. ;)
Même si je n'ai pas encore adopté tous les réflexes, j'évolue...
27/09/2006, 17h43
JolyLoic

Perso, cette page ne m'a clairement pas convaincu. En particulier, dans son cas, plutôt que de me servir de convention de nommage, j'aurais préféré me servire du système de type qui a l'avantage d'être vérifié par le compilateur (dans le cas du C, le système de type n'est pas assez évolué, est-ce pour ça que cette notation a été inventée ?).

J'aurais donc écrit deux classes chaines, une EncodedString, une DecodedString, et j'aurais selon les cas soit interdit la conversion explicite entre ces types, soit fourni une conversion implicite qui encode/décode automatiquement.
27/09/2006, 22h54
Luc Hermitte

Dans les systêmes non assez typés, cette notation a tout son intérêt.
Mais jusqu'où faut-il aller dans notre typage. J'aime assez son exemple de fonction qui prend des lignes et des colonnes. Enrichir notre base de type pour tous les entiers possibles et imaginable me parait un peu lourd. Prendre une petite convention de nommage ne coute pas grand chose.

Ce que j'ai apprécié dans l'article c'est le côté qui rappelle que la notation hongroise ne s'applique pas sur les types du langage, mais sur les kinds.

Ce qui ne m'empêche pas d'utiliser un simili de notation hongroise pour gérer les diverses représentations d'un état. Typiquement dans le cas des énumérés: eToto (la valeur énumérée), sToto (la représentation chaîne), iToto (pour quand il y a des convertions intermédiaires passant par des entiers). L'intérêt pour moi est que je n'ai pas à réfléchir longtemps aux noms des 3 variables une fois le "Toto" décidé.