Форум программистов, компьютерный форум, киберфорум
C для начинающих
Форум программистов и сисадминов Киберфорум > Форум программистов > C/C++ > C (Си) > C для начинающих
Войти
Регистрация
Восстановить пароль
Карта форума Темы раздела Блоги Сообщество Поиск Заказать работу  
 
Рейтинг 4.73/26: Рейтинг темы: голосов - 26, средняя оценка - 4.73
0 / 0 / 0
Регистрация: 19.06.2012
Сообщений: 22
1

FIFO

19.06.2012, 20:04. Показов 4862. Ответов 4
Метки нет (Все метки)
Author24 — интернет-сервис помощи студентам
надо реализовать класс FIFO (добавление,считивание елементов)
0
Programming
Эксперт
94731 / 64177 / 26122
Регистрация: 12.04.2006
Сообщений: 116,782
 19.06.2012, 20:04
Ответы с готовыми решениями:

Список FIFO со стеками
Доброго времени суток,Уважаемые форумчане! Прошу вашей помощи в решении моей проблемы. Имеется...

Нужно реализовать FIFO
Имея заголовочный файл queue.h нужно реализовать FIFO в файле queue.c, файл queue.h имеет вид: ...

Очередь элементов (FIFO)
Нужно создать программу демонстрации работы очереди(FIFO) на примере автомобилей которая будет...

Индивидуальное задание (FIFO, массивы)
Привет! Ребята, нужна ваша помощь. Мне нужно написать несколько программ на работу с очередями,...

4
2554 / 1319 / 178
Регистрация: 09.05.2011
Сообщений: 3,086
Записей в блоге: 1
19.06.2012, 21:49 2
В Си нет классов.
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128

#ifndef __STACK_HPP__
#define __STACK_HPP__
//------------------------------------------------------------------------------
#include <cstdlib>
#include <utility>
#include <stdexcept>
//------------------------------------------------------------------------------
template <class T>
class Stack
{
    //--------------------------------------------------------------------------
public:
    using value_type        = T;
    using reference         = T&;
    using const_reference   = const T&;
    using rvalue_reference  = T&&;
    using size_type         = std::size_t;
    //--------------------------------------------------------------------------
    struct _Element
    {
        using _ptr  = _Element*;
        //----------------------------------------------------------------------
        T data;
        _ptr next;
        //----------------------------------------------------------------------
        explicit _Element(const_reference d = T(), const _ptr& e = nullptr)
            : data(d), next(e)
        {
 
        }
        //----------------------------------------------------------------------
        explicit _Element(rvalue_reference d = T(), const _ptr& e = nullptr)
            : data(d), next(e)
        {
 
        }
        //----------------------------------------------------------------------
    };
    //--------------------------------------------------------------------------
    using _E = _Element;
    //--------------------------------------------------------------------------
private:
    _E*         _head;
    size_type   _size;
    //--------------------------------------------------------------------------
public:
    explicit Stack(): _head(nullptr), _size(0)
    {
 
    }
    //--------------------------------------------------------------------------
    ~Stack()
    {
        while(_size--)
        {
            _E* tmp = _head -> next;
            delete _head;
            _head = tmp;
        }
    }
    //--------------------------------------------------------------------------
    void push(const_reference ref)
    {
        _head = new _E(ref, _head);
        ++_size;
    }
    //--------------------------------------------------------------------------
    void push(rvalue_reference r_ref)
    {
        _head = new _E(r_ref, _head);
        ++_size;
    }
    //--------------------------------------------------------------------------
    void pop()
    {
        if(_head)
        {
            _E* tmp = _head -> next;
            delete _head;
            _head = tmp;
            --_size;
        }
        else
            throw std::length_error("No element in stack");
    }
    //--------------------------------------------------------------------------
    reference top()
    {
        if(_head)
            return _head -> data;
        else
            throw std::length_error("No element in stack");
    }
    //--------------------------------------------------------------------------
    const_reference top()                                               const
    {
        if(_head)
            return _head -> data;
        else
            throw std::length_error("No element in stack");
    }
    //--------------------------------------------------------------------------
    const bool empty()                                                  const
    {
        return _head == nullptr;
    }
    //--------------------------------------------------------------------------
    const size_type size()                                              const
    {
        return _size;
    }
    //--------------------------------------------------------------------------
    // deleted functions
    template <class U>
    Stack(const Stack<U>&) = delete;
    //--------------------------------------------------------------------------
    template <class U>
    Stack(const Stack<U>&&) = delete;
    //--------------------------------------------------------------------------
    template <class U>
    Stack<T>& operator=(const Stack<U>&) = delete;
    //--------------------------------------------------------------------------
    template <class U>
    Stack<T>& operator=(Stack&&) = delete;
    //--------------------------------------------------------------------------
};
//------------------------------------------------------------------------------
#endif /*__STACK_HPP__*/
Исходя из предположения, что требуется C++
1
Модератор
Эксперт PythonЭксперт JavaЭксперт CЭксперт С++
12457 / 7481 / 1753
Регистрация: 25.07.2009
Сообщений: 13,759
20.06.2012, 04:14 3
soon, FIFO (First In First Out) - это очередь, а не стек.
C
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99

