Проблема с typedef.... не виден новый тип данных!

switch (MenuType()) 
        {
            case 1: typedef string Type; break;
            case 2: typedef char Type;break;
            case 3: typedef int Type;break;
            case 4: typedef double Type;break;
            case 5: don=true;
        }
        
        //здесь Type уже не виден!
        Set_list<Type> A("SetA"),B("SetB"),C("SetC"),D("SetD");
        Set_list<Type>* pSet[] = { &A, &B, &C, &D };

#include  <iostream>
 
template <typename T>
void type()
{
    std::cout << typeid( T ).name() << std::endl;
}
 
int main()
{
 
    int i = 1;
 
    if ( i == 0 ) typedef int T;
    if ( i == 1 ) typedef char T;
 
    type<T>();
}

template <typename T>
void type()
{
        std::cout << typeid( T ).name() << std::endl;
}

template <typename T>
void type()
{
    std::cout << typeid( T ).name() << std::endl;
}
 
 
int main()
{
    STD;
 
    CKDice md;
    int i = md.GetRandom(0,1);
    cout<<"i="<<i<<endl;
 
    if ( i == 0 ) typedef int T;
    if ( i == 1 ) typedef char T;
 
    type<T>(); //вывод: char независимо от того, чему равно i
     
    EndProgramm();
}

template <typename T>
void type()
{
    std::cout << typeid( T ).name() << std::endl;
}
 
 
int main()
{
    STD;
 
    int i=0;
 
    if ( i == 0 ) typedef int T;
    if ( i == 1 ) typedef char T;
 
    type<T>(); //вывод: char
     
    EndProgramm();
}

switch (MenuType()) 
{
   case 1:
   { 
      Set_list<Type> A("SetA"),B("SetB"),C("SetC"),D("SetD");
      /* В этом блоке делаете все, что вам нужно сделать с этим объектом */
      break;
   }
   case 2:
   {
      Set_list<Type>* pSet[] = { &A, &B, &C, &D };
      /* В этом блоке делаете все, что вам нужно сделать с этим объектом */
      break;
   }
   ...
   ...
}

// Set.cpp: определяет точку входа для консольного приложения.
//реализация класса множество через двусвязный список
/*Описать класс «множество», позволяющий выполнять основные операции — добавление
и удаление элемента, пересечение, объединение и разность множеств.
Написать программу, демонстрирующую работу с этим классом. Программа
должна содержать меню, позволяющее осуществить проверку всех методов класса.*/
#include "stdafx.h"
#include "Set_list.h"
#include <iostream>
#include <clocale>
#include "MyStdSpezif.h"
#include <cstring>
 
template <typename T>
void type()
{
    std::cout << typeid( T ).name() << std::endl;
}
typedef double Type;
using namespace std;
 
int Menu();
int MenuType();
void ExitBack();
void Create(Set_list<Type> * p_Set[],int n);        //заполнить множество элементами
void Show_All(Set_list<Type> * p_Set[],int n);      //вывести все множества
void Show(Set_list<Type> * p_Set[],int n);          //вывести одно из множеств
void AddItem(Set_list<Type> * p_Set[],int n);       //добавить элемент
void DeleteItem(Set_list<Type> * p_Set[],int n);    //удалить элемент из множества
void DeleteAll(Set_list<Type> * p_Set[],int n); //Очистить все  множеств
void A_and_B(Set_list<Type> * p_Set[],int n);       //пересечение
void A_or_B(Set_list<Type> * p_Set[],int n);        //объединение
void A_minus_B(Set_list<Type> * p_Set[],int n); //разность
 
 
int _tmain(int argc, _TCHAR* argv[])
{
    ShowSpezif();
    bool don = false;
    
        /*int type =MenuType();
        if (type==1) typedef string Type; 
        if (type==1) typedef char Type;
        if (type==1) typedef int Type;
        if (type==1) typedef double Type;*/
        
        Set_list<Type> A("SetA"),B("SetB"),C("SetC"),D("SetD");
        Set_list<Type>* pSet[] = { &A, &B, &C, &D };
        int n = 4,k=0;
        //sizeof (pSet) / sizeof (pSet[0]);
        setlocale(LC_ALL,"rus");
        // Главный цикл
        bool done = false;
        while (!done) 
        {
            switch (Menu()) {
                case 1:     Create<Type>(pSet,n);       break;
                case 2:     Show(pSet,n);       break;
                case 3:     Show_All(pSet,n);   break;
                case 4:     AddItem(pSet,n);    break;
                case 5:     DeleteItem(pSet,n); break;
                case 6:     DeleteAll(pSet,n);  break;
                case 7:     A_minus_B(pSet,n);  break;
                case 8:     A_and_B(pSet,n);    break;
                case 9:     A_or_B(pSet,n); break;
                case 0: cout << "Конец работы." << endl;
                    done = true;    break;
                    }
        }
    
    ExitBack();
    return 0;
}
 
