#include <stdio.h>
#include <stdlib.h>

struct INTEGER_LIST {
    int number;
    struct INTEGER_LIST *next;
};

void print_integer_list(struct INTEGER_LIST *list) {
    struct INTEGER_LIST *current;
    for (current = list; current; current = current->next) {
        printf(current == list ? "%d" : ", %d", current->number);
    }
    putchar('\n');
}

void free_integer_list(struct INTEGER_LIST *list) {
    struct INTEGER_LIST *next;
    while (list) {
        next = list->next;
        free(list);
        list = next;
    }
}

struct INTEGER_LIST *new_integer_list(int min, int max) {
    int i;
    struct INTEGER_LIST *list, *next;
    if (min >= max) return NULL;
    list = NULL;
    for (i = max; i >= min; i--) {
        next = list;
        list = (struct INTEGER_LIST*)malloc(sizeof(struct INTEGER_LIST));
        if (!list) {
            free_integer_list(next);
            return NULL;
        }
        list->number = i;
        list->next = next;
    }
    return list;
}

int main(int argc, char *argv[]) {
    struct INTEGER_LIST *numbers;
    numbers = new_integer_list(1, 3);
    if (!numbers) return 1;
    print_integer_list(numbers);
    free_integer_list(numbers);
    return 0;
}

#include <iostream>

class List {
private:
    List *next;
public:
    List *getNext() {
        return this->next;
    }
    List(List *next) {
        this->next = next;
    }
};

class IntegerList: public List {
private:
    int number;
public:
    int getNumber() {
        return this->number;
    }
    IntegerList(int number, List *next): List(next) {
        this->number = number;
    }
};

void printIntegerList(List *list) {
    for (List *current = list; current; current = current->getNext()) {
        if (current != list) {
            std::cout << ',' << ' ';
        }
        std::cout << ((IntegerList*)current)->getNumber();
    }
    std::cout << std::endl;
}

void printIntegerList(List &list) {
    printIntegerList(&list);
}

int main(int argc, char *argv[]) {
    List *numbers = new IntegerList(1, new IntegerList(2, new IntegerList(3, NULL)));
    printIntegerList(numbers);
    while (numbers) {
        List *next = numbers->getNext();
        delete numbers;
        numbers = next;
    }
    return 0;
}

#include <iostream>

using namespace std;

enum ListType {
    LT_EMPTY_LIST,
    LT_INTEGER_LIST
};

class List {
public:
    virtual ListType getType() const = 0;
    List() {}
};

class EmptyList: public List {
public:
    virtual ListType getType() const override {
        return LT_EMPTY_LIST;
    }
    EmptyList(int x): List() {}
};

class IntegerList: public List {
private:
    const int number;
    const List &next;
public:
    virtual ListType getType() const override {
        return LT_INTEGER_LIST;
    }
    int getNumber() const {
        return number;
    }
    const List &getNext() const {
        return next;
    }
    IntegerList(
        int number,
        const List &next
    ): List(next), number(number), next(next) {}
};

void recursivePrintIntegerList(const IntegerList &list, int counter) {
    cout << list.getNumber();
    if (list.getNext().getType() == LT_INTEGER_LIST) {
        cout << ',' << ' ';
        recursivePrintIntegerList((const IntegerList&)list.getNext(), counter + 1);
    }
    if (counter == 1) {
        cout << endl;
    }
}

void recursivePrintIntegerList(const IntegerList &list) {
    recursivePrintIntegerList(list, 1);
}

void foreachPrintIntegerList(const IntegerList &list) {
    int counter = 0;
    for (
        List &current = (List&)list;
        current.getType() == LT_INTEGER_LIST;
        current = ((IntegerList&)current).getNext()
    ) {
        if (counter > 10) break;
        if (counter > 0) {
            cout << ',' << ' ';
        }
        counter++;
        cout << ((IntegerList&)current).getNumber();
    }
    cout << endl;
}