#include <stdio.h>
#include <stdlib.h>
 
typedef struct NODE {
    int value;
    struct NODE * next;
} node_t;
 
typedef struct QUEUE {
    node_t * first;
    node_t * last;
} queue_t;
 
queue_t * new_queue(void) {
    queue_t * q = malloc(sizeof(queue_t));
    if ( ! q )
        return NULL;
    
    q->first = q->last = NULL;
    
    return q;
}
 
void del_queue(queue_t * q) {
    while ( q->first ) {
        q->last = q->first->next;
        free(q->first);
        q->first = q->last;
    }
    
    free(q);
}
 
int push(queue_t * q, int v) {
    node_t * n = malloc(sizeof(node_t));
    if ( ! n )
        return -1;
    
    n->value = v;
    n->next = NULL;
    
    if ( ! q->first )
        q->first = n;
    else
        q->last->next = n;
    q->last = n;
    
    return 0;
}
 
int shift(queue_t * q, int * pv) {
    if ( q->first ) {
        node_t * n = q->first->next;
        *pv = q->first->value;
        free(q->first);
        q->first = n;
        
        return 0;
    }
    else
        return -1;
}
 
int main(void) {
    int i;
    queue_t * q;
    
    if ( ! ( q = new_queue() ) ) {
        fprintf(stderr, "Memory error!\n");
        exit(1);
    }
    
    for ( i = 1; i < 6; ++i ) {
        if ( push(q, i) ) {
            fprintf(stderr, "Memory error!\n");
            del_queue(q);
            exit(1);
        }
    }
    
    while ( ! shift(q, &i) )
        printf("%d ", i);
    
    for ( i = 6; i < 11; ++i ) {
        if ( push(q, i) ) {
            fprintf(stderr, "Memory error!\n");
            del_queue(q);
            exit(1);
        }
    }
    
    while ( ! shift(q, &i) )
        printf("%d ", i);
        
    del_queue(q);
    printf("\n");
    
    exit(0);
}
1
Эксперт С++
5043 / 2622 / 241
Регистрация: 07.10.2009
Сообщений: 4,310
Записей в блоге: 1
20.06.2012, 14:46 4
Цитата Сообщение от CRonaldo7 Посмотреть сообщение
класс
Вам на C++ что ли?
0
2554 / 1319 / 178
Регистрация: 09.05.2011
Сообщений: 3,086
Записей в блоге: 1
20.06.2012, 19:58 5
easybudda, точно, спасибо. Перепутал на ночь глядя.
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201