int MenuType()
{
    cout<<"Выберите тип элементов множества"<<endl;
    cout<<"1 - Строка \n2 - Символ \n3 - Целое число \n4 - Вещественное число"<<endl;
    return GetNumber(1,4);
 
}
 
// ------------------------------------------ вывод меню
int Menu() {
    system("cls");
    cout << "\n=============== Г л а в н о е   м е н ю ===================" << endl;
    cout << "1 - создать множество \t\t 2 - вывести одно множество " << endl;
    cout << "3 - Вывести все множества\t 4 - добавить элемент в множество" << endl;
    cout << "5 - удалить элемент из множества 6 - очистить множество" <<endl;
    cout << "7 - разность двух множеств\t 8 - пересечение двух множеств" << endl;
    cout << "9 - объединение двух множеств"<<endl;
    cout << "0 - \t\t\t Выход"<<endl;
    cout<<endl<<" \nВыш выбор: ";
    return GetNumber(0, 9);
}
 
// ------------------- возврат в функцию с основным меню
void ExitBack() {
    cout << "Нажмите Enter." << endl;
    cin.get();  cin.get();
}
//создать множество цифра 1
template <class T> void Create(Set_list * p_Set[],int n)
{
    int mn;
    cout<<"Выберите множество для записи"<<endl;
            for (int i=0; i<n; i++)
            {
                cout<<i+1<<": \t"<<p_Set[i]->GetName()<<endl;
            }
    cout<<" Ваш выбор : "; mn=GetNumber(1,4);
    mn--;
    int k;
    cout<<"\n\nВведите размерность множества "<<p_Set[mn]->GetName()<<": "; 
    k=GetNumber(1,15);
    cout<<endl;
    int tmp;
        cout<<"Введите "<<k<<" элементов множества через пробел   =   ";
    for (int i=1; i<=k; i++)
    {
        cin>>tmp;
        p_Set[mn]->push(tmp);
    }
    ExitBack();
}
//вывести одно из множеств цифра 2
template <class T> void Show(Set_list * p_Set[],int n)
{
    int mn;
    cout<<"Выберите множество для вывода на экран его элементов"<<endl;
            for (int i=0; i<n; i++)
            {
                cout<<i+1<<": \t"<<p_Set[i]->GetName()<<endl;
            }
    cout<<" Ваш выбор : "; mn=GetNumber(1,4);
    mn--;
    cout<<"Множество "<<p_Set[mn]->GetName()<<endl;
    p_Set[mn]->print_all();
    ExitBack();
}
//вывести все множества цифра 3
template <class T> void Show_All(Set_list * p_Set[],int n)
{
    cout<<"Вывод всех элементов\n"<<endl;
            for (int i=0; i<n; i++)
            {
                cout<<"Множество "<<p_Set[i]->GetName()<<endl;
                p_Set[i]->print_all();
            }
    ExitBack();
}
 
//добавить элемент цифра 4
template<class T> void AddItem(Set_list * p_Set[],int n)
{
    int mn;
    cout<<"Выберите множество для добавления в него элемента"<<endl;
            for (int i=0; i<n; i++)
            {
                cout<<i+1<<": \t"<<p_Set[i]->GetName()<<endl;
            }
    cout<<" Ваш выбор : "; mn=GetNumber(1,4);
    mn--;
    cout<<"Введите значение нового элемента"<<endl;
    int tmp;
    cin>>tmp;
    p_Set[mn]->push(tmp);
    ExitBack();
}
 
