List constructors

Syntax:

    #include <list>
    list();
    list( const list& c );
    explicit list( size_type num, const T& val = T() );
    list( input_iterator start, input_iterator end );
    ~list();

Der Standardkonstruktor nimmt keine Argumente und erzeugt eine neue Instanz einer Liste.

Der zweite Konstruktor ist der standard copy constructor, welcher dazu benutzt werden kann,

eine neue Liste zu erstellen, die eine Kopie einer gegebenen Liste c darstellt.

Der dritte Konstruktor erzeugt eine Liste mit num Elementen. Falls val angegeben ist, wird jedes Element mit diesem Wert initialisiert. Zum Beispiel erzeugt folgender Code eine Liste mit Fünf Kopien der Zahl 42:

   list <int> l1( 5, 42 );

Der letzte Konstruktor erzeugt eine Liste, welche mit den Werten zwischen start und end Initialisiert wird. Zum Beispiel:

   // Erzeugt einen Vektor mit Zufalls Ganzzahlen zwischen 0 und 9
   cout << "Original Liste: ";
   list<int> l;
   for( int i = 0; i < 20; i++ ) {
     int num = (int) rand() % 10;
     cout << num << " ";
     l.push_back( num );
   }
   cout << endl;
 
    // entferne 5 & 7
   list<int>::iterator iter1 = l.begin();
   while( iter1 != l.end() ) {
     list<int>::iterator thisone = iter1;
     ++iter1;
     if ( *thisone == 5 || *thisone == 7 ) {
		cout << "entferne " << *thisone << endl;
		l.erase( thisone );
	 }
   }
 
    // Finde das erste gerade Element von l
   list<int>::iterator iter2 = l.begin();
   while( iter2 != l.end() && *iter2 % 2 != 0 ) {
     ++iter2;
   }
 
   // Finde das letzte gerade Element von l
   list<int>::iterator iter3 = l.end();
   do {
     --iter3;
   } while( iter3 != l.begin() && *iter3 % 2 != 0 );
 
   cout << "erste gerade Zahl: " << *iter2 << ", letzte gerade Zahl: " << *iter3 << endl;
 
   cout << "neue Liste: ";
   list<int> l2( iter2, iter3 );
   list<int>::iterator iter4 = l2.begin();
   while( iter4 != l2.end() ) {
     cout << *iter4 << " ";
	 ++iter4;
   }
   cout << endl;

Dieser Code produziert die folgende Ausgabe:

   Original Liste: 7 9 3 8 0 2 4 8 3 9 0 5 2 2 7 3 7 9 0 2 
   entferne 7
   entferne 5
   entferne 7
   entferne 7
   erste gerade Zahl: 8, letzte gerade Zahl: 2
   neue Liste: 8 0 2 4 8 3 9 0 2 2 3 9 0

Der erste Konstruktor benötigt constant time, alle andere Konstruktoren laufen in linear time ab.

Bei Zerstörung der Liste wird der Standarddestruktor aufgerufen, welcher die Destruktoren jedes Elementes in der Liste mit linear complexity aufruft.