Создать односвязный линейный список

#include <iostream>
#include <iomanip>
 
struct ForwardListNodeBase {
    ForwardListNodeBase *next;
 
    ForwardListNodeBase() : next{this} {}
 
    ForwardListNodeBase(ForwardListNodeBase *after) : next(after->next) {
        after->next = this;
    }
 
    void remove(ForwardListNodeBase *previous) {
        previous->next = next;
    }
};
 
template<typename T>
struct ForwardListNode : public ForwardListNodeBase {
    T value;
 
    ForwardListNode(ForwardListNodeBase *after, const T &value) noexcept: ForwardListNodeBase{after},
                                                                          value{value} {}
};
 
template<typename T>
struct ForwardListIterator {
    using Self = ForwardListIterator<T>;
    using Node = ForwardListNode<T>;
    using NodeBase = ForwardListNodeBase;
 
    using value_type = T;
    using pointer = value_type *;
    using reference = value_type &;
    using difference_type = std::ptrdiff_t;
    using iterator_category = std::forward_iterator_tag;
 
    NodeBase *node;
 
    ForwardListIterator(ForwardListNodeBase *node) noexcept: node{node} {}
 
    reference operator*() const noexcept {
        return static_cast<Node *>(node)->value;
    }
 
    reference operator->() const noexcept {
        return &static_cast<Node *>(node)->value;
    }
 
    Self &operator++() noexcept {
        node = node->next;
        return *this;
    }
 
    Self operator++(int) noexcept {
        Self result{node};
        node = node->next;
        return result;
    }
 
    friend bool operator==(const Self &a, const Self &b) noexcept {
        return a.node == b.node;
    }
 
    friend bool operator!=(const Self &a, const Self &b) noexcept {
        return a.node != b.node;
    }
};
 
template<typename T>
struct ForwardListConstIterator {
    using Self = ForwardListConstIterator<T>;
    using Node = const ForwardListNode<T>;
    using NodeBase = ForwardListNodeBase;
    using Iterator = ForwardListIterator<T>;
 
    using value_type = T;
    using pointer = const value_type *;
    using reference = const value_type &;
    using difference_type = std::ptrdiff_t;
    using iterator_category = std::forward_iterator_tag;
 
    const NodeBase *node;
 
    ForwardListConstIterator(const ForwardListNodeBase *node) noexcept: node{node} {}
 
    ForwardListConstIterator(const Iterator &i) noexcept: node{i.node} {}
 
    reference operator*() const noexcept {
        return static_cast<Node *>(node)->value;
    }
 
    pointer operator->() const noexcept {
        return &static_cast<Node *>(node)->value;
    }
 
    Self &operator++() noexcept {
        node = node->next;
        return *this;
    }
 
    Self operator++(int) noexcept {
        Self result{node};
        node = node->next;
        return result;
    }
 
    friend bool operator==(const Self &a, const Self &b) noexcept {
        return a.node == b.node;
    }
 
    friend bool operator!=(const Self &a, const Self &b) noexcept {
        return a.node != b.node;
    }
};
 
 
template<typename T>
class ForwardList {
public:
    using Self = ForwardList<T>;
    using NodeBase = ForwardListNodeBase;
    using Node = ForwardListNode<T>;
 
    using value_type = T;
    using reference = value_type &;
    using const_reference = const value_type &;
    using pointer = value_type *;
    using const_pointer = const value_type *;
    using iterator = ForwardListIterator<T>;
    using const_iterator = ForwardListConstIterator<T>;
 
    ForwardList() noexcept: base{} {}
 
    ForwardList(const Self &) = delete;
 
    Self &operator=(const Self &) = delete;
 
    iterator before_begin() {
        return &base;
    }
 
    iterator begin() {
        return base.next;
    }
 
    iterator end() {
        return &base;
    }
 
    const_iterator before_begin() const {
        return &base;
    }
 
    const_iterator begin() const {
        return base.next;
    }
 
    const_iterator end() const {
        return &base;
    }
 
    iterator insert_after(const_iterator position, const_reference value) {
        return new Node{const_cast<NodeBase *>(position.node), value};
    }
 
    iterator erase_after(const_iterator position) {
        Node *node = position.node->next;
        node->remove(position.node);
        delete node;
        return position.node->next;
    }
 
    iterator push_front(const_reference value) {
        return insert_after(before_begin(), value);
    }
 
    void pop_front() {
        erase_after(before_begin());
    }
 
    bool isEmpty() const {
        return &base == base.next;
    }
 
    void clear() {
        while (!isEmpty()) {
            erase_after(before_begin());
        }
    }
 
private:
    NodeBase base;
};
 
template<typename Container>
struct ForwardListInsertAfterIterator {
    using value_type = void;
    using reference = void;
    using const_reference = void;
    using pointer = void;
    using difference_type = void;
    using iterator_category = std::output_iterator_tag;
 
    using Self = ForwardListInsertAfterIterator<Container>;
    using Iterator = typename Container::iterator;
 
    ForwardListInsertAfterIterator(Container &container, Iterator position) noexcept
            : container{container}, position{position} {}
 
    Self &operator=(typename Container::const_reference value) {
        position = container.insert_after(position, value);
        return *this;
    }
 
    Self &operator*() {
        return *this;
    }
 
    Self &operator++() {
        return *this;
    }
 
    Self &operator++(int) {
        return *this;
    }
 
    Container &container;
    Iterator position;
};
 
template<typename T>
ForwardListInsertAfterIterator<ForwardList<T>>
afterInserter(ForwardList<T> &list, typename ForwardList<T>::iterator position) {
    return ForwardListInsertAfterIterator<ForwardList<T>>(list, position);
}
 
template<typename T>
std::ostream &operator<<(std::ostream &out, const ForwardList<T> &list) {
    out << "[";
    for (auto i = list.begin(); i != list.end();) {
        out << *i++;
        if (i != list.end()) {
            out << ", ";
        }
    }
    return out << "]";
}
 
 
template<typename Iterator, typename T, typename BinaryOperation>
T accumulate(Iterator begin, Iterator end, T initial, BinaryOperation operation) {
    for (; begin != end; ++begin) {
        initial = operation(std::move(initial), *begin);
    }
    return initial;
}
 
int main() {
    ForwardList<double> list;
 
    auto inserter = afterInserter(list, list.before_begin());
 
    for (double value; std::cin >> value;) {
        *inserter++ = value;
    }
 
    std::cout << list << "\n";
 
    double productPositive = accumulate(list.begin(), list.end(), 1.0,
                                        [](double product, double value) {
                                            return value < 0 ? value : product * value;
                                        });
 
    std::cout << std::fixed << std::setprecision(4) << productPositive << "\n";
    return 0;
}