//удалить элемент из множества цифра 5
template <class T> void DeleteItem(Set_list * p_Set[],int n)
{
    int mn,i;
    cout<<"Выберите множество для удаления из него элемента"<<endl;
            for ( i=0; i<n; i++)
            {
                cout<<i+1<<": \t"<<p_Set[i]->GetName()<<endl;
            }
    cout<<" Ваш выбор : "; mn=GetNumber(1,4);
    mn--;
    int item;
    cout<<"Введите значение элемента, который выхотите удалить = "; cin>>item;
    if ((i=p_Set[mn]->Find(item))==-1)
        cout<<"такого элемента в множестве нет!!!"<<endl;
    else
        p_Set[mn]->clear(i);
    ExitBack();
}
//Очистить все  множеств цифра 6
template <class T> void DeleteAll(Set_list * p_Set[],int n)
{
    int mn;
    cout<<"Выберите множество для удаления всех его элементов"<<endl;
            for (int i=0; i<n; i++)
            {
                cout<<i+1<<": \t"<<p_Set[i]->GetName()<<endl;
            }
    cout<<" Ваш выбор : "; mn=GetNumber(1,4);
    mn--;
    p_Set[mn]->clear();
    ExitBack();
}
//пересечение цифра 9
template <class T> void A_and_B(Set_list * p_Set[],int n)
{
    int mn1,mn2,mn3;
    Set_list Mn1("Mn1"),Mn2("Mn2"), Mn3("Mn3");
    cout<<"Выберите множества для выполнения операции пересечения множеств Mn3 = Mn1 & Mn2"<<endl;
            for (int i=0; i<n; i++)
            {
                cout<<i+1<<": \t"<<p_Set[i]->GetName()<<endl;
            }
    cout<<" Ваш выбор 1: "; mn1=GetNumber(1,4);
    cout<<" Ваш выбор 2: "; mn2=GetNumber(1,4);
    cout<<" Ваш выбор 3: "; mn3=GetNumber(1,4);
    mn1--; mn2--; mn3--;
    Mn1=*p_Set[mn1];
    Mn2=*p_Set[mn2];
    Mn3=Mn1&Mn2;
    *p_Set[mn3]=Mn3;
    ExitBack();
}
//объединение цифра 8
template <class T> void A_or_B(Set_list * p_Set[],int n)
{
    int mn1,mn2,mn3;
    Set_list Mn1("Mn1"),Mn2("Mn2"), Mn3("Mn3");
    cout<<"Выберите множества для выполнения операции пересечения множеств Mn3 = Mn1 | Mn2"<<endl;
            for (int i=0; i<n; i++)
            {
                cout<<i+1<<": \t"<<p_Set[i]->GetName()<<endl;
            }
    cout<<" Ваш выбор 1: "; mn1=GetNumber(1,4);
    cout<<" Ваш выбор 2: "; mn2=GetNumber(1,4);
    cout<<" Ваш выбор 3: "; mn3=GetNumber(1,4);
    mn1--; mn2--; mn3--;
    Mn1=*p_Set[mn1];
    Mn2=*p_Set[mn2];
    Mn3=Mn1|Mn2;
    *p_Set[mn3]=Mn3;
    ExitBack();
}
//разность цифра 7
template <class T> void A_minus_B(Set_list * p_Set[],int n)
{
    int mn1,mn2,mn3;
    Set_list Mn1("Mn1"),Mn2("Mn2"), Mn3("Mn3");
    cout<<"Выберите множества для выполнения операции пересечения множеств Mn3 = Mn1 - Mn2"<<endl;
            for (int i=0; i<n; i++)
            {
                cout<<i+1<<": \t"<<p_Set[i]->GetName()<<endl;
            }
    cout<<" Ваш выбор 1: "; mn1=GetNumber(1,4);
    cout<<" Ваш выбор 2: "; mn2=GetNumber(1,4);
    cout<<" Ваш выбор 3: "; mn3=GetNumber(1,4);
    mn1--; mn2--; mn3--;
    Mn1=*p_Set[mn1];
    Mn2=*p_Set[mn2];
    Mn3=Mn1-Mn2;
    *p_Set[mn3]=Mn3;
    ExitBack();
}

#include <boost/variant.hpp>
#include <iostream>
#include <set>
 
int main()
{
   std::set<boost::variant<int, double, std::string> > s;
   
   s.insert("hello, world");
   s.insert(12.3);
   s.insert(1);
   
   for (auto &i : s) {
      std::cout << i << std::endl;
   }
   
   return 0;
}

