Ich habe einen std::string der ca. 10KB groß ist.
In diesem Tummeln sich Zeichen an Zeichen und ich sollte nach der Anzahl eines bestimmten Ausdrucks suchen.

Also ich könnte das zb. mit find() machen aber für diesen unendlich langen string gibt es doch sicherlich eine fertige Funktion?
Vielleicht auch mit boost?

Also als Beispiel:

string empfang;

...
// empfang wir vollgeballert

//Muss die Anzahl von "HALLO" suchen.
size_t posa=0, posb=0;
unsigned int zaehl;
for(int i=0;i<empfang.length();i++)
{
posb=empfang.find("HALLO",posa);

 if(posb!=std::string::npos)
 {
  zaehl++;
  posa=posb;
  posa++;
  i=posb;   

 }

}

//zaehler ist hier nun die Anzahl des vorkommens von HALLO

PS: Das ist kein lebendiges Beispiel, das habe ich nur so hier reingetipselt wie ich es als erstes machen würde. Also bei syntaktischen Fehlern nicht meckern:-)

So.
Gibts hierfür was einfacheres?

Danke und Grüße Mondmann

Gruß,

Simon2.

HI,
wie wär's mit std::count_if ?
Macht genau das und heißt auch noch so.

Darüber hatte ich auch nachgedacht, ist aber hier nicht anwendbar (er zählt Teilfolgen und keine Elemente). Und etwas schnelleres als mit find() alle Vorkommen des Ausdrucks zu suchen fällt mir leider nicht ein.

Ich habs mal so einprogrammiert wie ichs oben geschrieben habe und es funktioniert eigentlich ganz gut...

const std::string source("Das ist mein suuuuper langer String! Und meine tooolle Funktion!");

std::size_t count(0);
std::size_t pos(0);
while ((pos = source.find("mein", ++pos)) != std::string::npos) ++count;

... in count steht die Anzahl ...

//allgemeines Zaehlen von Sequenzen in Containern
template<class Iter1, class Iter2>
std::size_t count_subseq(Iter1 first1, Iter1 last1, Iter2 first2, Iter2 last2, std::size_t count = 0)
{
  Iter1 pos = std::search(first1, last1, first2, last2);
  if(pos==last1) return count; //subsequence not found
  return count_subseq(++pos, last1, first2, last2, ++count); //recursive call
}

//speziell: zaehlen eines subtrings in einem string
std::size_t count_subtring(const std::string& str, const std::string& substr) {
  return count_subseq(str.begin(), str.end(), substr.begin(), substr.end());
}

Natuerlich koennte man den rekursiven Zaehlalgorithmus auch iterativ machen:

template<class Iter1, class Iter2>
std::size_t count_subseq(Iter1 first1, Iter1 last1, Iter2 first2, Iter2 last2)
{
  std::size_t count = 0;
  Iter1 tmp;
  Iter1 pos = first1;
  while (pos != last1) {
    tmp = std::search(pos, last1, first2, last2);
    if (tmp == last1) return count;
    ++count;
    pos = ++tmp;
  }
  return count; 
}

/edit: args, mal wieder zu lange rumgedroeselt

? Dein Code von oben ist vollkommen unperformant!

const std::string source("Das ist mein suuuuper langer String! Und meine tooolle Funktion!");

std::size_t count(0);
std::size_t pos(0);
while ((pos = source.find("mein", ++pos)) != std::string::npos) ++count;

... in count steht die Anzahl ...

Danke. Sehr lehrreiches Beispiel.
Hast nur vergessen nach ++count noch pos zu incrementieren sonst rödelt er sich zu tode.
Ich denke so werde ich es machen, vielen Dank.

Vielen Dank auf an alle anderen die sich Mühe gemacht haben und mit Beispiele gebracht haben.
Jedes Beispiel an sich ist interessant und lehrreich.

Grüße Mondmann