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

Реализовать двунаправленный список в духе списка из STL - C++

Восстановить пароль Регистрация
Другие темы раздела
C++ порядок в выражении http://www.cyberforum.ru/cpp-beginners/thread241378.html
a.x < b.x || a.x == b.x && a.y < b.y как это понять: как (a.x < b.x || a.x == b.x) && a.y < b.y или a.x < b.x || (a.x == b.x && a.y < b.y) Можно ли это заменить a.x <= b.x && a.y < b.y ?
C++ Перегрузка операторов >>, << Помогите перегрузить операторы ввода и вывода в классе Time. (Я совсем-совсем новичек...)Заранее всем спасибо.class Time { friend ostream &operator<<(ostream &, const Time &); friend istream &operator>>(istream& , Time &); private: int hour; int minute; public: Time(int hour = 0, int minute = 0, int second = 0 ); void setTime(int, int, int); http://www.cyberforum.ru/cpp-beginners/thread241375.html
меню сортировок C++
Первый case работает хорошо.а два последних не хотят... #include<iostream> #include<ctime> using namespace std; void main() { srand(time(0)); setlocale(0,"rus"); cout<<" Вариант a - для сортировки вставкой \n"; cout<<" Вариант b - для сортировки выбором \n";
птички C++
на дереве сидит n(0<n<1000000)птичек .они по очереди поют натуральные цифра,начиная 1-го.во время каждой следующей песни улетает то количество птичек,какое число они поют.если количество оставшихся птичек меньше того числа которого должны птички спет ,песня начинается сначала. сколько времени продлится песня птичек,если нато что спет одну цифру нужно одна секунда и улетают они мгновенно ?
C++ Поскорее бы. http://www.cyberforum.ru/cpp-beginners/thread241345.html
Точно условие не помню но суть в том что вводится с клавы логическое выражение. например А и Б и (В или С) только или, и и остальные условия тоже буквы. Надо решить выражение. Это на стэки и строки по моему. Просьба объяснить текст который напишите. Ну хоть написать какая буква что означает. И надо примитивно. по крайней мере желательно) Программа на С++!!!!!!
C++ Класс "Окружность" с данными центр и радиус окружности. Вычислить длину и площадь окружности. Объявить класс и определить для него конструктор по умолчанию, конструктор инициализации. Определить функции-члены класса для ввода и вывода членов-данных внутри объявления класса, функции расчета. Составить программу, которая определяет три объекта класса и выводит их на экран. Первый объект должен инициализироваться по умолчанию, второй использовать конструктор инициализации, третий функцию... подробнее

Показать сообщение отдельно
volovzi
266 / 168 / 8
Регистрация: 14.03.2010
Сообщений: 501
14.02.2011, 19:24     Реализовать двунаправленный список в духе списка из STL
3. В стандартном, как раз, как у тебя . Просто мне кажется, что это нерационально.
4. См. пример.
5. Можно и оставить, просто если ты будешь передавать список куда-то в алгоритм, который не предназначен для списка, то он может работать неопределённое время.

Вот мой пример. Erase(iter, iter) у меня нестандартный, а вот swap и стандартный, и правильный.
list<T>

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
template <typename Value>
class list {
 
// ---- Определения -------------------------------------------------------------------------------
 
public:
    typedef Value value_type;
 
// ---- Узел списка -------------------------------------------------------------------------------
 
private:
    struct node {
        explicit node (const value_type & value) : value(value), next(0), previous(0) {}
        ~node () { delete next; }
    
        value_type value;
        
        node * next;
        node * previous;
    };
 
// ---- Итераторы ---------------------------------------------------------------------------------
 
public:
    struct iterator {
        iterator () : current(0), next(0), previous(0) {}
        explicit iterator (node * n) : current(n), next(n->next), previous(n->previous) {}
        
        value_type & operator * () { return current->value; }
        value_type * const operator -> () { return &current->value; }
        
        iterator & operator ++ () { return *this = iterator(next); }
        iterator & operator -- () { return *this = iterator(previous); }
        
        iterator operator ++ (int) {
            iterator result = *this;
            
            *this = iterator(next);
            
            return result;
        }
        
        iterator operator -- (int) {
            iterator result = *this;
            
            *this = iterator(previous);
            
            return result;
        }
        
        bool operator == (const iterator & i) const { return current == i.current; }
        bool operator != (const iterator & i) const { return current != i.current; }
    