int main(int argc, char *argv[]) {
    const EmptyList empty(0);
    const IntegerList n3(3, empty);
    const IntegerList n2(2, n3);
    const IntegerList n1(1, n2);
    const IntegerList numbers(1, IntegerList(2, IntegerList(3, empty)));
    cout << n1.getNumber() << ',' << ' ' << n2.getNumber() << ',' << ' ' << n3.getNumber() << endl;
    cout << numbers.getNumber() << ',' << ' ';
    cout << ((IntegerList&)numbers.getNext()).getNumber() << ',' << ' ';
    cout << ((IntegerList&)(
        (IntegerList&)(
            (IntegerList&)numbers.getNext()
        ).getNext()
    )).getNumber() << endl;
    recursivePrintIntegerList(numbers);
    foreachPrintIntegerList(numbers);
    return 0;
}

#include <cassert>
#include <iostream>
#include <memory>
#include <type_traits>

template <typename T>
struct ListNode
{
   T value{};
   std::unique_ptr<ListNode> next;

   template <typename...X>
   ListNode(X&&...x) : value{std::forward<X>(x)...}{}
};

template <typename T>
requires (!std::is_reference_v<T>)
class ListNodeIterator
{
public:
   using value_type = std::remove_const_t<T>;
   using node_type = std::conditional_t<std::is_const_v<T>, const ListNode<value_type>, ListNode<value_type>>;

   ListNodeIterator() = default;
   ListNodeIterator(node_type* node) : m_node(node) {}

   T& operator*() const { assert(m_node); return m_node->value; }
   ListNodeIterator& operator++() { assert(m_node); m_node = m_node->next.get(); return *this; }
   bool operator == (const ListNodeIterator& rhs) const { return m_node == rhs.m_node; }

private:
   node_type* m_node{};
};

template <typename T>
requires std::same_as<T, std::decay_t<T>>
class UniDirList
{
public:
   using iterator = ListNodeIterator<T>;
   using const_iterator = ListNodeIterator<const T>;

   UniDirList() = default;
   UniDirList(std::initializer_list<T> values) { for(auto&& value : values) emplace_back(value); }

   bool empty() const { return !m_first; }

   iterator begin() { return iterator{ m_first.get() }; }
   iterator end() { return {}; }

   const_iterator begin() const { return const_iterator{ m_first.get() }; }
   const_iterator end() const { return {}; }

   template <typename...X>
   T& emplace_back(X&&...x) {
      if (m_last) {
         m_last->next = std::make_unique<Node>(std::forward<X>(x)...);
         m_last = m_last->next.get();
      }
      else {
         m_first = std::make_unique<Node>(std::forward<X>(x)...);
         m_last = m_first.get();
      }
      return m_last->value;
   }

private:
   using Node = ListNode<T>;
   std::unique_ptr<Node> m_first;
   Node* m_last{};
};

int main()
{
   UniDirList list = {3.14, 2.71, 1.61};

   list.emplace_back(42.);

   for (double value : list)
      std::cout << value << " ";
}

#include <iostream>

using namespace std;

enum ListType {
    LT_EMPTY_LIST,
    // Переименовываем LT_INTEGER_LIST в невладеющий указателями View
    LT_INTEGER_LIST_VIEW,
    // Для примера добавляем владеющий указателями Container
    LT_INTEGER_LIST_CONTAINER
};

class List {
public:
    virtual ListType getType() const = 0;
    // Добавил сервисный метод is для красоты:
    bool is(ListType type) const { return type == getType();}
    List() {}
    // Как уже подсказали, нужен деструктор при наследовании,
    // т.к. вводим владеющий контейнер:
    virtual ~List() {}
};

class EmptyList: public List {
public:
    virtual ListType getType() const override {
        return LT_EMPTY_LIST;
    }
    EmptyList(int x): List() {}
};

// Выделяем общий интерфейс:
class IntegerList: public List {
public:
    virtual int getNumber() const {
        return 0;
    }
    // чтобы не в даваться в детали, пусть будет виртуальным:
    virtual const List &getNext() const = 0;
};

// Реализация твоего IntegerView, как невладеющий указателями IntegerListView:
class IntegerListView: public IntegerList {
private:
    const int number;
    const List &next;
public:
    virtual ListType getType() const override {
        return LT_INTEGER_LIST_VIEW;
    }
    virtual int getNumber() const override {
        return number;
    }
    virtual const List &getNext() const override {
        return next;
    }
    IntegerListView(
        int number,
        const List &_next
    ): number(number), next(_next) {}
};

