Какой контейнер в STL и для чего эффективнее использовать?

/////////////////////////////////////////////////////////////////////////////////////////
#include <algorithm>
#include <cctype>
#include <iostream>
#include <iterator>
#include <map>
#include <memory>
#include <numeric>
#include <set>
#include <string>
/////////////////////////////////////////////////////////////////////////////////////////
typedef std::string             T_str;
typedef std::set    < int   >   T_numbers;
/////////////////////////////////////////////////////////////////////////////////////////
enum    T_container
{
    FORWARD_LIST,
    LIST,
    ARRAY,
 
    VECTOR,
    STRING,
    DEQUE,
 
    UNORDERED_MAP,
    UNORDERED_SET,
    UNORDERED_MULTIMAP,
 
    UNORDERED_MULTISET,
    SET,
    MAP,
 
    MULTISET,
    MULTIMAP,
    STACK,
 
    QUEUE,
    PRIORITY_QUEUE
};
/////////////////////////////////////////////////////////////////////////////////////////
typedef std::set    < T_container               >   T_containers;
typedef std::map    < T_str,    T_containers    >   T_containers_of_answer;
/////////////////////////////////////////////////////////////////////////////////////////
template< typename  TT_set >
TT_set  &   operator-=
    (
        TT_set          &   L,
        TT_set  const   &   R
    )
{
    TT_set  res_set;
 
    std::set_difference
        (
            L.begin  (),
            L.end    (),
            R.begin  (),
            R.end    (),
 
            std::inserter
                (
                    res_set,
                    res_set.begin()
                )
        );
 
    return  L   =   res_set;
}
/////////////////////////////////////////////////////////////////////////////////////////
template
    <
        typename    TT_set,
        typename    TT_elem
    >
TT_set  &   operator-=
    (
        TT_set              &   L,
        TT_elem     const   &   R
    )
{
    L.erase( R );
    return  L;
}
/////////////////////////////////////////////////////////////////////////////////////////
template
    <
        typename    TT_set,
        typename    TT__set_or_elem
    >
TT_set  operator-
    (
        TT_set              const   &   L,
        TT__set_or_elem     const   &   R
    )
{
    auto    res     =   L;
    return  res     -=  R;
}
/////////////////////////////////////////////////////////////////////////////////////////
template
    <
        typename    TT_set,
        typename    TT_elem
    >
TT_set  &   operator+=
    (
        TT_set              &   L,
        TT_elem     const   &   R
    )
{
    L.insert( R );
    return  L;
}
/////////////////////////////////////////////////////////////////////////////////////////
template< typename  TT_set >
TT_set  &   operator+=
    (
        TT_set          &   L,
        TT_set  const   &   R
    )
{
    TT_set  res_set;
 
    std::set_union
        (
            L.begin  (),
            L.end    (),
            R.begin  (),
            R.end    (),
 
            std::inserter
                (
                    res_set,
                    res_set.begin()
                )
        );
 
    return  L   =   res_set;
}
/////////////////////////////////////////////////////////////////////////////////////////
template
    <
        typename    TT_set,
        typename    TT__set_or_elem
    >
TT_set  operator+
    (
        TT_set              const   &   L,
        TT__set_or_elem     const   &   R
    )
{
    auto    res     =   L;
    return  res     +=  R;
}
/////////////////////////////////////////////////////////////////////////////////////////
template< typename  TT_set >
TT_set  &   operator*=
    (
        TT_set          &   L,
        TT_set  const   &   R
    )
{
    TT_set  res_set;
 
    std::set_intersection
        (
            L.begin  (),
            L.end    (),
            R.begin  (),
            R.end    (),
 
            std::inserter
                (
                    res_set,
                    res_set.begin()
                )
        );
 
    return  L   =   res_set;
}
/////////////////////////////////////////////////////////////////////////////////////////
template< typename  TT_set >
TT_set  operator*
    (
        TT_set  const   &   L,
        TT_set  const   &   R
    )
{
    auto    res     =   L;
    return  res     *=  R;
}
/////////////////////////////////////////////////////////////////////////////////////////
template< typename  TT_set >
bool    is_subset_of
    (
        TT_set  const   &   L,
        TT_set  const   &   R
    )
{
    return  std::includes
                (
                    R.begin     (),
                    R.end       (),
                    L.begin     (),
                    L.end       ()
                );
}
/////////////////////////////////////////////////////////////////////////////////////////
struct  T_containers_data
{
    //-----------------------------------------------------------------------------------
    T_containers    lists_containers_;
    T_containers    arrays_containers_;
    T_containers    hash_containers_;
 
    T_containers    tree_containers_;
    T_containers    adapters_;
    T_containers    key_containers_;
 
    T_containers    all_containers_;
    T_containers    lists_and_deque_containers_;
    T_containers    not_multi_key_containers_;
 
    T_containers    sets_containers_;
    T_containers    lists_and_deque_and_hash_containers_;
    T_containers    vector_and_string_containers_;
 