//данная страктура умеет хранить имя типа данных
struct Data
{
    template<typename T>  void setType() {    mTypeName= typeid( T ).name();     }
    void ViewType() { std::cout<< "Мой тип: "<<mTypeName.c_str()<<std::endl; }
    
    std::string mTypeName;
};
 
int MenuType()
{
    STD;
 
    cout << "Введите тип данных, с которыми вы хотите работать:\n";
    
    cout << "1 -  string\n";
    cout << "2 -  char\n";
    cout << "3 -  int\n";
    cout << "4 -  double\n";
 
    int select;   cin >> select;
    return select;
}
 
 
int main()
{
    STD;
 
    list<Data> myList; //создали контейнер
 
    Data mData;  //создали структуру, 
                 //которая будит хранить знание о типе,
                 //с которым хочет работать пользователь
    
    switch ( MenuType()  )  //запросили у пользователя 
                            //с каким типом данных он хочет работать
    {
        case 1: mData.setType<std::string>(); break;
        case 2: mData.setType<char>(); break;
        case 3: mData.setType<int>(); break;
        case 4: mData.setType<double>(); break;
    }
    
    mData.ViewType(); //покажем, какой тип хранит данная структура
    myList.push_back(mData); //погрузили данные в контейнер
     
    EndProgramm();
}

//Set_list.h
 
#pragma once
#ifndef Set_list_h
#define Set_list_h
template <class T> class Set_list           //шаблон класса 
{
public:
    Set_list(char*);
    ~Set_list(void);
    bool IsEmpty(){return first==NULL;}             //если указатель на начало = NULL, то список пуст
    
    void push(const T value);
    char* GetName() {return name_set;};
    void print_all();                               //печать списка
    void print_all_rev();                           //печать списка в обратном порядке
    
    int print_count();                              //размерность множества
 
    void clear();                                   //очистить список
    bool clear(int num);                            //удалить элемент
    
    int Find(const T value);                        //поиск элемента
    int select(int num);                            //вывести элемент
 
    Set_list(const Set_list & rhs);                 //конструктор копирования
    Set_list& operator=(const Set_list & rhs);      //конструктор присваивания
    
    //операции множества
    Set_list operator-( Set_list & rhs);            //разность  
    Set_list operator&( Set_list & rhs);            //пересечение
    Set_list operator|( Set_list & rhs);            //объединение
 
    //функция, получающая число из заданного диапазона
    friend int GetNumber(int, int);
protected:
    struct node
    {
        T data;     //data имеет тип T
 
        node *next;
        node *prev;
 
        node(T value, node *n, node *p): 
                    data(value), next(n), prev(p) {}
    };
    char * name_set;
    node *end;          //хвост
    node *first;        //голова
    int count;          //количество элементов
 
private:
    void push_begin(const T value);                 //добавление в начало списка
    void push_end(const T value);                       //добавление в конец списка
};
 
#endif

//Set_list.cpp
 
#include "StdAfx.h"
#include "Set_list.h"
#include <iostream>
using namespace std;
 
//конструктор
template <class T> Set_list<T>::Set_list(char *s) : count(0), first(NULL), end(NULL)
{
    name_set= new char[strlen(s)+1];
    strcpy(name_set,s);
}
//конструктор копирования
template <class T> Set_list<T>::Set_list(const Set_list & rhs)              
{
   first = end = NULL;
   count=0;
   // Голова списка, из которого копируем
   node * temp = rhs.first;
   // Пока не конец списка
   while(temp != 0)
   {
      // Передираем данные
      push_end(temp->data);
      temp = temp->next;
   }
} // конец конструктора копирования
 
//конструктор присваивания
template <class T> Set_list<T>& Set_list<T>::operator=(const Set_list<T> & rhs)
{
    // Проверка присваивания элемента "самому себе"
    if(this<T> == &rhs)
       return *this;
 
   // удаление старого списка
   this->~Set_list(); // DelAll();
 
   node * temp = rhs.first;
 
   // Копируем элементы
   while(temp != 0)
   {
       push_end(temp->data);
      temp = temp->next;
   }
    return *this;
}//end конструктор присваивания
 
//деструктор
template <class T>Set_list<T>::~Set_list(void)
{
    clear();
}
 
