Невозможно создать экземпляр абстрактного класса

#include "list.h"
 
void main()
{   list<String> A;
    cout<<"win"<<endl;
    String* a;
    a=new String("qwerty");
    A.add(a);
}

#include <iostream>
#include <time.h>
#include <malloc.h>
#include <windows.h>
#include <stdio.h>
#include <string.h>
#include <conio.h>
#include <dos.h>
#include <fstream>
using namespace std;
const char NONAME[]="NONAME";
const char STRINGNAME[]="String";
const char INTNAME[]="Int";
const char FLOATNAME[]="Float";
 
// Абстрактный класс - родитель классов, которые можно сохранять в коллекции
 
class object
{
public:
    char *className;// имя класса
    int sz2;
    int classUID;// уникальный идентификатор класса
    object(){classUID=0;};
    virtual ~object(){};
    virtual int GetUID() = 0;// получение УИК
    virtual char* GetName() = 0;// получение имени класса
 
    virtual int readbin(ifstream &ff) = 0;// чтение из бинарного файла
    virtual int writebin(ofstream &ff) = 0;// запись в бинарный файл
 
    virtual bool Load(char *buf) = 0;// загрузка из строки
    virtual bool Upload(char *buf) = 0;// выгрузка в строку
 
    virtual int Compar(object *rhs) = 0;// сравнение с другим объектом
 
    virtual void Union(object *rhs) = 0;// объединение с другим объектом
 
    virtual void Show(ostream &os = cout) = 0;// вывод в поток
    object *next,*prev;
};
class String: public object
{
public:
    char *str;  // Массив для хранения строки
    int sz;     // Размерность массива
    String();                                       // Конструктор по умолчанию
    String(char *s);                                // Конструктор с параметрами
    String(const String &rhs);                      // Конструктор копирования
    virtual ~String();              // Деструктор
    void add(const char *ns);                       // Добавление строки
    virtual void change(const char *ns);                    // Изменение строки
    virtual void print();                   // Вывод
    virtual int readbin(ifstream &ifs);                     // Чтение и запиcь в двоичный файл
    virtual int write(ofstream &ofs);
    operator char*();                               // Преобразование в строку
    //friend ostream& operator<< (ostream& os,const String& r); // Потоковый ввод/вывод
    //friend istream& operator>> (istream& is,String& r);
 
};
 
class Int: public object
{
    protected:
    Int *next,*prev;// указатели на следующий и предыдущий элементы списка
public:
    int date;   //поле данных
    
    Int();                                      // Конструктор по умолчанию
    Int(int a);                             // Конструктор с параметрами
    Int(const Int &rhs);                        // Конструктор копирования
    virtual ~Int();             // Деструктор
    virtual void change(int ns);                    // Изменение строки
    virtual void print();                   // Вывод
    virtual int readbin(ifstream &ifs);                     // Чтение и запиcь в двоичный файл
    virtual int write(ofstream &ofs);
    //friend ostream& operator<< (ostream& os,const String& r); // Потоковый ввод/вывод
    //friend istream& operator>> (istream& is,String& r);
 
};

#include "head.h"
 
String::String()
{           // Конструктор по умолчанию
    sz=1;
    str=new char[sz];       // Создать массив
    str[0]='\0';
    next=prev=NULL;
    classUID=1;
    sz2=strlen(STRINGNAME)+1;
    className=new char[sz2];
    strcpy(className,STRINGNAME);
//  cout << endl << "\t\t*** Default constructor-1 parclass" << endl;
    
}
 
 
String::String(char *s){        // Конструктор  с параметрами
    sz=strlen(s)+1; // Вычислить длину масива и создать его
    str=new char[sz];
    strcpy(str,s);              // Скопировать строку
    next=prev=NULL;
    classUID=1;
    sz2=strlen(STRINGNAME)+1;
    className=new char[sz2];
    strcpy(className,STRINGNAME);
//  cout << endl << "\t\t*** Constructor with parameters-1 parclass" << endl;
}
 
 
String::String(const String &rhs){  // Конструктор копирования
    sz=rhs.sz;                      // Создать массив той же размерности, что и у переданного объекта 
    str=new char[sz];               
    strcpy(str,rhs.str);            // Скопировать строку
    next=prev=NULL;
    classUID=1;
    sz2=strlen(STRINGNAME)+1;
    className=new char[sz2];
    strcpy(className,STRINGNAME);
//  cout << endl << "\t\t*** Copy constructor-1 parclass" << endl;
}
 
 
String::~String()
{                   // Деструктор
    delete []str;                   // Удалить его
    delete []className;
//  cout << endl << "\t\t*** Destructor-1 parclass" << endl;
}
 
 
void String::add(const char *ns){       // Добавление строки
    int ss=strlen(ns);
    char *nstr=new char[sz+ss];         // Создать новый массив необходимой длины
    strcpy(nstr,str);                   // Скопировать исходную строку
    strcat(nstr,ns);                    // Дополнить новой строкой
    str=nstr;                           // Запомнить новый массив
    sz+=ss;
}
 
 
void String::change(const char *ns){        // Изменение строки
    int ss=strlen(ns);
    delete []str;               // Удалить старый массив
    str=new char[ss+1];         // Создать новый
    strcpy(str,ns);                         // Скопировать строку
}
 
