Am besten gibst du uns dein Beispiel und wir erklären dir, wo und wieso es dort stehen muss.

Ich möchte nun bestimmte Iteratoren definieren um diese in Schleifen zu benutzen. Sollte ich jetzt die typedef-Definition z.B. in der Header nach den includes und vor irgendwelchen Klassen machen oder macht es mehr Sinn die typedef-Definition direkt vor den angesprochenen Schleifen aufzuführen. Wie gesagt simples Beispiel!

for(auto it = vec.begin(); ...)

Wenn du aber dennoch auch typedef bestehst, dann mache es vor der Schleife. Wenn du es aber öfters benutzt, also durchgehend auch an anderen Stellen, dann hängt das wiederum vom Design ab, wo es hingehört. Aber ich empfehle dir, benutze in diesen Schleifen-Fällen nur noch auto (http://www.c-plusplus.net/forum/p2251480#2251480).

auto int bsp;

Aber das ist ja gleichbedeutend mit

int bsp;

Handelt sich bei deinem Beispiel und meinem

auto

um dasselbe oder hat es bei dir einen anderen Zusammenhang?

Ich möchte z.B. eine print-Funktion schreiben.

class Map {
private:
   map<int, vector<int> > myMap;
   //usw...

public:
    void printMap() const {
         for(auto map_it = myMap.begin();map_it != myMap.end();map_it++) {
              cout << (*map_it).first << ": ";
              for(auto vec_it = (*map_it).second.begin();vec_it < (*map_it).second.end();vec_it++) {
                  cout << *vec_it << " ";
              }
         }
    }
    //usw....
}

Wäre es dann so sinnvoll?

Ein paar Code-Kleinigkeiten:
- Du könntest statt (*x).y auch x->y benutzen
- Bei der vector-Schleife auch in der Bedingung bitte != benutzen
- Dir vielleicht angewöhnen ++it statt it++ zu schreiben
- Seit C++11 kannst du auch die spitzen Klammern zusammen schreiben:

map<int, vector<int>> myMap;

Ne globale Variable statt einem Parameter?

Ich hatte eher das Gefühl, das steht da nur, um uns zu zeigen was myMap überhaupt ist.

- Dir vielleicht angewöhnen ++it statt it++ zu schreiben

Ist es in der Schleife nicht egal ob ich ++it oder it++ schreibe?!

Ist es in der Schleife nicht egal ob ich ++it oder it++ schreibe?!

VOm Ergebnis her ja, von der Performance her nicht.

it++ erhöht ja den Iterator und gibt den Iterator zurück, wie er vor der Erhöhung war. Auch wenn du den Rückgabewert nicht benutzt, muss dafür eine Kopie angelegt werden, die hinterher zurückgegeben werden kann - und nicht benutzt wird, also völlig unnötig ist.

int a = 0;
int b = a++; // b ist nun 0 und a auf 1

int c = 0;
int d = ++d; // d ist nun 1 und c ebenfalls

Der Postinkrement-Operator (x++) gibt den aktuellen Wert von x zurück und inkrementiert danach. Der Preinkrement-Operator (++x) inkrementiert x und gibt den inkrementierten Wert zurück. Wenn du den Operator mal für deine Klasse selbst implementieren solltest, dann sieht das so aus:

MyClass& operator++() // Preinkrement
{
    this.irgendwas erhöhen
    return *this;
}

MyClass operator++(int) // Postinkrement
{
    MyClass temp = *this;
    ++(*this); // über preinkrment erhöhen
    return temp; // alten Wert zurückgeben
}

Du siehst, in ++(int) steht ein bissl mehr, was auch ein bissl mehr dann kostet. Ich schaetze aber ehe, dass dein Compiler das in den meisten Faellen richtig optimiert. Trotzdem willst du ja in deinem Beispiel nur das it erhöhen. Das es dir aber mit dem Postinkrement eine weitere Funktionalitaet zur Verfügung stellt, interessiert ja nicht. Wieso für etwas zahlen, wenn man es nicht benutzt. Auch wenn das PODs (FAQ) keine Rolle spielt, gewöhne es dir an.

PS: Irgendwie sieht das Wort Pre-/Postinkrement komisch aus