Очередь

#include <stdio.h>
#include <stdlib.h>
#include <locale.h>
 
typedef struct QueueNode DataType;             
 
struct QueueNode *next;                            
 
    void input(int count){                          
        int ci,ei;                                    
                                                     
        printf("Enter c: ");
            scanf("%d",&ci);
        printf("Enter e: ");
            scanf("%d",&ei);
    }
 
void output(){                                
        printf ("cix^ei");
    }
 
void QueueNode *addToQueue (QueueNode*ptr, int &count){          
    QueueNode *tmp == ptr,*cur == new QueueNode;                
    cur->input(count++);                                  
    cur->next = nullptr;                                  
 
    if(ptr == nullptr){                                    
        ptr = cur;                                          
    }
    else{                                                   
        while(tmp -> next != nullptr){
            tmp = tmp -> next;
        }
 
        tmp -> next = cur;                                  
    }
 
    return ptr;                                             
}
 
void showQueue(QueueNode *ptr){                             
    QueueNode *tmp = ptr;
 
    if(ptr == nullptr){
        printf("Queue is empty!\n");                  
    }
    else{
        printf("P = ");
        while(tmp != nullptr){                             
            tmp -> output();                                    
 
            if(tmp -> next != nullptr) printf() << " + ";      
            tmp = tmp -> next;                                  
        }
        printf(';');
    }
}
 
void delQueue(QueueNode *ptr){                             
    QueueNode *tmp = ptr, *cur(nullptr);
 
    if(ptr == nullptr){
        printf("Queue is empty!\n");                  
    }
    else{
        while(tmp != nullptr){
            cur = tmp -> next;                     
            delete tmp;                                
            tmp = cur;                                 
        }
    }
}
 
int _tmain(int argc, _tchar* argv[])
{
    int count(1);                           
    QueueNode *Head(nullptr);               
 
    for(int i = 0; i < 3; ++i)              
        Head = addToQueue(Head, count);
 
    showQueue(Head);                        
    delQueue(Head);                         
 
    printf("\n\n");
    return 0;
}

#include <iostream>
 
struct QueueNodeBase {
    QueueNodeBase *prev;
    QueueNodeBase *next;
 
    QueueNodeBase() : next(this), prev(this) {}
 
    QueueNodeBase(QueueNodeBase *prev, QueueNodeBase *next) : next(next), prev(prev) {
        next->prev = prev->next = this;
    }
 
    ~QueueNodeBase() {
        next->prev = prev;
        prev->next = next;
    }
};
 
template<typename T>
struct QueueNode : public QueueNodeBase {
    T value;
 
    QueueNode(QueueNodeBase *prev, QueueNodeBase *next, const T &value) : QueueNodeBase(prev, next), value(value) {}
};
 
template<typename T, typename QueueNodeBasePointer, typename QueueNodePointer>
struct QueueIterator {
    using iterator_category = std::bidirectional_iterator_tag;
    using difference_type = std::ptrdiff_t;
    using value_type = T;
    using pointer = value_type *;
    using reference = value_type &;
    using self = QueueIterator<T, QueueNodeBasePointer, QueueNodePointer>;
 
    QueueIterator(QueueNodeBasePointer node) : node(node) {}
 
    reference operator*() { return static_cast<QueueNodePointer>(node)->value; }
 
    reference operator*() const { return static_cast<QueueNodePointer>(node)->value; }
 
    pointer operator->() { return &static_cast<QueueNodePointer>(node)->value; }
 
    pointer operator->() const { return &static_cast<QueueNodePointer>(node)->value; }
 
    self &operator++() {
        node = node->next;
        return *this;
    }
 
    self operator++(int) {
        self result = *this;
        ++(*this);
        return result;
    }
 
    self &operator--() {
        node = node->prev;
        return *this;
    }
 
    self operator--(int) {
        self result = *this;
        --(*this);
        return result;
    }
 
    friend bool operator==(const self &a, const self &b) {
        return a.node == b.node;
    };
 
    friend bool operator!=(const self &a, const self &b) {
        return a.node != b.node;
    };
 
    QueueNodeBasePointer node;
};
 
template<typename T>
class Queue {
public:
    using Iterator = QueueIterator<T, QueueNodeBase *, QueueNode<T> *>;
    using ConstIterator = QueueIterator<const T, const QueueNodeBase *, const QueueNode<T> *>;
    using Node = QueueNode<T>;
 
    Queue() : base() {}
 
    Queue(const std::initializer_list<T> &list) : base() {
        for (auto &i : list) {
            pushBack(i);
        }
    }
 
    Queue(const Queue<T> &other) : base() {
        for (auto &i : other) {
            pushBack(i);
        }
    }
 
    Queue<T> &operator=(const Queue<T> &other) {
        if (this != &other) {
            clear();
            for (auto &i : other) {
                pushBack(i);
            }
        }
        return &this;
    }
 
    ~Queue() {
        clear();
    }
 
    void pushBack(const T &value) {
        new Node(base.prev, &base, value);
    }
 
    T popFront() {
        T result = *begin();
        delete base.next;
        return result;
    }
 
    Iterator begin() {
        return base.next;
    }
 
    Iterator end() {
        return &base;
    }
 
    ConstIterator begin() const {
        return base.next;
    }
 
    ConstIterator end() const {
        return &base;
    }
 
    ConstIterator cbegin() const {
        return base.next;
    }
 
    ConstIterator cend() const {
        return &base;
    }
 
    bool isEmpty() const {
        return base.next == &base;
    }
 
    void clear() {
        while (!isEmpty()) {
            delete base.next;
        }
    }
 
private:
    QueueNodeBase base;
};
 
template<typename T>
std::ostream &operator<<(std::ostream &out, const Queue<T> &q) {
    for (auto i = q.cbegin(), end = q.cend(); i != end;) {
        std::cout << *i++;
        if (i != end) {
            std::cout << ", ";
        }
    }
    return out;
}
 
// допустим, очередь содержит коэфициенты полинома от младшей степени к старшей
template<typename T>
Queue<T> differentiate(const Queue<T> &polynomial) {
    if (polynomial.isEmpty()) {
        return Queue<T>();
    }
    Queue<T> result;
    std::size_t c = 0;
    for (auto i = ++polynomial.begin(), end = polynomial.end(); i != end;) {
        result.pushBack((++c) * (*i++));
    }
    return result;
}
 
 
int main() {
    Queue<double> coefficients{1, 3, 3, 1};
 
    std::cout << coefficients << std::endl << differentiate(coefficients) << std::endl;
 
    return 0;
}