=====List constructors=====
Syntax:

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

The default list constructor takes no arguments, creates a new instance of that
list.

The second constructor is a default copy constructor that can be used to create
a new list that is a copy of the given list c.

The third constructor creates a list with space for num objects. If val is
specified, each of those objects will be given that value. For example, the
following code creates a list consisting of five copies of the integer 42:

<code>
   list <int> l1( 5, 42 );
</code>

The last constructor creates a list that is initialized to contain the elements
between start and end. For example:

<code>
   // create a vector of random integers
   cout << "original list: ";
   list<int> l;
   for( int i = 0; i < 20; i++ ) {
     int num = (int) rand() % 10;
     cout << num << " ";
     l.push_back( num );
   }
   cout << endl;
 
    // delete 5 & 7
   list<int>::iterator iter1 = l.begin();
   while( iter1 != l.end() ) {
     list<int>::iterator thisone = iter1;
     ++iter1;
     if ( *thisone == 5 || *thisone == 7 ) {
		cout << "erase " << *thisone << endl;
		l.erase( thisone );
	 }
   }
 
    // find the first element of l that is even
   list<int>::iterator iter2 = l.begin();
   while( iter2 != l.end() && *iter2 % 2 != 0 ) {
     ++iter2;
   }
 
   // find the last element of l that is even
   list<int>::iterator iter3 = l.end();
   do {
     --iter3;
   } while( iter3 != l.begin() && *iter3 % 2 != 0 );
 
   cout << "first even number: " << *iter2 << ", last even number: " << *iter3 << endl;
 
   cout << "new list: ";
   list<int> l2( iter2, iter3 );
   list<int>::iterator iter4 = l2.begin();
   while( iter4 != l2.end() ) {
     cout << *iter4 << " ";
	 ++iter4;
   }
   cout << endl;
</code>

When run, this code displays the following output:

<code terminal>
  original list: 7 9 3 8 0 2 4 8 3 9 0 5 2 2 7 3 7 9 0 2 
  erase 7
   erase 5
   erase 7
   erase 7
   first even number: 8, last even number: 2
   new list: 8 0 2 4 8 3 9 0 2 2 3 9 0 
</code>

All of these constructors run in [[/complexity|linear time]] except the first, which runs in
[[/complexity|constant time]].

The default destructor calls the destructor for each object in the list with linear complexity.