Форум программистов, компьютерный форум CyberForum.ru

Динамический список динамических списков - C++

Восстановить пароль Регистрация
Другие темы раздела
C++ Односвязный список. Поменять местами элементы http://www.cyberforum.ru/cpp-beginners/thread310460.html
Привет. Есть односвязный список. Например: 5 элементов, поменять местами 2 и 3 Как поменять местами элементы p1 и p2. Что я сделал? нашел позиции этих p1 и p2 через циклы. Как поменять? Я думаю, что нужно поменять указатели, как конкретно их поменять? Что на что должно указывать? Напишите кодом, пожалуйста. void list::change(int first,int last) { nodes *p1 = new nodes;
C++ Возврат значения по ссылке Долго гуглил, но что-то так и не понял. Почему слева от знака = может использоваться только функция, возвращающая ссылку? http://www.cyberforum.ru/cpp-beginners/thread310451.html
Осуществить движение окружности по дуге C++
Условие: Осуществить такое движение,при котором окружность движется по-другой окружности,Оставаясь внутри ее. 1е) Я понимаю что таких как мы много и как мы достали нормальных людей 2е) Я не хочу орать :"помогите иначе мне хана и тп." Я понимаю что таких же о5 тут много 3е) Я понимаю что программисты коих здесь я думаю обитает не мало ленивые люди( не как сам человек,а как рабочий) ибо все...
C++ Посмотрите код пожалуйста...
#include <stdio.h> #include <stdlib.h> int main() { int n,*b,i,k; double x; float **M;// двухмерная матрциа
C++ Построение многоугольника http://www.cyberforum.ru/cpp-beginners/thread310428.html
На клетчатой бумаге нарисован многоугольник, стороны которого по линиям сетки.В каждую клеточку многоугольника вписано число равное количеству сторон данной клетки, которые принадлежат сторонам многоугольника.Многоугольник стерается,и на листке остаются только числа.Восстановить многоугольник.
C++ Массив Подскажите, что не так делаю: #include <iostream> using namespace std; int main () { int n, m, i, j, k, n1, m1; float mas_U; подробнее

Показать сообщение отдельно
viktorrrr
42 / 42 / 1
Регистрация: 11.02.2010
Сообщений: 358
01.06.2011, 22:28     Динамический список динамических списков
Всем экспертам привет. Нужна категорическая помощь). Задача такая, надо разобраться как работает этот код(Заголовочный файл). Комментарии написать. Самому толку не хватает. А уж потом в main() я бы уже сам как-нить засунул. Помогите, пожалуйста

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
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
#ifndef _UTIL_LIST_H_
#define _UTIL_LIST_H_
 
namespace Core {
 
class EList {
public:
    class Node;
    class IteratorBase;
    class ConstIterator;
    class Iterator;
 
    class Node {
        friend class EList;
        friend class IteratorBase;
 
        Node* next;
        Node* prev;
 
        Node(Node* self) : next(self), prev(self) {}
 
        Node* insert_before(Node* n);
        Node* insert_after(Node* n);
 
        Node* insert_before(EList&);
        Node* insert_after(EList&);
 
    public:
        Node() : next(0), prev(0) {}
        ~Node() { remove_from_list(); }
 
        Node* remove_from_list();
        bool is_in_list() const { return next!=0; }
    };
 
    class IteratorBase {
        typedef IteratorBase self_t;
    protected:
        Node* m_node;
 
        IteratorBase(Node* n) : m_node(n) {}
 
        self_t& inc() { m_node = m_node->next; return *this; }
        self_t& dec() { m_node = m_node->prev; return *this; }
 
        bool eq(const self_t& i) const { return m_node==i.m_node; }
        bool ne(const self_t& i) const { return m_node!=i.m_node; }
 
        Node* insert_before(Node* n) { return m_node->insert_before(n); }
        Node* insert_after(Node* n) { return m_node->insert_after(n); }
 
        Node* insert_before(EList& d) { return m_node->insert_before(d); }
        Node* insert_after(EList& d) { return m_node->insert_after(d); }
 
        Node* do_remove() { return m_node->remove_from_list(); }
    };
 
    class ConstIterator : public IteratorBase {
        typedef IteratorBase base_t;
        typedef ConstIterator self_t;
    public:
        ConstIterator(const Node* n) : base_t(const_cast<Node*>(n)) {}
 
        Node* node() const { return m_node; }
        const Node* operator->() const { return m_node; }
 
        self_t& operator++() { return static_cast<self_t&>(base_t::inc()); }
        self_t& operator--() { return static_cast<self_t&>(base_t::dec()); }
 
        bool operator == (const self_t& i) const { return base_t::eq(i); }
        bool operator != (const self_t& i) const { return base_t::ne(i); }
    };
 
    class Iterator : public ConstIterator {
        typedef ConstIterator base_t;
        typedef Iterator self_t;
    public:
        Iterator(Node* n) : base_t(n) {}
 
        Node* operator->() const { return m_node; }
 
        self_t& operator++() { return static_cast<self_t&>(base_t::inc()); }
        self_t& operator--() { return static_cast<self_t&>(base_t::dec()); }
 
        Iterator insert_before(Node* n) { return base_t::insert_before(n); }
        Iterator insert_after(Node* n) { return base_t::insert_after(n); }
 
        Iterator insert_before(EList& d) { return base_t::insert_before(d); }
        Iterator insert_after(EList& d) { return base_t::insert_after(d); }
 