    T_containers    lists_and_hash_containers_;
    T_containers    array_containers_;
    T_containers    vector_deque_string_containers_;
 
    T_containers    not_key_containers_;
    T_containers    lists_and_key_containers_;
    T_containers    array_and_vector_and_string_containers_;
 
    T_containers    forward_list_and_deque_and_hash_containers_;
    T_containers    not_forward_list_containers_;
    T_containers    not_arrays_containers_;
    //-----------------------------------------------------------------------------------
    T_containers_data()
    {
        //===============================================================================
        lists_containers_               .insert( FORWARD_LIST           );
        lists_containers_               .insert( LIST                   );
        //===============================================================================
        arrays_containers_              .insert( ARRAY                  );
        arrays_containers_              .insert( VECTOR                 );
        arrays_containers_              .insert( DEQUE                  );
        arrays_containers_              .insert( STRING                 );
        //===============================================================================
        hash_containers_                .insert( UNORDERED_SET          );
        hash_containers_                .insert( UNORDERED_MAP          );
        hash_containers_                .insert( UNORDERED_MULTISET     );
        hash_containers_                .insert( UNORDERED_MULTIMAP     );
        //===============================================================================
        tree_containers_                .insert( SET                    );
        tree_containers_                .insert( MAP                    );
        tree_containers_                .insert( MULTISET               );
        tree_containers_                .insert( MULTIMAP               );
        //===============================================================================
        adapters_                       .insert( STACK                  );
        adapters_                       .insert( QUEUE                  );
        adapters_                       .insert( PRIORITY_QUEUE         );
        //===============================================================================
        not_multi_key_containers_       .insert( SET                    );
        not_multi_key_containers_       .insert( MAP                    );
        not_multi_key_containers_       .insert( UNORDERED_SET          );
        not_multi_key_containers_       .insert( UNORDERED_MAP          );
        //===============================================================================
        sets_containers_                .insert( SET                    );
        sets_containers_                .insert( MULTISET               );
        sets_containers_                .insert( UNORDERED_SET          );
        sets_containers_                .insert( UNORDERED_MULTISET     );
        //===============================================================================
        array_containers_               .insert( ARRAY                  );
        //===============================================================================
        not_forward_list_containers_    .insert( LIST                   );
        //===============================================================================
        vector_and_string_containers_   .insert( VECTOR                 );
        vector_and_string_containers_   .insert( STRING                 );
        //===============================================================================
        key_containers_                                 =       hash_containers_
                                                            +   tree_containers_;
        //===============================================================================
        all_containers_                                 =       lists_containers_
                                                            +   arrays_containers_
                                                            +   key_containers_
                                                            +   adapters_;
        //===============================================================================
        lists_and_deque_containers_                     =       lists_containers_
                                                            +   DEQUE;
        //===============================================================================
        lists_and_deque_and_hash_containers_            =       lists_and_deque_containers_
                                                            +   hash_containers_;
        //===============================================================================
        lists_and_hash_containers_                      =       lists_containers_
                                                            +   hash_containers_;
        //===============================================================================
        vector_deque_string_containers_                 =       arrays_containers_
                                                            -   array_containers_;
        //===============================================================================

        not_key_containers_                             =       all_containers_
                                                            -   key_containers_
                                                            -   adapters_;
        //===============================================================================
        lists_and_key_containers_                          =       lists_containers_
                                                                +   key_containers_;
        //===============================================================================
        array_and_vector_and_string_containers_         =       arrays_containers_
                                                            -   DEQUE;
        //===============================================================================
        forward_list_and_deque_and_hash_containers_     =       lists_and_deque_and_hash_containers_
                                                            -   LIST;
        //===============================================================================
        not_arrays_containers_                          =       all_containers_
                                                            -   arrays_containers_;
        //===============================================================================
    }
};
/////////////////////////////////////////////////////////////////////////////////////////
const   T_str   ANSWER_YES          =   "1) да";
const   T_str   ANSWER_NO           =   "2) нет";
/////////////////////////////////////////////////////////////////////////////////////////
const   T_str   TYPE_NAME_BUILT_IN  =   "встроенный";
const   T_str   TYPE_NAME_CHAR      =   "char";
const   T_str   TYPE_NAME_BOOL      =   "bool";
const   T_str   USER_DEFINED_TYPE   =   "пользовательский";
/////////////////////////////////////////////////////////////////////////////////////////
class   T_question
{
    //-----------------------------------------------------------------------------------
    T_str   question_text_;
    //-----------------------------------------------------------------------------------
public:
    //-----------------------------------------------------------------------------------
    typedef unsigned long   T_answer_num;
    //-----------------------------------------------------------------------------------
    T_question( T_str   const   &   question_text )
        :
        question_text_( question_text )
    {}
    //-----------------------------------------------------------------------------------
    virtual
    ~T_question()
    {}
    //-----------------------------------------------------------------------------------
    virtual
    bool    there_are_superfluous_containers_in
        ( T_containers  const   &   containers )                                    const   =   0;
    //-----------------------------------------------------------------------------------
    virtual
    int     weight()                                                                const   =   0;
    //-----------------------------------------------------------------------------------
    virtual
    bool    there_are_suitable_containers_to_choose_from_in
        ( T_containers   const   &   containers )                                   const   =   0;
    //-----------------------------------------------------------------------------------
    virtual
    bool    successfully_ask_question_and_set_selected_containers_and_write_to_answers_history
        (
            T_containers    &   containers,
            T_str           &   answers_history
        )                                                                           const
    {
        T_answer_num    answer_num  =   0;
 
        bool            bool_res    =   successfully_for_containers_input_and_set_answer_num
                                            (
                                                containers,
                                                answer_num
                                            );
 
        if( bool_res )
        {
            modify_selected_containers_for_answer_num
                (
                    containers,
                    answer_num
                );
 
            answers_history.append
                (
                    get_text_of_question_and_answer_with_num( answer_num )
                );
        }//if
 
        return  bool_res;
    }
    //-----------------------------------------------------------------------------------
protected:
    //-----------------------------------------------------------------------------------
    bool    there_are_suitable_containers_in
        ( T_containers   const   &   containers )                                   const
    //
    {
        return  !   (
                            containers
                        *   main_containers()
                    )
                    .empty();
    }
    //-----------------------------------------------------------------------------------
    T_str   question_text               ()                                          const
    {
        return  question_text_;
    }
    //-----------------------------------------------------------------------------------
private:
    //-----------------------------------------------------------------------------------
    virtual
    T_containers    main_containers     ()                                          const   =   0;
    //-----------------------------------------------------------------------------------
    virtual
    T_str   get_text_of_question_and_answer_with_num( int  answer_num )             const   =   0;
    //-----------------------------------------------------------------------------------
    bool    successfully_for_containers_input_and_set_answer_num
        (
            T_containers    const   &   containers,
            T_answer_num            &   answer_num
        )                                                                           const
    {
        bool        bool_res    =   false;
        T_numbers   answers_numbers;
        T_str       answers_texts;
 
        for_containers_set_numbers_and_texts_of_not_empty_answers
            (
                containers,
                answers_numbers,
                answers_texts
            );
 
        do
        {
            std::cout   <<  std::endl
                        <<  question_text()
                        <<  std::endl
                        <<  answers_texts;
 
            std::cout   <<  "Введите номер ответа (чтобы пропустить вопрос - просто нажмите Enter): ";
            T_str   s;
            std::cin.sync();
            getline( std::cin,  s );
            bool_res    =   !s.empty();
 
            if( !bool_res )
            {
                break;
            }
 
            try
            {
                answer_num  =   std::stoul( s );
            }
            catch(...)
            {
                continue;
            }
        }
        while   (
                    answers_numbers.count( answer_num )     ==  0
                );
 
        return  bool_res;
    }
    //-----------------------------------------------------------------------------------
    virtual
    void    modify_selected_containers_for_answer_num
        (
            T_containers    &   containers,
            T_answer_num        answer_num
        )                                                                           const   =   0;
    //-----------------------------------------------------------------------------------
    virtual
    void    for_containers_set_numbers_and_texts_of_not_empty_answers
        (
            T_containers    const   &   containers,
            T_numbers               &   numbers,
            T_str                   &   answers_texts
        )                                                                           const  =   0;
    //-----------------------------------------------------------------------------------
};
/////////////////////////////////////////////////////////////////////////////////////////
typedef std::shared_ptr     < T_question    >   T_question_ptr;
/////////////////////////////////////////////////////////////////////////////////////////
struct  T_question_ptrs_comp
{
    //-----------------------------------------------------------------------------------
    bool    operator()
        (
            T_question_ptr  L_ptr,
            T_question_ptr  R_ptr
        )   const
    {
        return      L_ptr->weight()
                >   R_ptr->weight();
    }
    //-----------------------------------------------------------------------------------
};
/////////////////////////////////////////////////////////////////////////////////////////
typedef std::multiset< T_question_ptr,   T_question_ptrs_comp   >   T_question_ptrs;
/////////////////////////////////////////////////////////////////////////////////////////
class   T_yes_question  :   public  T_question
{
    //-----------------------------------------------------------------------------------
    T_containers    containers_for_selecting_;
    T_containers    containers_yes_;
    int             weight_;
    //-----------------------------------------------------------------------------------
public:
    //-----------------------------------------------------------------------------------
    enum    T_weight
    {
        ADAPTERS_QUESTION_WEIGHT                =   200,
        QUICK_BINARY_SEARCH_QUESTION_WEIGHT     =   100
    };
    //-----------------------------------------------------------------------------------
    T_yes_question
        (
            T_str           const   &   question_text,
            T_containers    const   &   containers_for_selecting,
            T_containers    const   &   containers_yes,
            int                         weight
        )
        :
        T_question                  ( question_text             ),
        containers_for_selecting_   ( containers_for_selecting  ),
        containers_yes_             ( containers_yes            ),
        weight_                     ( weight                    )
    {}
    //-----------------------------------------------------------------------------------
    virtual
    ~T_yes_question()
    {}
    //-----------------------------------------------------------------------------------
    virtual
    bool    there_are_superfluous_containers_in
        ( T_containers  const   &   containers )                                    const
    {
        return  !   is_subset_of
                        (
                            containers,
                            containers_for_selecting_
                        );
    }
    //-----------------------------------------------------------------------------------
    virtual
    int     weight()                                                                const
    {
        return  weight_
                    ?   weight_
                    :   main_containers().size();
    }
    //-----------------------------------------------------------------------------------
    virtual
    bool    there_are_suitable_containers_to_choose_from_in
        ( T_containers   const   &   containers )                                   const
    {
        return      there_are_suitable_containers_in( containers )
 
                &&  !is_subset_of
                        (
                            containers,
                            containers_yes()
                        );
    }
    //-----------------------------------------------------------------------------------
protected:
    //-----------------------------------------------------------------------------------
    T_containers    containers_yes()                                                const
    {
        return  containers_yes_;
    }
    //-----------------------------------------------------------------------------------
private:
    //-----------------------------------------------------------------------------------
    virtual
    T_containers    main_containers()                                               const
    {
        return  containers_yes();
    }
    //-----------------------------------------------------------------------------------
};
/////////////////////////////////////////////////////////////////////////////////////////
class   T_yes_or_not_relevant_question   :   public  T_yes_question
{
    //-----------------------------------------------------------------------------------
public:
    //-----------------------------------------------------------------------------------
    T_yes_or_not_relevant_question
        (
            T_str           const   &   question_text,
            T_containers    const   &   containers_for_selecting,
            T_containers    const   &   containers_yes,
            int                         weight  =   0
        )
        :
        T_yes_question
            (
                question_text,
                containers_for_selecting,
                containers_yes,

                weight
            )
    {}
    //-----------------------------------------------------------------------------------
    virtual
    ~T_yes_or_not_relevant_question()
    {}
    //-----------------------------------------------------------------------------------
private:
    //-----------------------------------------------------------------------------------
    virtual
    T_str   get_text_of_question_and_answer_with_num( int  answer_num )             const
    {
        return      "\n"
                +   question_text()
                +   "\t"
                +   ANSWER_YES;
    }
    //-----------------------------------------------------------------------------------
    virtual
    void    modify_selected_containers_for_answer_num
        (
            T_containers    &   containers,
            T_answer_num        answer_num
        )                                                                           const
    {
        containers  *=  containers_yes();
    }
    //-----------------------------------------------------------------------------------
    virtual
    void    for_containers_set_numbers_and_texts_of_not_empty_answers
                (
                    T_containers    const   &   containers,
                    T_numbers               &   numbers,
                    T_str                   &   answers_texts
                )                                                                   const
    {
        numbers.insert(1);
 
        answers_texts.append
            (
                "\t"    +   ANSWER_YES  +   "\n"
            );
    }
    //-----------------------------------------------------------------------------------
};
/////////////////////////////////////////////////////////////////////////////////////////
class   T_yes_or_not_question   :   public  T_yes_question
{
    //-----------------------------------------------------------------------------------
public:
    //-----------------------------------------------------------------------------------
    T_yes_or_not_question
        (
            T_str           const   &   question_text,
            T_containers    const   &   containers_for_selecting,
            T_containers    const   &   containers_yes,
            int                         weight  =   0
        )
        :
        T_yes_question
            (
                question_text,
                containers_for_selecting,
                containers_yes,
                weight
            )
    {}
    //-----------------------------------------------------------------------------------
    virtual
    ~T_yes_or_not_question()
    {}
    //-----------------------------------------------------------------------------------
private:
    //-----------------------------------------------------------------------------------
    virtual
    T_str   get_text_of_question_and_answer_with_num( int  answer_num )             const
    {
        return      "\n"
                +   question_text()
                +   "\t"
                +   (
                        answer_num  ==  1
                            ?   ANSWER_YES
                            :   ANSWER_NO
                    );
    }
    //-----------------------------------------------------------------------------------
    virtual
    void    modify_selected_containers_for_answer_num
        (
            T_containers    &   containers,
            T_answer_num        answer_num
        )                                                                           const
    {
        answer_num  ==  1
            ?   containers  *=  containers_yes()
            :   containers  -=  containers_yes();
    }
    //-----------------------------------------------------------------------------------
    virtual
    void    for_containers_set_numbers_and_texts_of_not_empty_answers
        (
            T_containers    const   &   containers,
            T_numbers               &   numbers,
            T_str                   &   answers_texts
        )                                                                           const
    {
        numbers.insert(1);
        numbers.insert(2);
 
        answers_texts.append
            (
                        "\t"    +   ANSWER_YES  +   "\n"
                    +   "\t"    +   ANSWER_NO   +   "\n"
            );
    }
    //-----------------------------------------------------------------------------------
};
/////////////////////////////////////////////////////////////////////////////////////////
class   T_switch_question   :   public  T_question
{
    //-----------------------------------------------------------------------------------
    T_containers_of_answer  containers_of_answer_;
    //-----------------------------------------------------------------------------------
public:
    //-----------------------------------------------------------------------------------
    T_switch_question
        (
            T_str   const   &   question_text,
            T_str   const   &   answer_A            ,   T_containers    const   &   containers_A,
            T_str   const   &   answer_B    =   ""  ,   T_containers    const   &   containers_B    =   T_containers(),
            T_str   const   &   answer_C    =   ""  ,   T_containers    const   &   containers_C    =   T_containers(),
            T_str   const   &   answer_D    =   ""  ,   T_containers    const   &   containers_D    =   T_containers()
        )
        :
        T_question( question_text )
    {
        containers_of_answer_[ answer_A ]       =   containers_A;
 
        if  (
                !answer_B.empty()
            )
        {
            containers_of_answer_[ answer_B ]   =   containers_B;
        }
 
        if  (
                !answer_C.empty()
            )
        {
            containers_of_answer_[ answer_C ]   =   containers_C;
        }
 
        if  (
                !answer_D.empty()
            )
        {
            containers_of_answer_[ answer_D ]   =   containers_D;
        }
    }
    //-----------------------------------------------------------------------------------
    virtual
    ~T_switch_question()
    {}
    //-----------------------------------------------------------------------------------
    virtual
    bool    there_are_superfluous_containers_in
        ( T_containers  const   &   containers )                                    const
    {
        return  false;
    }
    //-----------------------------------------------------------------------------------
    virtual
    int     weight()                                                                const
    {
        return  main_containers().size();
    }
    //-----------------------------------------------------------------------------------
    virtual
    bool    there_are_suitable_containers_to_choose_from_in
        ( T_containers   const   &   containers )                                   const
    {
        return      there_are_suitable_containers_in            ( containers )
                &&  is_not_subset_of_containers_of_any_answer   ( containers );
    }
    //-----------------------------------------------------------------------------------
private:
    //-----------------------------------------------------------------------------------
    virtual
    T_containers    main_containers()                                               const
    {
        return  std::accumulate
            (
                containers_of_answer_.begin     (),
                containers_of_answer_.end       (),
                T_containers                    (),
 
                [&] (
                        T_containers                        const   &   res_containers,
                        T_containers_of_answer::value_type  const   &   answer_and_containers
                    )
                {
                    return      res_containers
                            +   answer_and_containers.second;
                }
            );
    }
    //-----------------------------------------------------------------------------------
    virtual
    T_str   get_text_of_question_and_answer_with_num( int  answer_num )             const
    {
        auto    answer_and_containers_it    =   containers_of_answer_.begin();
 
        std::advance
            (
                answer_and_containers_it,
                answer_num - 1
            );
 
        return      "\n"
                +   question_text()
                +   "\t"
                +   answer_and_containers_it->first;
    }
    //-----------------------------------------------------------------------------------
    virtual
    void    modify_selected_containers_for_answer_num
        (
            T_containers    &   containers,
            T_answer_num        answer_num
        )                                                                           const
    {
        auto    answer_and_containers_it    =   containers_of_answer_.begin();
 
        std::advance
            (
                answer_and_containers_it,
                answer_num - 1
            );
 
        auto    answer_containers   =   answer_and_containers_it->second;
        containers  *=  answer_containers;
    }
    //-----------------------------------------------------------------------------------
    bool    is_not_subset_of_containers_of_any_answer
        ( T_containers   const   &   containers )                                   const
    {
        return      std::find_if
                        (
                            containers_of_answer_.begin     (),
                            containers_of_answer_.end       (),
 
                            [&]     (
                                        T_containers_of_answer::value_type  const   &   answer_and_containers
                                    )
                                    ->  bool
                            {
                                return  is_subset_of
                                            (
                                                containers,
                                                answer_and_containers.second
                                            );
                            }
                        )
 
                ==  containers_of_answer_.end();
    }
    //-----------------------------------------------------------------------------------
    virtual
    void    for_containers_set_numbers_and_texts_of_not_empty_answers
        (
            T_containers    const   &   containers,
            T_numbers               &   numbers,
            T_str                   &   answers_texts
        )                                                                           const
 