/* ------- */
/* ФУНКЦИИ */
/* ------- */
/*
 
*/
template <class T>void Set_list<T>::push(const T value)
{
    node *ptr =first;
    while(true)
    {   
        if (ptr==NULL){ push_end(value); break;}
        else if (ptr->data==value) 
            break;
        else if(ptr->data>value)
            {
                node* newnode = new node(value, ptr, ptr->prev);
                node* prev = ptr->prev;
                
                if(prev != NULL)
                    prev->next = newnode;
                else
                    first=newnode;
                ptr->prev = newnode;
                count++;
                break;
            }
        if (ptr->data<value) {ptr=ptr->next; }
    }
}
// добавление записи в начало списка
template <class T> void Set_list<T>::push_begin(const T value)
{
    first = new node(value, first, 0);
    
    if(!count)
         end = first;
    
    node *ptr = first->next;
    if(ptr)
         ptr->prev = first;
 
    count++;
}
 
// добавление записи в конец списка
template <class T> void Set_list<T>::push_end(const T value)
{
    end = new node(value, NULL, end);
    
    if (!count)
       first = end;
    
    node *ptr = end->prev;
    if (ptr)
       ptr->next = end;
 
    count++;
}
 
// печать списка
template <class T> void Set_list<T>::print_all()
{
    if (IsEmpty()) {cout<<"Пустое множество"<<endl; return;}
    node *ptr = first;
    
    cout<<ptr->data;
        ptr = ptr->next;
    while (ptr)
    {
        cout<<", "<<ptr->data;
        ptr = ptr->next;
    }
 
    cout<<"."<<endl;
}
 
// печать списка в обратном порядке
template <class T> void Set_list<T>::print_all_rev()
{
    if (IsEmpty()) {cout<<"Пустое множество"<<endl; return;}
    node *ptr = end;
    
    cout<<ptr->data;
        ptr = ptr->prev;
    while (ptr)
    {
        cout<<", "<<ptr->data;
        ptr = ptr->prev;
    }
    cout<<"."<<endl;
}
 
// кол-во элементов
template <class T> int Set_list<T>::print_count()
{
     return count;
}
 
// выборка элемента по порядковому номеру
template <class T> int Set_list<T>::select(int num)
{
    if(!count || !num || num>count+1)
    { cout<<"Задан неверный аргумен. Введите корректный номер"<<endl;
         num=GetNumber(0,count);
    }
    int cnt=0;
         
    node *ptr = first;
    
    while (ptr)
    {
         cnt++;
         if (num==cnt)
              return ptr->data;
         ptr = ptr->next;
    }
}
 
// удаление произвольного элемента
template <class T> bool Set_list<T>::clear(int num)
{
    if(!count || !num || num>count+1)
         return false;
    
    int cnt=0;
         
    node *ptr = first;
    
    while (ptr)
    {
         cnt++;
         if (num==cnt) {
              node *ptr_prev = ptr->prev;
              node *ptr_next = ptr->next;
              
              if(ptr_prev)
                   ptr_prev->next = ptr_next;
              if(ptr_next)
                   ptr_next->prev = ptr_prev;
              
              delete ptr;
              
              count--;
              return true;
         }
         ptr = ptr->next;
    }
}
 
// удаление всего списка
template <class T> void Set_list<T>::clear()
{
     while (first)
     {
          node *ptr = first;
          first = ptr->next;
          delete ptr;
     }
     end = first;
     
     count = 0;
}
 
//поиск элемента в списке.
template <class T> int Set_list<T>::Find(const T value)
{
    for (int pos=1; pos<=count; pos++)
    {
        if(select(pos)==value) return pos; 
    }
    return -1;
}
 
