STL之序列式容器（deque和list）

std::deque<int> a_deque;    // A deque container with no elements
std::deque<int> my_deque(10); // A deque container with 10 elements

std:: deque<std:: string> words { "one", "none", "some", "all","none","most", "many” };

std::deque<std::string> words_copy { words };// Makes a copy of the words c
std::deque<std::string> words_part { std::begin(words),std::begin(words) + 5 };

std::cout << words.at(2) << std::endl; // Output the third element in words

    std::deque<int> numbers {2, 3, 4};
    numbers.push_front(11); // numbers contains 11 2 3 4
    numbers.push_back(12);  // numbers contains 11 2 3 4 12
    numbers.pop_front();    // numbers contains 2 3 4 12

std::deque<std::string> words {"one", "two", "three", "four"};
    auto init_list = {std::string{"seven"}, std::string{ "eight"}, std::string{"nine"}};
    words.assign(init_list);
    words.assign({"seven”，"eight","nine"});
    
    std::vector<std::string> wordset {"this","that","these","those"};
    words.assign(std::begin(wordset)+1, --std::end(wordset));
    //Assigns "that" and "these"

    // Using a deque container
    #include <iostream> // For standard streams
    #include <algorithm> // For copy()
    #include <deque> // For deque container
    #include <string> // For string classes
    #include <iterator> // For front_insert_iterator & stream iterators
    using std::string;
    int main()
    {
        std::deque<string> names;
        std::cout << "Enter first names separated by spaces. Enter Ctrl+Z on a new line to end:\n";
        std::copy(std::istream_iterator < string > {std::cin}, std::istream_iterator < string > {}, std::front_inserter(names));
        std::cout << "\nIn reverse order, the names you entered are:\n";
        std::copy(std::begin(names), std::end(names), std::ostream_iterator < string > {std::cout, "  "});
        std::cout << std::endl;
    }

list 容器的构造函数的用法类似于 vector 或 deque 容器。
    std::list<std::string> words;

可以创建一个带有给定数量的默认元素的列表：
    std::list<std::string> sayings {20}; // A list of 20 empty strings

如何生成一个包含给定数量的相同元素的列表：
    std::list<double> values(50, 3.14159265);
不能使用初始化列表 {50,3.14159265}，这样列表将仅仅包含两个元素。

list 容器有一个拷贝构造函数，因此可以生成一个现有 list 容器的副本：
    std::list<double> save_values {values}; // Duplicate of values

用另一个序列的开始和结束迭代器所指定的一段元素，来构造 list 容器的初始化：
    std::list<double> samples {++cbegin(values), --cend(values)};

    std::list<std::string> names { "Jane", "Jim", "Jules", "Janet"};
    names.push_front("Ian"); // Add string ("Ian") to the front of the list
    names.push_back("Kitty"); // Append string ("Kitty") to the end of the list

   names.emplace_front("Ian");//Create string ("Ian") in place at the front of the list
   names.emplace_back("Kitty");// Create string ("Kitty") in place at the end of the list

     std::list<int> data(10, 55); // List of 10 elements with value 55
    data.insert(++begin(data), 66); // Insert 66 as the second element

     auto iter = begin(data);
    std::advance(iter, 9); // Increase iter by 9
    data.insert(iter, 3, 88);// Insert 3 copies of 88 starting at the 10th

     std::vector<int> numbers(10, 5)/ // Vector of 10 elements with value 5
    data.insert(--(--end(data)), cbegin(numbers), cend(numbers));

     std::list<std:: string> names {"Jane", "Jim", "Jules", "Janet"};
    names.emplace_back("Ann");
    std:: string name ("Alan");
    names.emplace_back(std::move(name));
    names.emplace_front("Hugo");
    names.emplace(++begin(names), "Hannah");

    std::list<int> numbers { 2, 5, 2, 3, 6, 7, 8, 2, 9};
    numbers.remove(2); // List is now 5 3 6 7 8 9
第二条语句移除了 numbers 中出现的所有值等于 2 的元素。

    numbers.remove_if([](int n){return n%2 == 0;});// Remove even numbers. Result 5 3 7 9
这里的参数是一个 lambda 表达式，但也可以是一个函数对象。

成员函数 unique() 非常有意思，它可以移除连续的重复元素，留下其中的第一个。
    std::list<std::string> words { "one", "two", "two", "two","three", "four", "four"};
    words.unique () ; // Now contains "one" "two" "three" "four"

names.sort(std::greater<std::string>()); // Names in descending sequence
 names.sort(std::greater<>()); // Function object uses perfect forwarding

// Order strings by length when the initial letters are the same
class my_greater{  
public:  
bool operator () (const std::strings s1, const std::strings s2)  
{        if (s1[0] == s2 [0])            
return si.length() > s2.length();      
else            return s1 > s2;    
}
};

names.sort(my_greater()); // Sort using my_greater

names.sort([](const std::strings s1, const std::strings s2)
{    if (s1[0] == s2[0])        
return s1.length() > s2.length();  
else        return s1 > s2;
});

    std::list<int> my_values {2, 4, 6, 14};
    std::list<int> your_values{ -2, 1, 7, 10};
    my_values.merge (your_values);//my_values contains: -2 1 2 4 6 7 10 14
    your_values.empty(); // Returns true

    std::list<std::string> my_words { "three","six", "eight"};
    std::list<std::string> your_words { "seven", "four", "nine"};
    auto comp_str = [](const std::strings s1, const std::strings s2){ return s1[0]<s2[0];};
    my_words.sort (comp_str); //"eight" "six" "three"
    your_words.sort (comp_str) ;  //"four" "nine" "seven"
    my_words.merge (your_words, comp_str) ; // "eight" "four" "nine" "six" "seven" "three"

your_words: "seven", "nine"my_words : "three", "four", "six", "eight"

your_words.splice(++std::begin(your_words),my_words,++std::begin(my_words), std::end(my_words));

your_words:"seven", "four", "six", "eight","nine" my_words: "three"

my_words.splice(std::begin(my_words), your_words);

your_words.splice(std::end(your_words), my_words);

无法使用反向迭代器。只能从它得到const或non-const前向迭代器，这些迭代器都不能解引用，只能自增；
 没有可以返回最后一个元素引用的成员函数back();只有成员函数front();
 因为只能通过自增前面元素的迭代器来到达序列的终点，所以push_back()、pop_back()、emplace_back()也无法使用。

std::forward_list<std::string> my_words {"three", "six", "eight"};auto count = std::distance(std::begin(my_words),std::end(my_words));// Result is 3

std::forward_list<int> data {10, 21, 43, 87, 175, 351};
auto iter = std::begin(data);
size_t n {3};
std::advance(iter, n);
std::cout << "The " << n+1 << "th element is n << *iter << std::endl;// Outputs 87

std::forward_list<std::string> my_words {"three", "six", "eight"}
std::forward_list<std::string> your_words {"seven", "four", "nine"};
my_words.splice_after(my_words.before_begin(), your_words, ++std::begin(your_words));

my_words.splice_after (my_words . before_begin () , your_words,++std::begin(your_words), std::end(your_words));