// Добавляем для примера владеющий указателями IntegerListContainer:
class IntegerListContainer: public IntegerList {
private:
    const int number;
    const List *next;
public:
    virtual ListType getType() const override {
        return LT_INTEGER_LIST_CONTAINER;
    }
    virtual int getNumber() const override {
        return number;
    }
    virtual const List &getNext() const override{
        return *next;
    }
    IntegerListContainer(
        int number,
        List *_next
    ): number(number), next(_next) {}
    virtual ~IntegerListContainer() override {
        if (next) {
            delete next;
        //  ^^^^^^ Поэтому и нужен виртуальный деструтор.
        }
    }
};

// Слегка меняем интерфейс функции:
void recursivePrintIntegerList(const IntegerList* pList, int counter, ListType LT_INTEGER_LIST_VIEW) {
    cout << pList->getNumber();
    if (pList->getNext().is(LT_INTEGER_LIST_VIEW)) {
        cout << ',' << ' ';
        recursivePrintIntegerList((const IntegerList*)&pList->getNext(), counter + 1, LT_INTEGER_LIST_VIEW);
    }
    if (counter == 1) {
        cout << endl;
    }
}

// Тоже слегка меняем интерфейс функции:
void recursivePrintIntegerList(const IntegerList *pList, ListType LT_INTEGER_LIST_VIEW) {
    cout << "recursivePrintIntegerList(" << LT_INTEGER_LIST_VIEW << ") => ";
    recursivePrintIntegerList(pList, 1, LT_INTEGER_LIST_VIEW);
}

// Тоже слегка меняем интерфейс функции:
void foreachPrintIntegerList(const IntegerList&list, ListType LT_INTEGER_LIST_VIEW) {
    cout << "foreachPrintIntegerList(" << LT_INTEGER_LIST_VIEW << ") => ";
    int counter = 0;
    for (
        // Тут тебе уже подсказали, что твой вариант предполагал семантику ссылок языков с GC,
        // Поэтому явное возьмём указатели:
        const List *current = &list;
        current && current->is(LT_INTEGER_LIST_VIEW);
        current = &((const IntegerList*)current)->getNext()
    ) {
        if (counter > 10) break;
        if (counter > 0) {
            cout << ',' << ' ';
        }
        counter++;
        cout << ((const IntegerList*)current)->getNumber();
    }
    cout << endl;
}

int main(int argc, char *argv[]) {
    const EmptyList empty(0);
    const IntegerListView n3(3, empty);
    const IntegerListView n2(2, n3);
    const IntegerListView n1(1, n2);

    // const IntegerList numbers(1, IntegerList(2, IntegerList(3, empty)));
    //                     Если так ^^^^^^^^^^^^ сделать,
    // то временные объекты тут же разрушатся и останутся висячие указатели на них.

    // тут можно использовать владеющий контейнер пока так:
    const IntegerListContainer numbers(1, new IntegerListContainer(2, new IntegerListContainer(3, new EmptyList(0))));
    // Кстати, после программирования на сборщике мусора,
    // людям обычно нравятся std::shared_ptr<>,
    // т.к. они по семантике похожи, но есть особенности.

    // Подправим вывод информационных сообщений:
    cout << "n1... => " << n1.getNumber() << ',' << ' ' << n2.getNumber() << ',' << ' ' << n3.getNumber() << endl;
    cout << "numbers... => " << numbers.getNumber() << ',' << ' ';
    cout << ((IntegerListContainer&)numbers.getNext()).getNumber() << ',' << ' ';
    cout << ((IntegerListContainer&)(
        (IntegerListContainer&)(
            (IntegerListContainer&)numbers.getNext()
        ).getNext()
    )).getNumber() << endl;
    recursivePrintIntegerList(&n1, n1.getType());
    recursivePrintIntegerList(&numbers, numbers.getType());
    foreachPrintIntegerList(n1, n1.getType());
    foreachPrintIntegerList(numbers, numbers.getType());
    return 0;
}

n1... => 1, 2, 3
numbers... => 1, 2, 3
recursivePrintIntegerList(1) => 1, 2, 3
recursivePrintIntegerList(2) => 1, 2, 3
foreachPrintIntegerList(1) => 1, 2, 3
foreachPrintIntegerList(2) => 1, 2, 3