/*
lpSrc : La chaine à traiter
lpChars : Les caractères à remplacer
cReplace : Le caractère de remplacement
*/
char *ReplaceByChr (char *lpSrc, char *lpChars, char cReplace)
{
// if(!lpSrc || !*lpSrc || !lpChars|| !*lpChars || !cReplace) return 0;
do {
char *pChars = lpChars;
do {
if(*pChars == *lpSrc) {
*lpSrc = cReplace;
break;
}
} while(*++pChars);
} while(*++lpSrc);
return lpSrc;
}
/*
lpDest : La chaine destinatrice
lpSrc : La chaine source
lpChars : Les caracteres à remplacer
lpReplace : La chaine de remplacement
*/
char *ReplaceByStr (char *lpDest, char *lpSrc, char *lpChars, char *lpReplace)
{
// if(!lpDest || !*lpSrc || !lpSrc || !*lpChars || !lpChars || !*lpRemplace || !lpRemplace)
// return 0;
do {
char *pChars = lpChars;
do {
if(*lpSrc == *pChars) {
char *pReplace = lpReplace;
do *lpDest++ = *pReplace; while(*++pReplace);
goto __test_curchar;
}
} while(*++pChars);
*lpDest++ = *lpSrc;
__test_curchar:;
} while(*++lpSrc);
*lpDest = 0;
return lpDest;
}
/*
lpDest : La chaine destinatrice
size : La taille total de la chaine destinatrice
lpSrc : La chaine source
lpChars : Les caracteres à remplacer
lpReplace : La chaine de remplacement
*/
char *s_ReplaceByStr (char *lpDest, int iSize, char *lpSrc, char *lpChars, char *lpReplace)
{
char *pLimit;
// if(!lpDest || !size || !*lpSrc || !lpSrc || !*lpChars || !lpChars || !*lpRemplace || !lpRemplace)
// return 0;
pLimit = (lpDest+iSize)-1;
do {
char *pChars = lpChars;
do {
if(*lpSrc == *pChars) {
char *pReplace = lpReplace;
do {
*lpDest = *pReplace;
if(++lpDest == pLimit) goto __end_loops;
} while(*++pReplace);
goto __test_curchar;
}
} while(*++pChars);
*lpDest++ = *lpSrc;
__test_curchar:;
} while(*++lpSrc);
__end_loops:
*lpDest = 0;
return lpDest;
}
/*
lpSrc : La chaine à traiter
lpChars : Les caractères à remplacer
lpReplaces : Les caractères de remplacement
*/
char *ReplaceByPredef (char *lpSrc, char *lpChars, char *lpReplaces)
{
// if(!*lpSrc || !lpSrc || !*lpChars || !lpChars || !*lpReplaces || !lpReplaces) return 0;
do {
int iLoc = 0;
do
if(*lpSrc == lpChars[iLoc]) *lpSrc = lpReplaces[iLoc];
while(lpChars[++iLoc]);
} while(*++lpSrc);
return lpSrc;
}
/*
lpSrc : La chaine à traiter
lpChars : Les caractères à remplacer
lpReplaces : Les caractères de remplacement
iCount : Le nombre de caractères présents dans lpReplaces
*/
char *s_ReplaceByPredef (char *lpSrc, char *lpChars, char *lpReplaces, int iCount)
{
// if(!*lpSrc || !lpSrc || !*lpChars || !lpChars || !*lpReplaces || !lpReplaces) return 0;
do {
int iLoc = 0;
do
if(iLoc < iCount)
if(*lpSrc == lpChars[iLoc]) *lpSrc = lpReplaces[iLoc];
while(lpChars[++iLoc]);
} while(*++lpSrc);
return lpSrc;
}
Remarque :
5 fonctions
ReplaceByChr : Remplace tout les caractères de lpChars trouvés dans lpSrc par cReplace.
Ex :
char buf[] = "C% t*st &st un t!st";
ReplaceByChr(buf, "%*!&", 'e');
Buf contiendra:
"Ce test est un test"
ReplaceByStr : Remplace tout les caractères de lpChars trouvés dans lpSrc par la chaine lpReplace. La chaine destinatrice est lpDest.
Ex :
char buf[] = "Ce % est un ?";
char dest[128];
ReplaceByStr(dest, buf, "%?", "test");
dest contiendra:
"Ce test est un test"
s_ReplaceByStr : Version sécuritaire de ReplaceByStr.
ReplaceByPredef : Remplace tout les caractères de lpChars dans lpSrc par leurs équivalent dans lpReplaces.
Ex :
char buf[] = "C% t%&t %&t un t%&t";
ReplaceByPredef(buf, "%&", "es");
buf contiendra
"Ce test est un test"
s_ReplaceByPredef : Version sécuritaire de ReplaceByPredef.
Public Function ReplaceChars(ByVal Expression As String, Chars As String, ReplacementChar As String)
If Expression <> vbNullString And Chars <> vbNullString Then
Dim i As Integer
For i = 1 To Len(Chars)
Expression = Replace$(Expression, Mid$(Chars, i, 1), ReplacementChar)
Next i
End If
ReplaceChars = Expression
End Function
procedure ReplaceChars(var Str: String; SrcChar, DestChar: Char);
Var
P, E: PByte;
begin
if Length(Str) = 0 then Exit; { Pas de chaîne nulle }
P := @Str[1]; { On récupère le début de la chaîne }
E := @Str[Length(Str)]; { La fin de la chaîne }
Inc(E); { A cause du Inc(P) à la fin }
while P <> E do
begin
{ Si caractère correspondant, on remplace }
if P^ = Byte(SrcChar) then P^ := Byte(DestChar);
Inc(P); { On passe au caractère suivant }
end;
end;
Remarque :
Performances (avec 65536 caractères, comparant cette fonction et la fonction standard qui boucle sur la chaîne avec Str[I]) :
Fonction ReplaceChr : 691987.3895 nanosecondes. (plus rapide)
Fonction standard : 9340572.6147 nanosecondes.