void String::print()
{           // Вывод 
    cout << str<<endl;                          // Вывести строку
}
 
 
String::operator char*() // преобразование в строку
{
    return strdup(str);
}
 
ostream& operator<< (ostream& os,const String& r) // вывод в поток
 
{
    os << r.str;
    return os;
}
 
 
istream& operator>> (istream& is,String& r){
    char buf[1000];
    is >> buf;                                  // Прочитать строку из потока
 
    int ss=strlen(buf);
    int *n;
 
    delete [](r.str);               
    r.str=new char[ss+1];           
 
    n=(int*)r.str;
 
    strcpy(r.str,buf);                      
    r.sz=ss+1;
 
    return is;
}
 
 
 
int String::readbin(ifstream &ifs){     // Чтение из двоичного файла
    int s;
    ifs.read((char*)&s,sizeof(int));    
    delete []str;               
    str=new char[s+1];              
    ifs.read(str,s*sizeof(char));   
    str[s]='\0';
    sz=s+1;
 
    return 1;
}
 
 
int String::write(ofstream &ofs)
{       // Запись в двоичный файл
    int n=(strlen(str));
    ofs.write((char*)&n,sizeof(int));
    ofs.write((char*)str,n*sizeof(char));
 
    return 1;
}

virtual bool Load(char *buf) = 0;// загрузка из строки
virtual bool Upload(char *buf) = 0;// выгрузка в строку
virtual int Compar(object *rhs) = 0;// сравнение с другим объектом
virtual void Union(object *rhs) = 0;// объединение с другим объектом
virtual void Show(ostream &os = cout) = 0;// вывод в поток

class String: public object
{
public:
    char *str;  // Массив для хранения строки
    int sz;     // Размерность массива
    String();                                       // Конструктор по умолчанию
    String(char *s);                                // Конструктор с параметрами
    String(const String &rhs);                      // Конструктор копирования
    virtual ~String();              // Деструктор
    void add(const char *ns);                       // Добавление строки
    void change(const char *ns);                    // Изменение строки
    void print();                   // Вывод
 
    virtual int GetUID();// получение УИК
    virtual char* GetName();// получение имени класса
 
    virtual int readbin(ifstream &ff);// чтение из бинарного файла
    virtual int writebin(ofstream &ff);// запись в бинарный файл
 
    virtual bool Load(char *buf);// загрузка из строки
    virtual bool Upload(char *buf);// выгрузка в строку
 
    virtual int Compar(String *rhs);// сравнение с другим объектом
 
    virtual void Union(String *rhs);// объединение с другим объектом
 
    virtual void Show(ostream &os = cout);// вывод в поток
    operator char*();                               // Преобразование в строку
    //friend ostream& operator<< (ostream& os,const String& r); // Потоковый ввод/вывод
    //friend istream& operator>> (istream& is,String& r);
 
};

class String: public object
{
public:
        char *str;      // Массив для хранения строки
        int sz;         // Размерность массива
        String();                                                                               // Конструктор по умолчанию
        String(char *s);                                                                // Конструктор с параметрами
        String(const String &rhs);                                              // Конструктор копирования
        virtual ~String();                              // Деструктор
        void add(const char *ns);                                               // Добавление строки
        void change(const char *ns);                                    // Изменение строки
    void print();                                       // Вывод
 
        virtual int GetUID(){};// получение УИК
        virtual char* GetName(){};// получение имени класса
 
        virtual int readbin(ifstream &ff){};// чтение из бинарного файла
        virtual int writebin(ofstream &ff){};// запись в бинарный файл
 
