While est un boucle et il faut donc la refermer !

Mais elle est normalement fermée : Quand il n'y a plus de sous-chaine à modifier, elle ne se répète plus, non ?

Je ne comprend pas ton Algo, ensuite, à mon avis, le proto à utiliser est:
string& replace( size_type index, size_type num1, const char* str, size_type num2 ); (http://www.cppreference.com/cppstring/replace.html)

string remplacement(string chaine, string aRemplacer, string parCa)
{
    int len = aRemplacer.size(),pos;
    while((pos=chaine.find(aRemplacer)) != string::npos)
    {
        ch.replace(pos, len, parCa,perCa.size());
    }
return chaine;
} 

Super merci !
Ca marche !! J'ai reprit et adapté un peu le code que tu m'a donné.

Oups, désolé, mon code amélioré ne fonctionnait pas. Je viens d'essayer avec ta version, le debugueur se fait bavard :

In file included from dico.h:6,
from code.h:5,
from main.cpp:4:
dico.cpp: In function ‘std::string rch(std::string, std::string, std::string)’:
dico.cpp:18: erreur: no matching function for call to ‘std::basic_string<char, std::char_traits<char>, std::allocator<char> >::replace(int&, int&, std::string&, size_t)’
/usr/lib/gcc/i386-redhat-linux/4.3.0/../../../../include/c++/4.3.0/bits/basic_string.h:1194: note: candidats sont: std::basic_string<_CharT, _Traits, _Alloc>& std::basic_string<_CharT, _Traits, _Alloc>::replace(typename _Alloc::rebind<_CharT>::other::size_type, typename _Alloc::rebind<_CharT>::other::size_type, const std::basic_string<_CharT, _Traits, _Alloc>&) [with _CharT = char, _Traits = std::char_traits<char>, _Alloc = std::allocator<char>]
/usr/lib/gcc/i386-redhat-linux/4.3.0/../../../../include/c++/4.3.0/bits/basic_string.h:1217: note: std::basic_string<_CharT, _Traits, _Alloc>& std::basic_string<_CharT, _Traits, _Alloc>::replace(typename _Alloc::rebind<_CharT>::other::size_type, typename _Alloc::rebind<_CharT>::other::size_type, const std::basic_string<_CharT, _Traits, _Alloc>&, typename _Alloc::rebind<_CharT>::other::size_type, typename _Alloc::rebind<_CharT>::other::size_type) [with _CharT = char, _Traits = std::char_traits<char>, _Alloc = std::allocator<char>]
/usr/lib/gcc/i386-redhat-linux/4.3.0/../../../../include/c++/4.3.0/bits/basic_string.tcc:390: note: std::basic_string<_CharT, _Traits, _Alloc>& std::basic_string<_CharT, _Traits, _Alloc>::replace(typename _Alloc::rebind<_CharT>::other::size_type, typename _Alloc::rebind<_CharT>::other::size_type, const _CharT*,

Et ainsi de suite...


Si la suite du rapport peut aider il faut me le dire, mais ça m'étonnerait.
Sinon, la concaténation rajoute des caractères à la fin, mais ne transforme pas (enfin je pense, ne pas hésiter à me corriger !!). Et sinon, a quoi ressemble la technique des "itérateurs" ? Je ne vois pas vraiment...
En tous cas, merci !

Regarde le lien que je t'ai donné, et essai avec une autre fonction. Je suis étonné que ça ne fonctionne pas, car ce site est pas mal et documente bien la STL. Mais bon, les faits sont têtus !
La concaténation que je t'ai donnée fait ça : prendre le début de la chaine jusqu'au mot à remplacer, mettre à la suite le mot remplaçant, puis mettre la fin de la chaine à partir de la fin du mot à remplacer. En fait, c'est un peu barbare/brutale, ça consiste tout simplement à écraser la chaine initiale en y mettant des bouts d'elle même.
D'un autre coté, je ne suis pas sur que le replace() fasse autre chose au final (dans son code à lui).
Sinon, comme je te disais, tu utilise erase() pour effacer le mot à changer et insert() pour mettre le nouveau. Je pense que c'est ce que je ferai car étant le plus élégant après le replace().
Pour les itérateurs, regarde un peu sur le lien que je t'ai donnée, il y a certains exemples. Je trouve que c'est bien est puissant, mais lourd à mettre en œuvre pour ne l'utiliser que sur une ligne ou deux. Salutation ! avant je croyais, maintenant je suis fixé.Jésus Christ
Char Snipeur

Ah oui d'accord, l'idée est bonne (même si c'est barbare !).

Je vais commencer par essayer d'appliquer la méthode erase/insert, qui m'a l'air plus simple à mettre en oeuvre, si ça coince je teste la concaténation, et sinon, effectivement, j'essaie les itérateurs.

Je ne connaisais pas la page sur les strings (en C++ !), mais effectivement, ça a l'ai clair et complet.

Bon, bein merci, j'essaie !

C'est bon (cette fois j'ai vérifié !!), la concaténation barbare fonctionne.
Merci pour l'astuce et pour le lien, qui va me servir !