explicit list ( const Allocator& = Allocator() );
explicit list ( size_type n, const T& value = T(), const Allocator& = Allocator() );
template < class InputIterator >
         list ( InputIterator first, InputIterator last, const Allocator& = Allocator() );
list ( const list<T,Allocator>& x );

Construct list

Constructs a list container object, initializing its contents depending on the constructor version used:

explicit list ( const Allocator& = Allocator() );

Default constructor: constructs an empty list object, with no content and a size of zero.

explicit list ( size_type n, const T& value= T(), const Allocator& = Allocator() );

Repetitive sequence constructor: Initializes the container object with its content set to a repetition, n times, of copies of value.

template <class InputIterator> list ( InputIterator first, InputIterator last, const Allocator& = Allocator() );

Iteration constructor: Iterates between first and last, setting a copy of each of the sequence of elements as the content of the container object.

list ( const list<T,Allocator>& x );

Copy constructor: The object is initialized to have the same contents and properties as the x list object.

Parameters

n

Times that value is repeated to form the content of the object.
Member type size_type is an unsigned integral type.

value

Value to be repeated n times as the content of the object.
T is the first class template parameter (the type of the elements stored in the list).

first, last

Input iterators to the initial and final positions in a sequence. The range used is [first,last), which includes all the elements between first and last, including the element pointed by first but not the element pointed by last.
The function template type can be any type of input iterator.

x

Another list object with the same class template parameters (T and Allocator).

unnamed Allocator parameter

Allocator object to be used instead of constructing a new one.
For class instantiations using their version of the default allocator class template, this parameter is not relevant.

Example

// constructing lists
#include <iostream>
#include <list>
using namespace std;

int main ()
{
  // constructors used in the same order as described above:
  list<int> first;                                // empty list of ints
  list<int> second (4,100);                       // four ints with value 100
  list<int> third (second.begin(),second.end());  // iterating through second
  list<int> fourth (third);                       // a copy of third

  // the iterator constructor can also be used to construct from arrays:
  int myints[] = {16,2,77,29};
  list<int> fifth (myints, myints + sizeof(myints) / sizeof(int) );

  cout << "The contents of fifth are: ";
  for (list<int>::iterator it = fifth.begin(); it != fifth.end(); it++)
    cout << *it << " ";

  cout << endl;

  return 0;
}

The contents of fifth are: 16 2 77 29 

Complexity

See also