        virtual bool Load(char *buf){};// загрузка из строки
        virtual bool Upload(char *buf){};// выгрузка в строку
 
        virtual int Compar(String *rhs){};// сравнение с другим объектом
 
        virtual void Union(String *rhs){};// объединение с другим объектом
 
        virtual void Show(ostream &os = cout){};// вывод в поток
        operator char*();                                                               // Преобразование в строку
        //friend ostream& operator<< (ostream& os,const String& r);     // Потоковый ввод/вывод
    //friend istream& operator>> (istream& is,String& r);
 
};

class Person {  // Абстрактный класс
public:
Person() {  
       strcpy(name,"NONAME"); age=0; next=0; }
Person(char*NAME,int AGE) {  strcpy(name,NAME); age=AGE; next=0; }
virtual~Person(){};
virtual void Show()=0;
virtual void Input()=0;
friend class List;     //для доступа в List к next
protected:
char name[20];       //имя
int age;             //возраст
Person* next;       
};
class Student: public Person{  //Студент
public:
Student() {grade=0;}
Student(char* NAME,int AGE, float GRADE): Person(NAME,AGE) 
       {grade=GRADE; }
void Show() {
        cout<<"name="<<name<<"            
        age="<<age<<"grade="<<grade<<endl;}
void Input() {
         cout<<"name=";cin>>name;
         cout<<"age=";cin>>age;
         cout<<"grade=";cin>>grade;
}
protected:
float grade;        //рейтинг
};
class Teacher: public Person{  // Преподаватель
public:   Teacher() {work=0;}
Teacher(char* NAME,int AGE,int WORK):
       Person(NAME,AGE) { work=WORK;}
void Show(){cout<<"name="<<name<<"  age="<<age<<"  work="<<work<<endl;}
void Input() {
        cout<<"name=";cin>>name;
        cout<<"age=";cin>>age;
        cout<<"work=";cin>>work;
}
protected:  int work;   //стаж
};
 
class List {
       private: Person* begin;
public:
       List()   {begin=0;}
       ~List();
       void Insert(Person*);
       void Show();
};
List::~List() { 
       Person*r;
    while(begin!=0){ 
               r=begin; begin=begin->next; delete r;}
}
void List::Insert(Person*p){
       Person *r;
       r=begin; begin=p; p->next=r;   }
void List::Show() {
       Person *r;
        r=begin;
        while(r!=0) {r->Show(); r=r->next;} 
}
 
void main() {
      List list;
    Student* ps;
    Teacher* pt;
    ps=new Student("Иванов",21,50.5);
    list.Insert(ps);
    pt=new Teacher("Котов",34,10);
    list.Insert(pt);
    ps=new Student();  ps->Input();
    list.Insert(ps);
    pt=new Teacher();  pt->Input();
    list.Insert(pt);
    list.Show();
}

#include <stdio.h>
#include <string.h>
#include <conio.h>
#include <dos.h>
#include <fstream>
using namespace std;
const char NONAME[]="NONAME";
const char STRINGNAME[]="String";
const char INTNAME[]="Int";
const char FLOATNAME[]="Float";
 
// Абстрактный класс - родитель классов, которые можно сохранять в коллекции
 
class object
{
public:
        char *className;// имя класса
        int sz2;
        int classUID;// уникальный идентификатор класса
        object(){classUID=0;};
        virtual ~object(){};
        virtual int GetUID() = 0;// получение УИК
        virtual char* GetName() = 0;// получение имени класса
 
        virtual int readbin(ifstream &ff) = 0;// чтение из бинарного файла
        virtual int writebin(ofstream &ff) = 0;// запись в бинарный файл
 
        virtual bool Load(char *buf) = 0;// загрузка из строки
        virtual bool Upload(char *buf) = 0;// выгрузка в строку
 
        virtual int Compar(object *rhs) = 0;// сравнение с другим объектом
 
        virtual void Union(object *rhs) = 0;// объединение с другим объектом
 
        virtual void Show(ostream &os = cout) = 0;// вывод в поток
        object *next,*prev;
};
class String: public object
{
public:
        char *str;      // Массив для хранения строки
        int sz;         // Размерность массива
        String(){};                                                                               // Конструктор по умолчанию
        String(char *s){};                                                                // Конструктор с параметрами
        String(const String &rhs){};                                              // Конструктор копирования
         ~String(){};                              // Деструктор
        void add(const char *ns);                                               // Добавление строки
        virtual int GetUID() {return 0;};// получение УИК
        virtual char* GetName() {return "foo";};// получение имени класса
 
