#include <assert.h>
#include <stdio.h>
#include <string>

using namespace std;

class list_item_t {
public:
  virtual ~list_item_t() {}
  const list_item_t* prev() const {return _prev;}
  const list_item_t* next() const {return _next;}
  list_item_t* prev() {return _prev;}
  list_item_t* next() {return _next;}
  virtual void print() const = 0;
private:
  list_item_t* _prev = nullptr;
  list_item_t* _next = nullptr;
  friend class list_t;
};

class list_t {
public:
  // запрещаем неявное копирование
  list_t(const list_t& source) = delete; // удаляем конструктор копирования
  list_t& operator=(const list_t& source) = delete; // удаляем оператор присваивания

  list_t() {}
  ~list_t() {clear();}
  const list_item_t* first() const {return _first;}
  const list_item_t* last() const {return _last;}
  list_item_t* first() {return _first;}
  list_item_t* last() {return _last;}
  void add(list_item_t* item) {insert(item, _last, nullptr);} // добавляет в конец списка
  void insert(list_item_t* item, list_item_t* prev, list_item_t* next);
  void clear();
  void print_items() const;
private:
  list_item_t* _first = nullptr;
  list_item_t* _last = nullptr;
};

void list_t::insert(list_item_t* item, list_item_t* prev, list_item_t* next) {
  assert(item->_prev == nullptr);
  assert(item->_next == nullptr);
  item->_prev = prev;
  item->_next = next;
  if (prev != nullptr) {
    assert(prev->_next == next);
    prev->_next = item;
  } else {
    assert(_first == next);
    _first = item;
  }
  if (next != nullptr) {
    assert(next->_prev == prev);
    next->_prev = item;
  } else {
    assert(_last == prev);
    _last = item;
  }
}

void list_t::clear() {
  list_item_t* i2;
  for (list_item_t* i = _first; i != nullptr; i = i2) {
    i2 = i->_next;
    delete i;
  }
  _first = _last = nullptr;
}

void list_t::print_items() const {
  for (const list_item_t* i = _first; i != nullptr; i = i->_next) {
    i->print();
  }
}

class int_list_item_t : public list_item_t {
public:
  explicit int_list_item_t(int value) : _value(value) {}
  virtual void print() const override {printf("int %i\n", _value);}
private:
  int _value;
};

class float_list_item_t : public list_item_t {
public:
  explicit float_list_item_t(float value) : _value(value) {}
  virtual void print() const override {printf("float %f\n", _value);}
private:
  float _value;
};

class string_list_item_t : public list_item_t {
public:
  explicit string_list_item_t(const char value[]) : _value(value) {}
  virtual void print() const override {printf("string %s\n", _value.c_str());}
private:
  string _value;
};

int main() {
  list_t list;
  int_list_item_t* i1 = new int_list_item_t(1); list.add(i1);
  float_list_item_t* i3 = new float_list_item_t(0.5f); list.add(i3);
  string_list_item_t* i2 = new string_list_item_t("abc"); list.insert(i2, /*prev:*/i1, /*next:*/i3);

  assert(list.first() == i1);
  assert(list.first()->next() == i2);
  assert(list.first()->next()->next() == i3);
  assert(list.first()->next()->next()->next() == nullptr);

  list.print_items();
  return 0;
}

int 1
string abc
float 0.500000

	object *mas[3];
	
	mas[0] = new object();
	mas[1] = new object();
	mas[2] = new float_object();