        Node* remove() { return base_t::do_remove(); }
    };
 
    friend class Node;
 
    bool empty() const { return m_list.next == &m_list; }
 
    ConstIterator front() const { return m_list.next; }
    ConstIterator end() const { return &m_list; }
    ConstIterator back() const { return m_list.prev; }
 
    Iterator front() { return m_list.next; }
    Iterator end() { return &m_list; }
    Iterator back() { return m_list.prev; }
 
    Iterator push_front(Node* n) { return front().insert_before(n); }
    Iterator push_back(Node* n) { return back().insert_after(n); }
    Node* pop_front() { return front().remove(); }
    Node* pop_back() { return back().remove(); }
 
    void clear() { Iterator i=front(); while( i!=end() ) { Iterator e = i; ++i; e.remove(); } }
 
protected:
    EList() : m_list(&m_list) {}
    ~EList() { clear(); }
 
    Node m_list;
 
    void reset() { m_list.next = &m_list; m_list.prev = &m_list; }
};
 
 
inline
EList::Node* EList::Node::remove_from_list()
{
    if( next ) {
        next->prev = prev;
        prev->next = next;
        next = 0;
        prev = 0;
    }
    return this;
}
 
 
inline
EList::Node* EList::Node::insert_before(Node* n)
{
    if( n->next == 0 )
    {
        n->next = this;
        n->prev = prev;
        prev->next = n;
        prev = n;
    }
    return this->prev;
}
 
inline
EList::Node* EList::Node::insert_after(Node* n)
{
    if( n->next == 0 )
    {
        n->next = next;
        n->prev = this;
        next->prev = n;
        next = n;
    }
    return next;
}
 
 
inline
EList::Node* EList::Node::insert_before(EList& list)
{
    if( !list.empty() )
    {
        Node* head = list.m_list.next;
        Node* tail = list.m_list.prev;
        head->prev = prev;
        prev->next = head;
        tail->next = this;
        this->prev = tail;
        list.reset();
        return head;
    }
    return this;
}
 
inline
EList::Node* EList::Node::insert_after(EList& list)
{
    if( !list.empty() )
    {
        Node* head = list.m_list.next;
        Node* tail = list.m_list.prev;
        tail->next = next;
        next->prev = tail;
        head->prev = this;
        this->next = head;
        list.reset();
        return head;
    }
    return next;
}
 
 
 
template<class T>
class EListOf : private EList {
    typedef EList base_t;
public:
    class ConstIterator;
    class Iterator;
 
    friend class ConstIterator;
    friend class Iterator;
 
    class ConstIterator : protected EList::IteratorBase {
        friend class EListOf<T>;
        typedef EList::IteratorBase base_t;
        typedef ConstIterator self_t;
    protected:
        ConstIterator(const EList::IteratorBase& i) : base_t(i) {}
    public:
        ConstIterator(const T* n) : base_t(const_cast<T*>(n)) {}
 
        const T& operator*() const { return *static_cast<const T*>(m_node); }
        const T* operator->() const { return static_cast<const T*>(m_node); }
        self_t& operator++() { return static_cast<self_t&>(base_t::inc()); }
        self_t& operator--() { return static_cast<self_t&>(base_t::dec()); }
 
        bool operator==(const ConstIterator& i) { return base_t::eq(i);}
        bool operator!=(const ConstIterator& i) { return base_t::ne(i);}
    };
 
    class Iterator : public ConstIterator {
        friend class EListOf<T>;
        typedef ConstIterator base_t;
        typedef Iterator self_t;
 
        Iterator(const EList::IteratorBase& i) : base_t(i) {}
    public:
        Iterator(T* n) : base_t(n) {}
 
        T& operator*() const { return *static_cast<T*>(m_node); }
        T* operator->() const { return static_cast<T*>(m_node); }
        self_t& operator++() { return static_cast<self_t&>(base_t::inc()); }
        self_t& operator--() { return static_cast<self_t&>(base_t::dec()); }
 
        self_t insert_before(T* n) { return static_cast<T*>(base_t::insert_before(n)); }
        self_t insert_after(T* n) { return static_cast<T*>(base_t::insert_after(n)); }
 
        self_t insert_before(EListOf<T>& d) { return static_cast<T*>(base_t::insert_before(d)); }
        self_t insert_after(EListOf<T>& d) { return static_cast<T*>(base_t::insert_after(d)); }
 
        T* remove() { return static_cast<T*>(base_t::do_remove()); }
    };
 
    EListOf() {}
    ~EListOf() {}
 
    using EList::empty;
    using EList::clear;
 
    ConstIterator front() const { return base_t::front(); }
    ConstIterator end() const { return base_t::end(); }
    ConstIterator back() const { return base_t::back(); }
 
    Iterator front() { return base_t::front(); }
    Iterator end() { return base_t::end(); }
    Iterator back() { return base_t::back(); }
 
    Iterator push_front(T* n) { return front().insert_before(n); }
    Iterator push_back(T* n) { return back().insert_after(n); }
    T* pop_front() { return front().remove(); }
    T* pop_back() { return back().remove(); }
 
};
 
 
}
 
#endif
После регистрации реклама в сообщениях будет скрыта и будут доступны все возможности форума.
 
Текущее время: 13:59. Часовой пояс GMT +3.
КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2016, vBulletin Solutions, Inc.
Рейтинг@Mail.ru