        virtual int readbin(ifstream &ff) {return 0;};// чтение из бинарного файла
        virtual int writebin(ofstream &ff){return 0;};// запись в бинарный файл
 
        virtual bool Load(char *buf) {return 0;};// загрузка из строки
        virtual bool Upload(char *buf) {return 0;};// выгрузка в строку
 
        virtual int Compar(object *rhs) {return 0;};// сравнение с другим объектом
 
        virtual void Union(object *rhs) {};// объединение с другим объектом
 
        virtual void Show(ostream &os = cout) {};// вывод в поток                                                            // Преобразование в строку
        //friend ostream& operator<< (ostream& os,const String& r);     // Потоковый ввод/вывод
    //friend istream& operator>> (istream& is,String& r);
 
};
 
class Int: public object
{
        protected:
        Int *next,*prev;// указатели на следующий и предыдущий элементы списка
public:
        int date;       //поле данных
 
        Int();                                                                          // Конструктор по умолчанию
        Int(int a);                                                             // Конструктор с параметрами
        Int(const Int &rhs);                                            // Конструктор копирования
        virtual ~Int();                         // Деструктор
        virtual void change(int ns);                                    // Изменение строки
        virtual void print();                                   // Вывод
        virtual int readbin(ifstream &ifs);                                             // Чтение и запиcь в двоичный файл
        virtual int write(ofstream &ofs);
        //friend ostream& operator<< (ostream& os,const String& r);     // Потоковый ввод/вывод
        //friend istream& operator>> (istream& is,String& r);
 
};
 
int main()
{
 
  String s("qwerty");
 
 
}

#include "head.h"
 
template <class T> class list
{
   class Elem//объект, который будет хранить данные типов
   {
       public:
         T *data;//поле с данными
         Elem * next;//указатели на следующий и предыдущий элемент
         Elem * prev;
         Elem(){data = 0; next = prev = NULL;}//констурктор
         Elem(T *d):data(d){next = prev = NULL;}//конструктор с параметрами
   };
   int size;//размерность списка
   Elem * head;//указатели на начало и конец списка
   Elem * end;
   public:
      list(){head = end = NULL; size=0;}; //конструктор по умолчанию
      ~list()
      {
          Elem * pt = head;
      while(pt->next!=NULL)
          {
              Elem * t = pt;
              pt = pt->next;
              delete t;
           }
}
void add(T *d)// вставка в конец списка
{
       Elem * t = new Elem(d);
        if ( head == NULL ) 
        {
             head = end = t;
             t->next=NULL;
             cout<<"Insert in head"<<endl;
             size=1;
        }
        else      {
              t->prev = end;
              end->next = t;
              end = t;
              t->next=NULL;
              cout<<"Insert in end"<<endl;
              size++;
        }
}
 
void print()  //вывод списка
{
       Elem * pt = head;
       while(pt->next!=NULL)
       {
            pt->data.print();
            pt = pt->next;
       }
}
void include(int num,T *d)//включение объекта по логическому номеру
{
    try
    {
    if(num<0||num>size-1) throw "Invalid number";
    
    else 
    {
        Elem *t=head,*pt=new Elem(d);
        int i=0;
        do 
        {
            t=t->next;
            i++;
        } while(t!=head && i<num);
 
        pt->prev=t->prev;
        t->prev->next=pt;
        pt->next=t;
        t->prev=pt;
    }
    }
    catch (char *s)
    {
        cout<<s<<endl;
    }
}
void exclude(int num)//исключение объекта из списка по логическому номеру
{
    try
    {
    if(num<0||num>size-1) throw "Invalid number";
    
    else 
    {
        if(num==0)//если первый элемент в списке
        {
            Elem *t=head;
            Elem *tt;
            tt=t->next;
            delete t;
            tt->prev=NULL;
            head=tt;
        }
        if(num==size-1)//если последний элемент в списке
        {
            Elem *t=end;
            Elem *tt;
            tt=t->prev;
            delete t;
            tt->next=NULL;
            end=tt;
        }
        if(num!=0&&num!=size)
        {
        Elem *t=head;
        int i=0;
        do 
        {
            t=t->next;
            i++;
        } while(t!=head && i<num);
 
        t->prev->next=t->next;
        t->next->prev=t->prev;
        delete t;
        }
    }
    }
    catch (char *s)
    {
        cout<<s<<endl;
    }
}
void search(int num) //поиск элемента по логисескому номеру
{
    try
    {
    if(num<0||num>size) throw "Invalid number";
    
    else 
    {
        Elem *t=head;
        int i=0;
        do 
        {
            t=t->next;
            i++;
        } while(t!=head && i<num);
 
        cout <<i<<":"<<; t->data.print(); cout<<endl;
    }
    }
    catch (char *s)
    {
        cout<<s<<endl;
    }
}
};

#include <iostream>
#include<conio.h>
#include<string>
 
using namespace std;
 
class Worker {
private:
    std::string fname;
    long id;
protected:
    virtual void Data()const {
        cout << "name: " << fname << endl;
        cout <<"id: "  << id << endl;
    };
    virtual void Get() {
        getline(cin, fname);
        cout << "Enter ID: ";
        cin >> id;
        while (cin.get() != '\n')
            continue;
    }
        
public:
    Worker() :fname("no name"), id(0L) {
 
    }
    Worker(const std::string &s, long n): fname(s), id(n) {
    
    };
    virtual void Set() =0;
    virtual void show()const=0;
};
//--------------
class Waiter: virtual public Worker {
private:
    int panache;
protected:
     void Data()const {
        cout << "panache rating: " << panache << endl;
    };
     void Get() {
        cout << "Enter waiter`s panache rating: ";
        cin >> panache;
        while (cin.get() != '\n')
            continue;
    };
public:
    Waiter()                                       :Worker(),     panache(0) {};
    Waiter(const std::string s, long n, int p = 0) :Worker(s, n), panache(p) {};
    Waiter(const Worker &wk,            int p = 0) :Worker(wk),   panache(p) {};
     void set() {
        cout << "Enter waiter name: ";
        Worker::Get();
        Get();
    };
     void show()const {
        cout << "Category: waiter\n";
        Worker::Data();
        Data();
    };
};
//--------------
class Singer :virtual public Worker {
protected:
    enum{other, alto, contralto, soprano, bass, baritone, tenor};
    enum { vtypes = 7 };
     void Data()const { cout << "Vocal range: " << pv[voice] << endl; };
     void Get() { cout << "Enter number for singer vocal range: \n";
    int i;
    for (i = 0; i < vtypes; i++)
    {
        cout << i << ": " << pv[i] << " ";
        if (i % 4 == 3) cout << endl;
    }
    if (i % 4 != 0)cout << endl;
    cin >> voice;
    while (cin.get()!='\n')
    {
        continue;
    }
    };
private:
    static const char *pv[vtypes];
    int voice;
public  :
    Singer()                                            : Worker(),     voice(other) {};
    Singer(const std::string &s, long n, int v = other) : Worker(s,n),  voice(v)     {};
    Singer(const Worker &wk,             int v = other) : Worker(wk),   voice(v)     {};
     void set() {
        cout << "Enter singer name: ";
        Worker::Get();
        Get();
    };
     void show()const {
        cout << "Category: songer\n";
        Worker::Data();
        Data();
    };
};
const char * Singer::pv[Singer::vtypes] = { "Other", "alto","contralto","soprano","bass","bbaritone", "tenor" };
//==================
class SingerWaiter :public Waiter, public Singer {
protected:
    virtual void Data()const {
        Singer::Data();
        Waiter::Data();
    };
    virtual void Get() {
        Waiter::Get();
        Singer::Get();
    };
public:
    SingerWaiter(){};
    SingerWaiter(const std::string &s, long n, int p = 0, int v = other)    : Worker(s, n), Waiter(s, n, p),    Singer(s, n, v)     {};
    SingerWaiter(const Worker &wk,             int p = 0, int v = other)    : Worker(wk),   Waiter(wk,   p),    Singer(wk,   v)     {};
    SingerWaiter(const Waiter &wtr,                       int v = other)    : Worker(wtr),  Waiter(wtr),        Singer(wtr,  v)     {};
    SingerWaiter(const Singer & sn,            int p = 0)                   : Worker(sn),   Waiter(sn,   p),    Singer(sn)          {};
     void set()      {
        cout << "Enter singing waiter name: ";
        Worker::Get();
        Get();
    };
     void show()const {
        cout << "Category: singing waiter \n";
        Worker::Data();
        Data();
    };
};
/***********************************************************************************/
 
int main()
{
    const int SIZE = 5;
    Worker * lolas[SIZE];
    lolas[0] = new Singer;
    lolas[1] = new Waiter;
 
    
    _getch();
 }