vermutlich ist es leicht zu lösen, ich finde aber nicht die richtige Stelle zum Schleifenabbruch.

Ich habe einen Vektor, der Daten aus der Datenbank aufnimmt. Diesen Vektor möchte ich durchlaufen und zählen, wie oft jedes inhaltlich gleiche Element vorkommt. Die gleichen Elemente stehen immer hintereinamder.

z.B:
1. Element des Vektos "M"
2. "M"
3. "M"
4. "A"
5. "A"

Bei meiner Lösung wird der ganze Vektor durchlaufen und ich gruppiere nicht nach "inhaltsgleichen" Elementen.

for (int k=0; k< t.size(); k++) {
strcpy(mainId, t[k]);

if (strcmp(mainId, oldMain) != 0) {
numMainId = 1;
strcpy(oldMain, mainId);
// break;
}
else {
numMainId ++;
}

//hier sollte im ersten Schleifendurchlauf numMainId =3 (3xM), beim 2. schleifendurchlauf numMainId = 2 (2xA)

if (numMainId > 1 ){
do..
}
}

Im Voraus schon mal vielen Dank...

(für letzteres könntest du mit unique_copy() über deinen Vector laufen und hinterher zählen, wieviele Werte rauskopiert wurden)

Aber warum machst du es nicht so:
Du speicherst das erste Element von "t" in einer Variable, sagen wir mal "GrundElement". Dann gehst du in "t" solange vor, bis das aktuelle Element in "t" ungleich "GrundElement" ist, dabei erhöhst du immer eine Zählervariable. Denn dann wären in deinem Beispiel die 3 "M"s vorbei.
Jetzt machst du was mit dieser Erkenntnis...
Dann setzt du "GrundElement" auf das aktuelle Element von "t", was dann ja 'A' wäre, und die Zählervariable auf 0. Du gehst wieder weiter vor, bis t[aktuell] != GrundElement und erhöhst wieder die Zählervariable. Dann wieder was damit machen usw.

Anschaulich erklärt?

Leider bin ich absoluter Anfänger und kann das, was Du (Badestrand) mir gepostet hast nicht in quelltext umsetzten. Aber von der Logik her ist es genau das, was ich möchte.

hier mein Versuch:

char old[10] = NULL;
char mainId[10] = "new";

for (int k=0; k< t.size(); k++) {
strcpy(old, t[0]->mainIdent);

while (strcmp(mainId, oldMain) == 0))
{
numMainId ++;
}

// wie komme ich zurück zum Anfang der forSchleife??
strcpy(old, t[i]);
numMainId = 0;
}

vielen Dank und sorry fürs erneute Fragen.. war anschaulich erklärt...

Mal ein Ansatz:

string tmp;
int oldi=0,blocksize=0;
for(i=0;i<vec.size();++i)
{
  if(vec[i]!=tmp)
  {
    tmp=vec[i];
    if(blocksize<i-oldi) blocksize=i-oldi;
    oldi=i;
  }
}
//jedes Mal, wenn ein neues Wort gefunden wird, wird der letzte Zähler ausgewertet und dann der Zähler neu gesetzt
//oldi speichert die Anfangsposition des Blocks, blocksize die bisherige Maximalgröße

Und vielen Dank, fürs antworten! Und das,obwohl ich nicht mehr geschrieben habe, was ich will.

Also:
Ich möchte für jedes "Wort" die Anzahl haben. Also wissen, wieviele "M"'s, "A"'s etc. es gibt.

Und genau das macht Dein Bsp ja! Danke fürs Gedankenlesen!

leider komme ich immer noch nicht weiter.

Also neuer Versuch zu erklären:
Es gibt eine bestehende if Anweisung, welche mit einem bestimmten Kriterium einige Elemente von t löscht. Ich möchte aber sichergehen, dass jedes "Wort" mindestens 1x vorkommt. Dafür soll die besagte Schleife s.u. sein.

Daher möchte ich die Anzahl der gleichen Wörter in einer späteren if Anweisung verwenden.

Also :

Schleife {
Ermittele die Anzahl des aktuellen Wortes, z.B: "M"

If ( Anzahl "M" >= 1)
}

Zu deinem neuen Problem. In der Schleife kannst du mit den Blockgrößen alles machen, was dir einfällt. Anstatt dir nur den längsten Block zu merken (siehe mein Code), kannst du dir auch alle Blöcke in einen vector<pair<string,int> > oder eine map<string,int> packen und später weiterverarbeiten.