Verstehe Codeteil nicht:

777

Hey Leute,
Folgende Schleife schreibt Werte von 1 - 10 in den vector ivec.
Der Code ist aus meinem C++ Buch.
Was ich jedoch auch nach der Erklärung im Buch nicht verstehe ist der Teil mit 'Size_type'.

Die Vectorklasse hat verschiedene Eigenschaften. size(), empty()...
Aber size_type ist was genau? Ein Typ?
Was soll dieser Teil in der For-Schleife?

#include <iostream>
#include <vector>
using std::cout;
using std::endl;
using std::vector;
int main() 
{ 
   vector<int> ivec(30);
   for(vector<int>::size_type ix = 0; ix != 10; ++ix)
      ivec[ix] = ix;
}

Wenn ich dieses 'Problem' hätte lösen sollen hätte ich es nämlich einfach so gemacht:

#include <iostream>
#include <vector>
using std::cout;
using std::endl;
using std::vector;
int main() 
{ 
   vector<int> ivec(30);
   for(int ix = 0; ix != 10; ++ix)
      ivec[ix] = ix;
}

Was ist der Vorteil des Buchcodes?

cya
David

SideWinder

Ja, size_type ist ein "innerer Typ" von vector. Du legst statt einem int als Zählvariable eine Variable vom Typ vector<T>::size_type an.

MfG SideWinder

(Für später: Tatsächlich ist size_type ein typedef auf einen anderen Typ)

C++ Forumbot

Dieser Thread wurde von Moderator/in SideWinder aus dem Forum DOS und Win32-Konsole in das Forum C++ verschoben.

Im Zweifelsfall bitte auch folgende Hinweise beachten:
C/C++ Forum :: FAQ - Sonstiges :: Wohin mit meiner Frage?

Dieses Posting wurde automatisch erzeugt.

CStoll

Der Vorteil von size_type gegenüber int ist, daß es genau der Typ ist, mit dem auch die vector<>-Methoden (size(), op[] etc) arbeiten.

(Für später: Tatsächlich ist size_type ein typedef auf einen anderen Typ)

Genau genommen ist's meistens ein typedef auf std::size_t (und das ist ein ausreichend großer vorzeichenloser Typ für Größenangaben).

777

Das heißt int wird auch gleichzeitig als unsigned declariert?
In diesem Fall der einzige Vorteil? Wenn size_type ja eh nur ein synonym für int ist...-.-

Braunstein

777 schrieb:

Das heißt int wird auch gleichzeitig als unsigned declariert?

Was willst du uns damit sagen?
int und unsigend int sind zwei verschiedene Typen.

CStoll

777 schrieb:

Das heißt int wird auch gleichzeitig als unsigned declariert?

was heißt das bitte auf deutsch?

In diesem Fall der einzige Vorteil? Wenn size_type ja eh nur ein synonym für int ist...-.-

Nein, size_t ist kein Synonym für (signed) int - bestenfalls für unsigned int (aber der Standard legt nicht fest, ob es ein typedef auf "unsigned int", "unsigned long" oder ein völlig eigenständiger Datentyp ist).

Badestrand

Ich glaube auch kaum, dass jemand vector<T>::size_type als Zählervariable nimmt (oder doch?). In der Regel spielt das sowieso nur eine Rolle, wenn mehr als 2 Millionen Elemente drin sind, da ein 32-Bit-int (jaja, int kann auch größer oder kleiner sein) keine Zahlen über 2 Mio darstellen kann.
In meiner Implementation (MSVC 2003) nehme ich immer size_t, denn das stellt dort einen unsigned 64-Bit-Integer dar, welcher auf jeden Fall ausreicht. Und, was auch wichtig ist, man braucht keine casts, denn for ( int i=0; i!=vec.size(); ++i ) ergibt meistens eine Compiler-Warnung. Und die sind nervig

Mhh... warnungen habe ich nicht.
Es geht eben auf beide Weisen gleich gut.
Mir war halt nur nicht ganz klar, was die Methode im Buch genau bringt... -.-

hustbaer

size_type braucht man nur wenn man mit einem Vektor arbeiten muss von dem man nicht weiss wie viele Elemente er enthalten kann, und einen Index abspeichern möchte.

Wenn man aber von Index 0 bis 9 durchgeht ... dann tuts ein unsigned (int/short/char) genauso. Ein signed int evtl. auch, kommt auf die Situation an was gescheiter ist.

Badestrand

Im Prinzip sehe ich nur einen Vorteil von unsigned gegenüber signed (außer der größeren Reichweite in den positiven Ganzzahlen): Beim Prüfen, ob ein Index valid ist, braucht es beim unsigned nur ein if ( i < vec.size() ) , beim int muss man auch auf <0 prüfen.
Könnte auch ein Grund sein, warum es in Java kein richtiges unsigned mehr gibt.

777

size_type braucht man nur wenn man mit einem Vektor arbeiten muss von dem man nicht weiss wie viele Elemente er enthalten kann, und einen Index abspeichern möchte.

Das wiederum verstehe ich jetzt auch wieder nicht...-.- im Buch steht, dass Vectoren dynamisch sind.
Das heißt, dass man auch wenn sie schon erstellt sind so viele Elemente bekommen können, wie man möchte.
Und die Größe lässt sich ja jederzeit ermitteln.
Zudem verstehe ich ach die Schreibweise allgemein nicht so ganz.
Wenn ich auf eine Klasse zugreifen wollte so ging das früher immer mit dem .-Operator.

Klasse.typderklasse

Der Doppelpunkt greift auf genau was zu? Eine Klasse innerhalb einer Bibliothek?-.-

cya

David

LordJaxom

777 schrieb:

size_type braucht man nur wenn man mit einem Vektor arbeiten muss von dem man nicht weiss wie viele Elemente er enthalten kann, und einen Index abspeichern möchte.

Das wiederum verstehe ich jetzt auch wieder nicht...-.- im Buch steht, dass Vectoren dynamisch sind.
Das heißt, dass man auch wenn sie schon erstellt sind so viele Elemente bekommen können, wie man möchte.

Der Satz ist auch arg unglücklich formuliert. Um einen Index auf einen Vector abzuspeichern, sollte (TM) man grundsätzlich denselben Typ nehmen, den der Vector selbst auch als Index erwartet. Und das ist size_type. Unsigned (d.h. ohne Vorzeichen) ist dieser Typ zum einen deshalb, weil ein Vektor keinen Index kleiner 0 haben kann, und zum anderen, weil man sonst den halben Wertebereich verlieren würde.

size_type ist ein typedef (auf std::size_t), welches innerhalb des Klassemtemplate std::vector beheimatet ist. Da Typen statische Informationen sind, kannst Du auf sie nicht per Objekt.Typ zugreifen, sondern per Klasse::Typ.

camper

size_type eines Containers geht immer auf ein typedef auf den entsprechenden size_type des zugrundeliegenden Allokators zurück (außer ggf. vector<bool,A>, dass sowieso kein Container ist) - was nicht unbedingt heißen muss, dass diese identisch sind. Der Defaultallokator deklariert dieses nun als size_t - bei einem anderen Allokator kann das anders aussehen. Da std::vector allerdings garantiert, dass Elemente in einem Array speichert und dieses Array selbst ein Objekt im Sinne von C++ ist, kann man schließen, dass der Wertebereich von size_t in jedem Falle ausreichend für das Indizieren in einen std::vector ist (es könnte nur ggf. ineffizient sein).
zusammenfassend:
C<T>::size_type ist immer der allgemein brauchbare Weg, für alle Container C
std::size_t kann man fehlerfrei als Alternative mit std::vector benutzen.