Имеется двусвязный список действительных чисел. Продублировать в нем все положительные числа

#include <iostream>
#include <cstdlib>
#include <ctime>
 
struct Node {
    int data = 0;
    Node* next = nullptr;
};
 
//-----------------------------------------------------------------------------
void push(Node*& list, int data) {
    Node* node = new Node;
    node->data = data;
    node->next = list;
    list = node;
}
//-----------------------------------------------------------------------------
void pop(Node*& list) {
    Node* node = list;
    list = list->next;
    delete node;
}
//-----------------------------------------------------------------------------
void clean(Node*& list) {
    for (; list; pop(list)) { ; }
}
//-----------------------------------------------------------------------------
std::ostream& operator << (std::ostream& os, Node*& list) {
    for (auto it = list; it; it = it->next) {
        os << it->data << " ";
    }
    return os;
}
//-----------------------------------------------------------------------------
Node* getRandomList(unsigned cnt, int min, int max) {
    Node* list = nullptr;
    while (cnt--) {
        push(list, rand() % (max - min) + min);
    }
    return list;
}
//-----------------------------------------------------------------------------
Node* duplication(Node* list) {
    for (auto it = list; it; it = it->next) {
        if (0 < it->data) {
            push(it->next, it->data);
            it = it->next;
        }
    }
    return list;
}
//-----------------------------------------------------------------------------
 
int main() {
    std::srand(std::time(nullptr));
 
    auto list = getRandomList(10, -50, 50);
 
    std::cout << "source: " << list << std::endl;
 
    duplication(list);
 
    std::cout << "result: " << list << std::endl;
 
    clean(list);
 
    return 0;
}

#include <iostream>
#include <stack>
 
int main() {
    std::stack<int> mainStack;
    std::stack<int> positiveStack;
    std::stack<int> negativeStack;
 
    for (int i = -50; i <= 50; ++i) {
        mainStack.push(i);
    }
 
    std::stack<int> tempStack(mainStack);
 
    std::cout << "All numbers in stack:" << std::endl;
    while (!tempStack.empty()) {
        std::cout << tempStack.top() << ' ';
        tempStack.pop();
    }
    std::cout << std::endl;
 
    while (!mainStack.empty()) {
        int value = mainStack.top();
        mainStack.pop();
        if (value > 0) {
            positiveStack.push(value);
        } else if (value < 0) {
            negativeStack.push(value);
        }
    }
 
    std::cout << "Positive stack:" << std::endl;
    while (!positiveStack.empty()) {
        std::cout << positiveStack.top() << ' ';
        positiveStack.pop();
    }
    std::cout << std::endl;
 
    std::cout << "Negative stack:" << std::endl;
    while (!negativeStack.empty()) {
        std::cout << negativeStack.top() << ' ';
        negativeStack.pop();
    }
    std::cout << std::endl;
 
    return 0;
}

#include <iostream>
#include <random>
 
template<typename T>
struct VNode;
 
struct Node {
    Node *prev;
    Node *next;
 
    Node() : prev(this), next(this) {}
    Node(Node *position) : prev(position), next(position->next) {
        next->prev = prev->next = this;
    }
    virtual ~Node() {
        next->prev = prev;
        prev->next = next;
    }
 
    template<typename T>
    T &value() {
        return dynamic_cast<VNode<T>*>(this)->value;
    }
};
 
template<typename T>
struct VNode : public Node {
    T value;
    VNode(Node *position, const T &value) : Node(position), value(value) {}
};
 
template<typename T>
VNode<T> *insert(Node *position, const T &value) {
    return new VNode<T>(position, value);
}
 
Node *erase(Node *position) {
    Node *result = position->next;
    delete position;
    return result;
}
 
void clear(Node &list) {
    while (&list != list.next) {
        delete list.next;
    }
}
 
template<typename Generator>
void generateN(std::size_t n, Node *position, Generator generate) {
    while (n--) {
        position = insert(position->next, generate());
    }
}
 
template<typename T>
std::ostream &output(std::ostream &out, const Node &base) {
    for (auto i = base.next; i != &base;) {
        out << i->template value<T>();
        if ((i = i->next) != &base) {
            out << ", ";
        }
    }
    return out;
}
 
template<typename T, typename Predicate>
void eraseIf(Node *begin, Node *end, Predicate condition) {
    while (begin != end) {
        if (condition(begin->template value<T>())) {
            begin = erase(begin);
        } else {
            begin = begin->next;
        }
    }
}
 
template<typename T, typename Predicate>
void duplicateIf(Node *begin, Node *end, Predicate condition) {
    while (begin != end) {
        auto &value = begin->template value<T>();
        if (condition(value)) {
            begin = insert(begin, value);
        }
        begin = begin->next;
    }
}
 
int main() {
    std::random_device rd; // генератор случайных чисел
    std::mt19937 rg(rd()); // больше генераторов случайных чисел
    // равномерное распределение для количества чисел в списке
    std::uniform_int_distribution<std::size_t> sdis(10, 15);
    // равномерное распределение для значений элементов в списке
    std::uniform_real_distribution<float> vdis(-50, 50);
 
    // будущий размер списка
    std::size_t n = sdis(rg);
    // генератор случайного действительного числа
    auto randomFloat = [&]()->float { return vdis(rg); };
 
    // Имеется двусвязный список действительных чисел
    Node list;
 
    // Создать список с числами в диапазоне от –50 до +50
    generateN(n, &list, randomFloat);
 
    // вывод
    output<float>(std::cout, list) << '\n';
 
    // продублировать все положительные числа
    duplicateIf<float>(list.next, &list, [](auto v) { return v > 0; });
 
    // вывод
    output<float>(std::cout, list) << '\n';
 
    // чтоб не было отрицательных
    eraseIf<float>(list.next, &list, [](auto v) { return v < 0; });
 
    // вывод
    output<float>(std::cout, list) << '\n';
 
    // В конце работы все списки должны быть удалены
    clear(list);
    return 0;
}