    {
        int     answer_num  =   0;
 
        std::for_each
            (
                containers_of_answer_.begin     (),
                containers_of_answer_.end       (),
 
                [&] ( T_containers_of_answer::value_type    const   &   answer_and_containers )
                {
                    ++answer_num;
 
                    if  (
                            !   (
                                        answer_and_containers.second
                                    *   containers
                                )
                                .empty()
                        )
                    {
                        numbers.insert( answer_num );
 
                        answers_texts.append
                            (

                                "\t"    +   answer_and_containers.first     +   "\n"
                            );
                    }//if
                }//lambda
            );
    }
    //-----------------------------------------------------------------------------------
};
/////////////////////////////////////////////////////////////////////////////////////////
class   T_containers_selector
{
    //-----------------------------------------------------------------------------------
    T_containers_data   containers_data_;
    T_containers        selected_containers_;
    T_str               value_type_name_;
    T_question_ptrs     question_ptrs_;
    T_str               answers_history_;
    //-----------------------------------------------------------------------------------
public:
    //-----------------------------------------------------------------------------------
    T_containers_selector()
        :
        selected_containers_( containers_data_.all_containers_ )
    {
        check_value_type();
        //===============================================================================
        //1
        question_ptrs_.insert
            (
                new     T_yes_or_not_question   (
                                                    "Нужен стек, или очередь, или очередь с приоритетами?",
                                                    containers_data_.all_containers_,
                                                    containers_data_.adapters_,
                                                    T_yes_question::ADAPTERS_QUESTION_WEIGHT
                                                )
            );
        //===============================================================================
        //2
        question_ptrs_.insert
            (
                new     T_yes_or_not_relevant_question  (
                                                            "Порядок последним пришел - первым ушел?",
                                                            containers_data_.all_containers_,
                                                                T_containers()
                                                            +   STACK
                                                        )
            );
        //===============================================================================
        //3
        question_ptrs_.insert
            (
                new     T_yes_or_not_relevant_question  (
                                                            "Порядок первым пришел - первым ушел?",
                                                            containers_data_.all_containers_,
                                                                T_containers()
                                                            +   QUEUE
                                                        )
            );
        //===============================================================================
        //4
        question_ptrs_.insert
            (
                new     T_yes_or_not_relevant_question  (
                                                            "Максимальный (минимальный) элемент уходит первым?",
                                                            containers_data_.all_containers_,
                                                                T_containers()
                                                            +   PRIORITY_QUEUE
                                                        )
            );
        //===============================================================================
        //5
        question_ptrs_.insert
            (
                new     T_yes_or_not_relevant_question  (
                                                            "Надо искать элементы по ключу?",
                                                            containers_data_.all_containers_,
                                                            containers_data_.key_containers_
                                                        )
            );
        //===============================================================================
        //6
        question_ptrs_.insert
            (
                new     T_yes_or_not_relevant_question  (
                                                            "Элементы отсортированы по ключу?",
                                                            containers_data_.all_containers_,
                                                            containers_data_.tree_containers_
                                                        )
            );
        //===============================================================================
        //7
        question_ptrs_.insert
            (
                new     T_yes_or_not_relevant_question  (
                                                            "Частые вставки или удаления в середине?",
                                                            containers_data_.all_containers_,
                                                            containers_data_.lists_containers_
                                                        )
            );
        //===============================================================================
        //8
        question_ptrs_.insert
            (
                new     T_yes_or_not_relevant_question  (
                                                            "Нужно производить упорядоченные выборки?",
                                                            containers_data_.all_containers_,
                                                            containers_data_.tree_containers_
                                                        )
            );
        //===============================================================================
        //9
        question_ptrs_.insert
            (
                new     T_yes_or_not_relevant_question  (
                                                            "Частые вставки или удаления в начале?",
                                                            containers_data_.all_containers_,
                                                            containers_data_.lists_and_deque_containers_
                                                        )
            );
        //===============================================================================
        //10
        question_ptrs_.insert
            (
                new     T_yes_or_not_relevant_question  (
                                                            "Надо быстро получить N-й элемент?",
                                                            containers_data_.all_containers_,
                                                            containers_data_.arrays_containers_
                                                        )
            );
        //===============================================================================
        //11
        question_ptrs_.insert
            (
                new     T_yes_or_not_relevant_question  (
                                                            "Дубликаты недопустимы?",
                                                            containers_data_.key_containers_,
                                                            containers_data_.not_multi_key_containers_
                                                        )
            );
        //===============================================================================
        //12
        question_ptrs_.insert
            (
                new     T_yes_or_not_relevant_question  (
                                                            "Нужно часто объединять большие контейнеры?",
                                                            containers_data_.all_containers_,
                                                            containers_data_.lists_containers_
                                                        )
            );
        //===============================================================================
        //13
        question_ptrs_.insert
            (
                new     T_yes_or_not_relevant_question  (
                                                            "Размер будет сильно меняться?",
                                                            containers_data_.all_containers_,
                                                                T_containers()
                                                            +   DEQUE
                                                        )
            );
        //===============================================================================
        //14
        question_ptrs_.insert
            (
                new     T_yes_or_not_question   (
                                                    "Хранить вместе ключ и значение?",
                                                    containers_data_.key_containers_,
                                                    containers_data_.sets_containers_
                                                )
            );
        //===============================================================================
        //15
        question_ptrs_.insert
            (
                new     T_yes_or_not_relevant_question  (
                                                            "Не нужно итерировать из конца в начало?",
                                                            containers_data_.lists_containers_,
                                                                T_containers()
                                                            +   FORWARD_LIST
                                                        )
            );
        //===============================================================================
        //16
        question_ptrs_.insert
            (
                new     T_yes_or_not_relevant_question  (
                                                            "Размер контейнера константный?",
                                                            containers_data_.all_containers_,
                                                                T_containers()
                                                            +   ARRAY
                                                        )
            );
        //===============================================================================
        //17
        question_ptrs_.insert
            (
                new     T_yes_or_not_relevant_question
                            (
                                "Нужна валидность всех итераторов после удаления элемента?",
                                containers_data_.all_containers_,
                                containers_data_.lists_and_hash_containers_
                            )
            );
        //===============================================================================
        //18
        question_ptrs_.insert
            (
                new     T_switch_question
                            (
                                "Временная сложность вставки в начало:",
                                "1) постоянная"        ,    containers_data_.lists_and_deque_and_hash_containers_,
                                "2) log N"             ,    containers_data_.tree_containers_,
                                "3) N"                 ,    containers_data_.vector_and_string_containers_,
                                "4) вообще невозможно" ,    containers_data_.array_containers_
                            )
            );
        //===============================================================================
        //19
        question_ptrs_.insert
            (
                new     T_switch_question
                            (
                                "Временная сложность вставки в середину:",
                                "1) постоянная"        ,    containers_data_.lists_and_hash_containers_,
                                "2) log N"             ,    containers_data_.tree_containers_,
                                "3) N"                 ,    containers_data_.vector_deque_string_containers_,
                                "4) вообще невозможно" ,    containers_data_.array_containers_
                            )
            );
        //===============================================================================
        //20
        question_ptrs_.insert
            (
                new     T_switch_question   (
                                                "Временная сложность поиска по значению:",
                                                "1) постоянная"     ,   containers_data_.hash_containers_,
                                                "2) log N"          ,   containers_data_.tree_containers_,
                                                "3) N"              ,   containers_data_.not_key_containers_
                                            )
            );
        //===============================================================================
        //21

        question_ptrs_.insert
            (
                new     T_switch_question   (
                                                "Временная сложность поиска N-го элемента:",
                                                "1) постоянная",    containers_data_.arrays_containers_,
                                                "2) N"         ,    containers_data_.lists_and_key_containers_
                                            )
            );
        //===============================================================================
        //22
        question_ptrs_.insert
            (
                new     T_switch_question
                            (
                                "Число указателей на один элемент контейнера:",
                                "1) 0",     containers_data_.array_and_vector_and_string_containers_,
                                "2) 1",     containers_data_.forward_list_and_deque_and_hash_containers_,
                                "3) 2",     containers_data_.not_forward_list_containers_,
                                "4) 3",     containers_data_.tree_containers_
                            )
            );
        //===============================================================================
        //23
        question_ptrs_.insert
            (
                new     T_yes_or_not_relevant_question
                            (
                                "Необходимо вставлять элементы в произвольное место контейнера?",
                                containers_data_.all_containers_,
                                    containers_data_.not_key_containers_
                                -   ARRAY
                            )
            );
        //===============================================================================
        //24
        question_ptrs_.insert
            (
                new     T_yes_or_not_relevant_question
                            (
                                "Надо искать элементы по ключу, не имея для него критерия сортировки?",
                                containers_data_.all_containers_,
                                containers_data_.hash_containers_
                            )
            );
        //===============================================================================
        //25
        question_ptrs_.insert
            (
                new     T_yes_or_not_relevant_question
                            (
                                "Нужен быстрый бинарный поиск в большом контейнере, не перемежающийся\n"
                                "вставкой и удалением элементов?",
                                containers_data_.all_containers_,
                                    T_containers()
                                +   VECTOR,
                                T_yes_question::QUICK_BINARY_SEARCH_QUESTION_WEIGHT
                            )
            );
        //===============================================================================
        //26
        question_ptrs_.insert
            (
                new     T_yes_or_not_relevant_question
                            (
                                "Элементы контейнера имеют высокую стоимость копирования/присваивания?",
                                containers_data_.all_containers_,
                                containers_data_.not_arrays_containers_
                            )
            );
        //===============================================================================
        //27
        question_ptrs_.insert
            (
                new     T_yes_or_not_relevant_question  (
                                                            "Нужен быстрый линейный поиск в большом контейнере?",
                                                            containers_data_.all_containers_,
                                                            containers_data_.arrays_containers_
                                                        )
            );
        //===============================================================================
        //28
        question_ptrs_.insert
            (
                new     T_switch_question
                            (
                                "Нужны быстрые случайные вставки/удаления:",
                                "1) маленьких элементов"    ,   containers_data_.vector_and_string_containers_,
                                "2) больших элементов"      ,   containers_data_.lists_containers_
                            )
            );
        //===============================================================================
    }
    //-----------------------------------------------------------------------------------
    void    select_container()
    {
        do
        {
            for (
                    size_t
                    i   =   0;
                    i   <   question_ptrs_.size();
                )
            {
                auto    question_ptr_it     =   question_ptrs_.begin();
 
                std::advance
                    (
                        question_ptr_it,
                        i
                    );
 
                if  (
                        ( *question_ptr_it )->there_are_superfluous_containers_in( selected_containers_ )
                    )
                {
                    ++i;
                    continue;
                }
 
                auto    question_is_relevant
                    =   ( *question_ptr_it )->there_are_suitable_containers_to_choose_from_in( selected_containers_ );
 
                if  (
                            !question_is_relevant
                        ||  ( *question_ptr_it )
                                ->successfully_ask_question_and_set_selected_containers_and_write_to_answers_history
                                (
                                    selected_containers_,
                                    answers_history_
                                )
                    )
                {
                    question_ptrs_.erase( question_ptr_it );
                }
                else
                {
                    ++i;
                }
 
                if( question_is_relevant )
                {
                    print_containers();
                }
 
                if  (
                        selected_containers_.size()  <=  1
                    )
                {
                    break;
                }
            }//for
        }
        while   (
                        question_ptrs_.size         ()  >   0
                    &&  selected_containers_.size   ()  >   1
                    &&  reply_to_question_is_yes    ( "Продолжить выбор контейнера?" )
                );
 
        std::cout   <<  "Выбор контейнера окончен."
                    <<  std::endl
 
                    <<  (
                            answers_history_.empty()
                                ?   "Контейнер не выбран."
                                :       "Контейнер выбран по следующим критериям:\n"
                                    +   answers_history_
                                    +   "."
                        )
 
                    <<  std::endl;
    }
    //-----------------------------------------------------------------------------------
private:
    //-----------------------------------------------------------------------------------
    void    check_value_type()
    {
        value_type_name_     =   reply_to_question_is_yes( "Тип элементов встроенный?" )
                                    ?   reply_to_question_is_yes( "Тип элементов char?" )
                                            ?   TYPE_NAME_CHAR
                                            :   reply_to_question_is_yes( "Тип элементов bool?" )
                                                    ?   TYPE_NAME_BOOL
                                                    :   TYPE_NAME_BUILT_IN
                                    :   USER_DEFINED_TYPE;
 
        if  (
                    value_type_name_
                !=  TYPE_NAME_CHAR
            )
        {
            selected_containers_.erase( STRING );
        }
    }
    //-----------------------------------------------------------------------------------
    static
    bool    reply_to_question_is_yes( T_str     const   &   question_text )
    {
        std::cout   <<  question_text
                    <<  " (y/n): ";
 
        T_str   s;
        std::cin    >>  s;
 
        return      std::tolower    (
                                        s.front()
                                    )
 
                ==  'y';
    }
    //-----------------------------------------------------------------------------------
    void    print_containers()                                                      const
    {
        std::cout   <<  "Тип элемента "
                    <<  value_type_name_
                    <<  "."
                    <<  std::endl;
 
        if  (
                selected_containers_.empty()
            )
        {
            std::cout   <<  "Таких контейнеров нет."
                        <<  std::endl;
        }
 
        std::for_each
            (
                selected_containers_.begin  (),
                selected_containers_.end    (),
 
                [&]                     ( T_container   container )
                {
                    std::cout   <<  get_container_name( container )
                                <<  std::endl;
                }
            );
 
        std::cout   <<  std::endl;
    }
    //-----------------------------------------------------------------------------------
    T_str   get_container_name( T_container   container )                           const
    {
        switch( container )
        {
        case    FORWARD_LIST        :   return  "forward_list";
        case    LIST                :   return  "list";
        case    ARRAY               :   return  "array";
 
        case    VECTOR              :   return  value_type_name_     ==  TYPE_NAME_BOOL
                                                    ?   "вместо vector<bool> рекомендуется использовать bitset или deque<bool>."
                                                    :   "vector";
 
        case    DEQUE               :   return  "deque";
        case    UNORDERED_MAP       :   return  "unordered_map";
 
        case    UNORDERED_SET       :   return  "unordered_set";
        case    UNORDERED_MULTIMAP  :   return  "unordered_multimap";
        case    UNORDERED_MULTISET  :   return  "unordered_multiset";
 
        case    SET                 :   return  "set";
        case    MAP                 :   return  "map";
        case    MULTISET            :   return  "multiset";
 
        case    MULTIMAP            :   return  "multimap";
        case    STACK               :   return  "stack";
        case    QUEUE               :   return  "queue";
 
        case    PRIORITY_QUEUE      :   return  "priority_queue";
        case    STRING              :   return  "string";
        default                     :   return  "";
        }//switch
    }
    //-----------------------------------------------------------------------------------
};
/////////////////////////////////////////////////////////////////////////////////////////
int     main()
{
    std::locale::global(std::locale(""));
    T_containers_selector  containers_selector;
    containers_selector.select_container();
    system("pause");
}