enlever un caractere redondant

Version imprimable

26/12/2010, 20h08
tamise

enlever un caractere redondant

Bonjour,

Mon problème est que je dispose d'une chaine de caractère( de type string) telle que : a,i,o,p

Et lorsque j'ajoute une autre chaine (string) telle que : a

Je veux q'il me supprime le a qui apparait deux fois, et qu'il me donne à la fin : i,o,p

Est ce qu'il existe une fonction qui fait ceci dans la bibliothèque ?

Merci
26/12/2010, 20h26
Skull57

C'est très simple : machaine.erase(0, 1);
1er argument : numéro du caractère
2eme argument : nombre de caractères à supprimer

@+
26/12/2010, 21h08
tamise

moi je ne veux pas indiquer le truc à supprimer je veux q'il trouve par lui même le truc redondons et le supprime
26/12/2010, 21h40
Skull57

Tu fais une recherche de caractère, dans ce cas !

pour i=0;i<tailedelachaine
si chaine[i] == lettre
supprimer chaine[i] (avec erase)

Apres, tu adaptes ça comme tu veux ...
26/12/2010, 21h57
droggo

Hia,

Tu peux toujours acheter un ordinateur avec lecteur de pensées intégré. :mouarf:

Si l'ordre de ta chaine n'est pas important tu peux utiliser l'algorithme unique :
Code:

1 2 3 4 5 6 maChaine += maChaineAAjouter; std::string::iterator debut(maChaine.begin()),fin(maChaine.end()); std::sort(debut, fin); std::string::iterator finUnique(std::unique(debut, fin)); maChaine.erase(finUnique, fin);
unique est une fonction qui, à partir d'une sequence triée(d'où l'utilisation de sort), met à la fin les doublons et renvoie un iterateur vers le premier doublon.

Si tu travailles sur des caractères :

Code:

1
2
3
4
5
6
7
8
 
// si le caractère est déjà dans la chaine, alors
// count va renvoyer au moins 1. 
if (std::count(str.begin(), str.end(), c))
{
  // du coup, on peut supprimer le caractère dans la chaine. 
  str.erase(std::remove(str.begin(), str.end(), c), str.end());
}

Si l'entrée est une chaine, ça devient plus complexe - il n'y a pas d'algorithme dans la librairie standard qui permet de faire ça simplement.

Du coup, on va faire quelque chose du genre :

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
 
template <class Char>
struct check_and_remove
{
  private:
    std::basic_string<Char>& base;
  public:
    check_and_remove(std::basic_string<Char>& b) : base(b) { }
    void operator()(Char c)
    {
      if (std::count(str.begin(), str.end(), c))
      {
        str.erase(std::remove(str.begin(), str.end(), c), str.end());
      }
    }
};
 
template <class Char>
std::basic_string<Char> traite_chaine(
    const std::basic_string<Char>& in, 
    const std::basic_string<Char>& chk)
{
  std::basic_string<Char> out(in);
  std::for_each(chk.begin(), chk.end(), check_and_remove<Char>(out));
  return out;
}

Mis en template, parce qu'il n'y a pas de raison de se limiter à des std::string (et du coup, le code fonctionne aussi pour std::wstring, naturellement) :

Code:

1
2
3
4
5
 
  std::wcout << traite_chaine(L"abcd", L"ac") << std::endl;
  // affiche bd; le traitement s'eefectue sur des std::wstring
  std::cout << traite_chaine("abcd", "ac") << std::endl;
  // affiche bd aussi; mais fait le traitement sur des std::string