#ifndef __QUEUE_HPP__
#define __QUEUE_HPP__
//------------------------------------------------------------------------------
#include <memory>
#include <stdexcept>
#include <cstdlib>
//------------------------------------------------------------------------------
template <class T>
class Queue
{
    //--------------------------------------------------------------------------
public:
    using value_type        = T;
    using reference         = T&;
    using const_reference   = const T&;
    using rvalue_reference  = T&&;
    using size_type         = std::size_t;
    //--------------------------------------------------------------------------
    struct _Element
    {
        using _ptr  = std::shared_ptr<_Element>;
        //----------------------------------------------------------------------
        T data;
        _ptr next;
        //----------------------------------------------------------------------
        explicit _Element(const_reference d, const _ptr& e = nullptr)
            : data(d), next(e)
        {
 
        }
        //----------------------------------------------------------------------
        explicit _Element(rvalue_reference d, const _ptr& e = nullptr)
            : data(d), next(e)
        {
 
        }
        //----------------------------------------------------------------------
    };
    //--------------------------------------------------------------------------
    using _E        = _Element;
    using _E_ptr    = typename _Element::_ptr;
    //--------------------------------------------------------------------------
private:
    _E_ptr      _front;
    _E_ptr      _back;
    size_type   _size;
    //--------------------------------------------------------------------------
    void _clear()
    {
        while(_front)
        {
            _back = _front -> next;
            _front.reset();
            _front = _back;
        }
        _size = 0;
    }
    //--------------------------------------------------------------------------
public:
    Queue(): _front(nullptr), _back(nullptr), _size(0)
    {
 
    }
    //--------------------------------------------------------------------------
    Queue(const Queue& q): Queue()
    {
        _size = q._size;
        _E_ptr p = q._front;
        while(p)
        {
            push(p -> data);
            p = p -> next;
        }
    }
    //--------------------------------------------------------------------------
    Queue(Queue&& q): Queue()
    {
        _size = q._size;
        _E_ptr p = q._front;
        while(p)
        {
            push(p -> data);
            p = p -> next;
        }
    }
    //--------------------------------------------------------------------------
    ~Queue()
    {
        _clear();
    }
    //--------------------------------------------------------------------------
    Queue& operator=(const Queue& q)
    {
        if(this != &q)
        {
            _clear();
            _E_ptr p = q._front;
            while(p)
            {
                push(p -> data);
                p = p -> next;
            }
            _size = q._size;
        }
        return *this;
    }
    //--------------------------------------------------------------------------
    Queue& operator=(Queue&& q)
    {
        if(this != &q)
        {
            _clear();
            _E_ptr p = q._front;
            while(p)
            {
                push(p -> data);
                p = p -> next;
            }
            _size = q._size;
        }
        return *this;
    }
    //--------------------------------------------------------------------------
    void push(const_reference ref)
    {
        _E_ptr n = std::make_shared<_E>(ref);
        if(!_front)
            _front = n;
        else
            _back -> next = n;
        _back = n;
    }
    //--------------------------------------------------------------------------
    void push(rvalue_reference ref)
    {
        _E_ptr n = std::make_shared<_E>(ref);
        if(!_front)
            _front = n;
        else
            _back -> next = n;
        _back = n;
    }
    //--------------------------------------------------------------------------
    void pop()
    {
        if(_front)
        {
            _E_ptr tmp = _front -> next;
            _front.reset();
            _front = tmp;
            --_size;
        }
        else
            throw std::length_error("No element in queue");
    }
    //--------------------------------------------------------------------------
    reference front()
    {
        if(_front)
            return _front -> data;
        else
            throw std::length_error("No element in queue");
    }
    //--------------------------------------------------------------------------
    const_reference front()                                             const
    {
        if(_front)
            return _front -> data;
        else
            throw std::length_error("No element in queue");
    }
    //--------------------------------------------------------------------------
    reference back()
    {
        if(_back)
            return _back -> data;
        else
            throw std::length_error("No element in queue");
    }
    //--------------------------------------------------------------------------
    const_reference back()                                              const
    {
        if(_back)
            return _back -> data;
        else
            throw std::length_error("No element in queue");
    }
    //--------------------------------------------------------------------------
    const bool empty()                                                  const
    {
        return _front == nullptr;
    }
    //--------------------------------------------------------------------------
    const size_type size()                                              const
    {
        return _size;
    }
    //--------------------------------------------------------------------------
};
//------------------------------------------------------------------------------
#endif /*__QUEUE_HPP__*/
1
20.06.2012, 19:58
IT_Exp
Эксперт
87844 / 49110 / 22898
Регистрация: 17.06.2006
Сообщений: 92,604
 20.06.2012, 19:58
Помогаю со студенческими работами здесь

Параллельные процессы read и write в работе с FIFO
Здравствуйте. В порядке самостоятельного изучения языка написал программку: #include...

Com и fifo
Всем доброго дня! Возникла проблема с приемом данных по com. Мне необходимо принять 1 байт данных...

СИ Fifo
Создайте 2 приложения: клиент и сервер. Клиент обращается к серверу, передавая путь к некоторой...

Очередь FIFO
Добрый вечер. Задали написать реализацию очереди FIFO. Загвоздка в том, как передать указание на...


Искать еще темы с ответами

Или воспользуйтесь поиском по форуму:
5
Ответ Создать тему
КиберФорум - форум программистов, компьютерный форум, программирование
Поддержать - Реклама - Обратная связь
Powered by vBulletin
Copyright ©2000 - 2024, CyberForum.ru