//--------------- разность двух множеств (работает нормально)
template <class T>Set_list<T> Set_list<T>::operator-( Set_list<T> & rhs)
{
    // Проверка присваивания элемента "самому себе"
    if(this == &rhs)
    {
        this->clear();
       return *this;
    }
    Set_list<T> temp("tmp");
    
    //если в rhs не найден элемент из this, то мы записываем его в temp
        for (int j=1; j<=count; j++)
            if ((rhs.Find(select(j)))==-1)
            {
                temp.push(select(j));
            }
            //возвращаем обновленный список
    return temp;
}
//пересечение двух множеств (работает нормально)
template <class T> Set_list<T> Set_list<T>::operator&( Set_list<T> & rhs)
{
    // Проверка присваивания элемента "самому себе"
    if(this == &rhs)
       return *this;
    int i=0;
    Set_list<T> temp("temp");
    for (int j=1; j<=rhs.count; j++)
        if (Find(rhs.select(j))!=-1)
            {
                temp.push(rhs.select(j));
            }
        return temp;
}
//объединение двух множеств (работает нормально)
template <class T>Set_list<T> Set_list<T>::operator|( Set_list<T> & rhs)
{
    // Проверка присваивания элемента "самому себе"
    if(this == &rhs)
       return *this;
    Set_list<T> temp("temp");
    temp=*this;
    for (int j=1; j<=rhs.count; j++)
    {
        temp.push(rhs.select(j));
    }
    return temp;
}
 
// -------------- ввод целого числа в заданном диапазоне
int GetNumber(int min, int max) {
    int number = min - 1;
    bool success = false;
    while (!success) {
        cin >> number;
        if ((number >= min) && (number <= max) && (cin.peek() == '\n'))
            break;
        else {
            cout << "Повторите ввод (ожидается число от " << min 
                    << " до " << max << "):" << endl;
            cin.clear();
            while (cin.get() != '\n') {};
        }
    }
    return number;
}

// Set.cpp: определяет точку входа для консольного приложения.
//реализация класса множество через двусвязный список
/*Описать класс «множество», позволяющий выполнять основные операции — добавление
и удаление элемента, пересечение, объединение и разность множеств.
Написать программу, демонстрирующую работу с этим классом. Программа
должна содержать меню, позволяющее осуществить проверку всех методов класса.*/
#include "stdafx.h"
#include "Set_list.h"
#include <iostream>
#include <clocale>
#include "MyStdSpezif.h"
#include <cstring>
 
 
//данная страктура умеет хранить имя типа данных
struct Data
{
    template<typename T>  void setType() {    mTypeName= typeid( T ).name();     }
    void ViewType() { std::cout<< "Мой тип: "<<mTypeName.c_str()<<std::endl; }
    
    std::string mTypeName;
};
using namespace std;
//
//int Menu();
int MenuType();
//void ExitBack();
//void Create(Set_list<Data> * p_Set[],int n);      //заполнить множество элементами
//void Show_All(Set_list<Data> * p_Set[],int n);        //вывести все множества
//void Show(Set_list<Data> * p_Set[],int n);            //вывести одно из множеств
//void AddItem(Set_list<Data> * p_Set[],int n);     //добавить элемент
//void DeleteItem(Set_list<Data> * p_Set[],int n);  //удалить элемент из множества
//void DeleteAll(Set_list<Data> * p_Set[],int n);   //Очистить все  множеств
//void A_and_B(Set_list<Data> * p_Set[],int n);     //пересечение
//void A_or_B(Set_list<Data> * p_Set[],int n);      //объединение
//void A_minus_B(Set_list<Data> * p_Set[],int n);   //разность
//
 
int _tmain(int argc, _TCHAR* argv[])
{
    /*ShowSpezif();
    bool don = false;*/
    
        Set_list<Data> myList("My"); //создали контейнер
 
    Data mData;  //создали структуру, 
                 //которая будит хранить знание о типе,
                 //с которым хочет работать пользователь
    
    switch ( MenuType()  )  //запросили у пользователя 
                            //с каким типом данных он хочет работать
    {
        case 1: mData.setType<std::string>(); break;
        case 2: mData.setType<char>(); break;
        case 3: mData.setType<int>(); break;
        case 4: mData.setType<double>(); break;
    }
    
    mData.ViewType(); //покажем, какой тип хранит данная структура
    myList.push(mData);} //погрузили данные в контейнер}
