Functional list in C ++ – Code revision stack exchange

This is more of an example of an immutable data type toy in C ++. I have tried to follow functional languages ​​like Scheme, Racket – making list as a contras cell: list is list or it is empty.

/ *
* Abstract class
* /
model 
ImmutableList class {

public:
~ ImmutableList () {std :: cout << "base class destructor";}
virtual bool is_empty () = 0;
virtual head T () = 0;
Immutable virtual list * queue () = 0;
virtual int length () = 0;
};

/ *
* Class not empty List
* /

model 
List of classes: Public ImmutableList {

int size = 1;
T first;
Immutable list * break;
public:

List (T _first, ImmutableList * _tail) {
first = _first;
rest = _tail;
size + = _tail-> length ();
}
~ List () {std :: cout << "List class destructor";}
bool is_empty () {return false; }

Head t () {
come back first
}

Immutable list* tail () {
return to rest
}

int length () {return size;}
};

/ *
* empty list class
* /
model 
Nil class: public ImmutableList {
public:
~ Nil ();
bool is_empty () {return true;}
int length () {return 0;}
Head t () {
throw std :: logic_error ("Empty list header!");
}
Immutable list * tail () {
throw std :: logic_error ("Empty list queue!");
}
};

There are more functions, such as reverse, there's also cons function – build a list.
Does this really need destroyers? Will it be better to use smart pointers?