"Richtige" Positionierung von typedef-Definitionen

Google mal nach "C++11 auto". Hier ne kurze Einführung: http://www.stroustrup.com/C++11FAQ.html#auto

Zero07

Das heißt ich hab folgendes Beispiel:

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?

cooky451

auto? Ja. Ne globale Variable statt einem Parameter? Nein. (Aber das const sieht so aus, als wäre es aus einer Klasse kopiert.)

Ja. Weist du, ob dein Compiler überhaupt C++11 Features unterstützt?

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;

cooky451 schrieb:

Ne globale Variable statt einem Parameter?

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

Zero07

Ja so war es gemeint, aber hab es eh editiert.
Ok danke;) Ja unterstützt er.

Zero07

KasF schrieb:

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

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

pumuckl

Zero07 schrieb:

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.

Noch ein klein wenig ausführlicher:

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

Zero07

Es leuchtet mir ein

&quot;Richtige&quot; Positionierung von typedef-Definitionen

"Richtige" Positionierung von typedef-Definitionen