//      Set_list<Data> A("SetA"),B("SetB"),C("SetC"),D("SetD");
//      Set_list<Data>* pSet[] = { &A, &B, &C, &D };
//      int n = 4,k=0;
//      //sizeof (pSet) / sizeof (pSet[0]);
//      setlocale(LC_ALL,"rus");
//      // Главный цикл
//      bool done = false;
//      while (!done) 
//      {
//          switch (Menu()) {
//              case 1:     Create(pSet,n);     break;
//              case 2:     Show(pSet,n);       break;
//              case 3:     Show_All(pSet,n);   break;
//              case 4:     AddItem(pSet,n);    break;
//              case 5:     DeleteItem(pSet,n); break;
//              case 6:     DeleteAll(pSet,n);  break;
//              case 7:     A_minus_B(pSet,n);  break;
//              case 8:     A_and_B(pSet,n);    break;
//              case 9:     A_or_B(pSet,n); break;
//              case 0: cout << "Конец работы." << endl;
//                  done = true;    break;
//                  }
//      }
//  
//  ExitBack();
//  return 0;
//}
//
int MenuType()
{
    cout<<"Выберите тип элементов множества"<<endl;
    cout<<"1 - Строка \n2 - Символ \n3 - Целое число \n4 - Вещественное число"<<endl;
    return GetNumber(1,4);
 
}
//
//// ------------------------------------------ вывод меню
//int Menu() {
//  system("cls");
//    cout << "\n=============== Г л а в н о е   м е н ю ===================" << endl;
//    cout << "1 - создать множество \t\t 2 - вывести одно множество " << endl;
//    cout << "3 - Вывести все множества\t 4 - добавить элемент в множество" << endl;
//  cout << "5 - удалить элемент из множества 6 - очистить множество" <<endl;
//  cout << "7 - разность двух множеств\t 8 - пересечение двух множеств" << endl;
//  cout << "9 - объединение двух множеств"<<endl;
//  cout << "0 - \t\t\t Выход"<<endl;
//  cout<<endl<<" \nВыш выбор: ";
//    return GetNumber(0, 9);
//}
//
//// ------------------- возврат в функцию с основным меню
//void ExitBack() {
//    cout << "Нажмите Enter." << endl;
//    cin.get();  cin.get();
//}
////создать множество цифра 1
//void Create(Set_list<Data> * p_Set[],int n)
//{
//  int mn;
//  cout<<"Выберите множество для записи"<<endl;
//          for (int i=0; i<n; i++)
//          {
//              cout<<i+1<<": \t"<<p_Set[i]->GetName()<<endl;
//          }
//  cout<<" Ваш выбор : "; mn=GetNumber(1,4);
//  mn--;
//  int k;
//  cout<<"\n\nВведите размерность множества "<<p_Set[mn]->GetName()<<": "; 
//  k=GetNumber(1,15);
//  cout<<endl;
//  int tmp;
//      cout<<"Введите "<<k<<" элементов множества через пробел   =   ";
//  for (int i=1; i<=k; i++)
//  {
//      cin>>tmp;
//      p_Set[mn]->push(tmp);
//  }
//  ExitBack();
//}
////вывести одно из множеств цифра 2
//void Show(Set_list<Data> * p_Set[],int n)
//{
//  int mn;
//  cout<<"Выберите множество для вывода на экран его элементов"<<endl;
//          for (int i=0; i<n; i++)
//          {
//              cout<<i+1<<": \t"<<p_Set[i]->GetName()<<endl;
//          }
//  cout<<" Ваш выбор : "; mn=GetNumber(1,4);
//  mn--;
//  cout<<"Множество "<<p_Set[mn]->GetName()<<endl;
//  p_Set[mn]->print_all();
//  ExitBack();
//}
////вывести все множества цифра 3
//void Show_All(Set_list<Data> * p_Set[],int n)
//{
//  cout<<"Вывод всех элементов\n"<<endl;
//          for (int i=0; i<n; i++)
//          {
//              cout<<"Множество "<<p_Set[i]->GetName()<<endl;
//              p_Set[i]->print_all();
//          }
//  ExitBack();
//}
//
////добавить элемент цифра 4
//void AddItem(Set_list<Data> * p_Set[],int n)
//{
//  int mn;
//  cout<<"Выберите множество для добавления в него элемента"<<endl;
//          for (int i=0; i<n; i++)
//          {
//              cout<<i+1<<": \t"<<p_Set[i]->GetName()<<endl;
//          }
//  cout<<" Ваш выбор : "; mn=GetNumber(1,4);
//  mn--;
//  cout<<"Введите значение нового элемента"<<endl;
//  int tmp;
//  cin>>tmp;
//  p_Set[mn]->push(tmp);
//  ExitBack();
//}
//
////удалить элемент из множества цифра 5
//void DeleteItem(Set_list<Data> * p_Set[],int n)
//{
//  int mn,i;
//  cout<<"Выберите множество для удаления из него элемента"<<endl;
//          for ( i=0; i<n; i++)
//          {
//              cout<<i+1<<": \t"<<p_Set[i]->GetName()<<endl;
//          }
//  cout<<" Ваш выбор : "; mn=GetNumber(1,4);
//  mn--;
//  int item;
//  cout<<"Введите значение элемента, который выхотите удалить = "; cin>>item;
//  if ((i=p_Set[mn]->Find(item))==-1)
//      cout<<"такого элемента в множестве нет!!!"<<endl;
//  else
//      p_Set[mn]->clear(i);
//  ExitBack();
//}
////Очистить все  множеств цифра 6
//void DeleteAll(Set_list <Type>* p_Set[],int n)
//{
//  int mn;
//  cout<<"Выберите множество для удаления всех его элементов"<<endl;
//          for (int i=0; i<n; i++)
//          {
//              cout<<i+1<<": \t"<<p_Set[i]->GetName()<<endl;
//          }
//  cout<<" Ваш выбор : "; mn=GetNumber(1,4);
//  mn--;
//  p_Set[mn]->clear();
//  ExitBack();
//}
////пересечение цифра 9
//void A_and_B(Set_list<Type> * p_Set[],int n)
//{
//  int mn1,mn2,mn3;
//  Set_list<Type> Mn1("Mn1"),Mn2("Mn2"), Mn3("Mn3");
//  cout<<"Выберите множества для выполнения операции пересечения множеств Mn3 = Mn1 & Mn2"<<endl;
//          for (int i=0; i<n; i++)
//          {
//              cout<<i+1<<": \t"<<p_Set[i]->GetName()<<endl;
//          }
//  cout<<" Ваш выбор 1: "; mn1=GetNumber(1,4);
//  cout<<" Ваш выбор 2: "; mn2=GetNumber(1,4);
//  cout<<" Ваш выбор 3: "; mn3=GetNumber(1,4);
//  mn1--; mn2--; mn3--;
//  Mn1=*p_Set[mn1];
//  Mn2=*p_Set[mn2];
//  Mn3=Mn1&Mn2;
//  *p_Set[mn3]=Mn3;
//  ExitBack();
//}
////объединение цифра 8
//void A_or_B(Set_list<Type> * p_Set[],int n)
//{
//  int mn1,mn2,mn3;
//  Set_list<Type> Mn1("Mn1"),Mn2("Mn2"), Mn3("Mn3");
//  cout<<"Выберите множества для выполнения операции пересечения множеств Mn3 = Mn1 | Mn2"<<endl;
//          for (int i=0; i<n; i++)
//          {
//              cout<<i+1<<": \t"<<p_Set[i]->GetName()<<endl;
//          }
//  cout<<" Ваш выбор 1: "; mn1=GetNumber(1,4);
//  cout<<" Ваш выбор 2: "; mn2=GetNumber(1,4);
//  cout<<" Ваш выбор 3: "; mn3=GetNumber(1,4);
//  mn1--; mn2--; mn3--;
//  Mn1=*p_Set[mn1];
//  Mn2=*p_Set[mn2];
//  Mn3=Mn1|Mn2;
//  *p_Set[mn3]=Mn3;
//  ExitBack();
//}
////разность цифра 7
//void A_minus_B(Set_list<Type> * p_Set[],int n)
//{
//  int mn1,mn2,mn3;
//  Set_list<Type> Mn1("Mn1"),Mn2("Mn2"), Mn3("Mn3");
//  cout<<"Выберите множества для выполнения операции пересечения множеств Mn3 = Mn1 - Mn2"<<endl;
//          for (int i=0; i<n; i++)
//          {
//              cout<<i+1<<": \t"<<p_Set[i]->GetName()<<endl;
//          }
//  cout<<" Ваш выбор 1: "; mn1=GetNumber(1,4);
//  cout<<" Ваш выбор 2: "; mn2=GetNumber(1,4);
//  cout<<" Ваш выбор 3: "; mn3=GetNumber(1,4);
//  mn1--; mn2--; mn3--;
//  Mn1=*p_Set[mn1];
//  Mn2=*p_Set[mn2];
//  Mn3=Mn1-Mn2;
//  *p_Set[mn3]=Mn3;
//  ExitBack();
//}