Also, ich habe ein vector<string>. Mit

vector<string> map;
 for (size_t i = 0; i <20; i++) map.push_back("++++++++++++++++++++");

diesem inhalt.

so, nun packe ich auf einen von den chars ein 'p'.
sieht so aus:

int write_map ( int x, int y, char inhalt ) {
    //inhalt auf koordinaten schreiben
    map[x][y] = inhalt;
    return 0;
}
write_map (0, 0, 'p');

und nun kommt mein problem:
ich weiß nicht richtig, wie ich das p jetzt finden kann...

ich habe das hier:

int i, k = 0;
    while (i != 19) {
          while ( k != 19 ) {
                input = map[i][k];
                if (input == 'p') {
                          break;
                          }
                k++;
                }
          k = 0;
          i++;
          }

aber damit stürzt das programm ab...

was muss ich verändern, dass die schleife das macht, was ich will?

greetz, hokage (not logged )

(das ist eine der wenigen Situationen, wo ich über ein goto nachdenken würde)

PS: Übrigens solltest du lieber die tatsächliche Größe des Feldes (map.size() bzw. map[i].size()) als Endekriterium verwenden.

int i, k = 0;
    while (i > map.size()) {
          while ( k > map[i].size() ) {
                input = map[i][k];
                if (input == 'p') {
                          goto schleifenende;
                          }
                k++;
                }
          k = 0;
          i++;
          }
schleifenende:

oder hab ich das falsch verstanden ?

Edit: Und was mir im Nachhinein noch aufgefallen ist - du hast vergessen, i zu initialisieren.

wenn Du das in eine Funktion auslagerst, wird's einfach:

bool findeInMeinerMap(vector<string> const& v, char const item, size_t& vPos, size_t& sPos) {
   for(vPos=0; vPos < v.size(); ++vPos) {
      for(sPos=0; sPos < v[vPos].size(); ++sPos) {
         if(v[vPos][sPos] == item) return true;
      }
   }
   return false;
}

int main (int argc, char **argv)
{
   vector<string> map;
   size_t vPos, sPos;
   for(size_t i=0; i<8; ++i) map.push_back("Simon2");

   if(findeInMeinerMap(map, 'i', vPos, sPos)) 
      cout << "gefunden: " << vPos << ", " << sPos << "\n";
   else cout << "NICHT gefunden\n";

   return 0;
}

Aber Du kannst natürlich auch string.find() einsetzen, das spart Dir die innere Schleife:

bool findeInMeinerMap(vector<string> const& v, char const item, size_t& vPos, size_t& sPos) {
   for(vPos=0; vPos < v.size(); ++vPos) {
      sPos = v[vPos].find(item);
      if(string::npos != sPos) return true;
   }
   return false;
}

... oder Du bastelst Dir ein Konstrukt, das std::find_if() auf vector nutzt.

Gruß,

Simon2.

und nochwas: was erhalte ich als ergebnis?

@CStoll
mhja, aber ich hab irgendwie eine while-sympathie xD

ja is klah, das war ja auch nurnochma schnell hier gepostet

s.o.

alled klah!

mh, tut mir leid, aber ich habs jetz scho selbst gelöst

sieht jetz so aus:

int i = 0;
    int k = 0;
    while (i < map.size()) {
          input = map[i][k];
          if (input == 'p') {
                    break;
                    }
          while ( k != 19 ) {
                input = map[i][k];
                if (input == 'p') {
                          break;
                          }
                k++;
                }

          k = 0;
          i++;
          }

mh, aber das string.find() interessiert mich trotzdem

...
mh, aber das string.find() interessiert mich trotzdem

Hast Du mein Obiges Post gesehen ? Da steht's drin.

Der Vollständigkeit halber (wenn auch für dieses konkrete Aufgabe woh ein wenig oversized) noch die "std::find_if"-Variante:

#include <algorithm>
using std::find_if;

struct locateChar{ // "Functor" = Typ, der als Funktion genutzt wird
   locateChar(char i, size_t& pos) : item(i), sPos(pos) {}
   char const item;
   size_t& sPos;
   bool operator()(string const& s) { // Funktionsoperator liefert true zurück, wenn char gefunden
      sPos = s.find(item);
      return (string::npos != sPos);
   }
};   

bool findeInMeinerMap(vector<string> const& v, char const item, size_t& vPos, size_t& sPos) {
   locateChar loc(item, sPos);
   vector<string>::const_iterator vIter = find_if(v.begin(), v.end(), loc);
   if(vIter == v.end()) return false;
   vPos = vIter - v.begin(); // Position bestimmen
   return true;
}

Übrigens zu Deiner Lösung: Du fragst k immer noch auf einen festen Wert ab ... da täte ich auch nochmal "size()" rein....

Gruß,

Simon2.

vielen dank!

huijuijui, das sieht alled so kompliziert aus

...
huijuijui, das sieht alled so kompliziert aus

OK, die find_if()-Geschichte vielleicht (ist aber ein Konzept, das Dir noch häufiger begegnen und oftmals die Sache einfacher machen wird) ... aber
das hier

bool findeInMeinerMap(vector<string> const& v, char const item, size_t& vPos, size_t& sPos) {
   for(vPos=0; vPos < v.size(); ++vPos) {
      sPos = v[vPos].find(item);
      if(string::npos != sPos) return true;
   }
   return false;
}

Ist doch wirklich selbsterklärender als Dein Code, oder ?
Von mir aus auch in der "while-Variante":

bool findeInMeinerMap(vector<string> const& v, char const item, size_t& vPos, size_t& sPos) {
   vPos=0;
   while(vPos < v.size()) {
      sPos = v[vPos].find(item);
      if(string::npos != sPos) return true;
      ++vPos
   }
   return false;
}

Gruß,

Simon2.

naja, bin eh erstma in der testphase, muss mir noch ein bissl das objektorientierte angucken mit
objekt erstellen
methoden ....

usw... bei php ma ein bissl angeschnitten aber das is ja hier was andres xD

greetz. hok