        node * current;
        node * next;
        node * previous;
    };
    
    struct const_iterator {
        const_iterator () : current(0), next(0), previous(0) {}
        explicit const_iterator (node * n) : current(n), next(n->next), previous(n->previous) {}
        
        const value_type & operator * () const { return current->value; }
        const value_type * const operator -> () const { return &current->value; }
        
        const_iterator & operator ++ () { return *this = const_iterator(next); }
        const_iterator & operator -- () { return *this = const_iterator(previous); }
        
        const_iterator operator ++ (int) {
            const_iterator result = *this;
            
            *this = const_iterator(next);
            
            return result;
        }
        
        const_iterator operator -- (int) {
            const_iterator result = *this;
            
            *this = const_iterator(previous);
            
            return result;
        }
        
        bool operator == (const const_iterator & i) const { return current == i.current; }
        bool operator != (const const_iterator & i) const { return current != i.current; }
    
        node * current;
        node * next;
        node * previous;
    };
 
// ---- Создание и уничтожение --------------------------------------------------------------------
    
public:
    list () : m_last(new node(value_type())), m_size(0) { m_last->previous = m_last->next = m_last; }
    
    explicit list (int size, const value_type & value = value_type()) : m_last(new node(value_type())), m_size(0) {
        m_last->previous = m_last->next = m_last;
        
        for (size_t i = 0; i < size; ++i) push_back(value);
    }
    
    template <typename InputIterator>
    list (InputIterator first, InputIterator last) : m_last(new node(value_type())), m_size(0) {
        m_last->previous = m_last->next = m_last;
        
        while (first != last) push_back(*first++);
    }
 
    ~list () {
        m_last->previous->next = 0;
        
        delete m_last;
    }
 
// ---- Модификации -------------------------------------------------------------------------------
 
public:
    iterator insert (iterator position, const value_type & value) {
        node * new_node = new node(value);
        node * current_node = position.current;
        
        new_node->next = current_node->next;
        new_node->previous = current_node;
        
        current_node->next->previous = new_node;
        current_node->next = new_node;
        
        ++m_size;
        
        return iterator(new_node);
    }
    
    iterator erase (iterator position) {
        node * node_to_delete = position.current;
        
        node_to_delete->previous->next = node_to_delete->next;
        node_to_delete->next->previous = node_to_delete->previous;
        
        node * result = node_to_delete->next;
        
        node_to_delete->next = 0;
        delete node_to_delete;
        
        --m_size;
        
        return iterator(result);
    }
    
    iterator erase (iterator first, iterator last) {
        for (iterator i = first; i != last; ++i) --m_size;
    
        node * to_delete = first.current;
        node * not_to_delete = last.current;
        
        to_delete->previous->next = not_to_delete;
        
        not_to_delete->previous->next = 0;
        not_to_delete->previous = to_delete->previous;
        
        delete to_delete;
        
        return iterator(not_to_delete);
    }
    
    void push_back (const value_type & value) { insert(--end(), value); }
    void push_front (const value_type & value) { insert(end(), value); }
    
    void pop_back () { erase(--end()); }
    void pop_front () { erase(++end()); }
    
    void swap (list & l) {
        std::swap(m_last, l.m_last);
        std::swap(m_size, l.m_size);
    }
    
    void clear () {
        m_last->previous->next = 0;
        delete m_last->next;
        
        m_last->previous = m_last->next = m_last;
        m_size = 0;
    }
    
// ---- Доступ к элементам ------------------------------------------------------------------------
 
public:
    value_type & front () { return m_last->next->value; }
    const value_type & front () const { return m_last->next->value; }
    
    value_type & back () { return m_last->previous->value; }
    const value_type & back () const { return m_last->previous->value; }
 
// ---- Последовательный доступ -------------------------------------------------------------------
 
public:
    iterator begin () { return ++iterator(m_last); }
    const_iterator begin () const { return ++const_iterator(m_last); }
    
    iterator end () { return iterator(m_last); }
    const_iterator end () const { return const_iterator(m_last); }
 
// ---- Информация --------------------------------------------------------------------------------
    
public:
    bool is_empty () const { return m_size == 0; }
    int size () const { return m_size; }
 
// ---- Переменные --------------------------------------------------------------------------------
    
private:
    node * m_last;
    
    int m_size;
};
 
Текущее время: 16:10. Часовой пояс GMT +3.
КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2016, vBulletin Solutions, Inc.
Рейтинг@Mail.ru