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

Стек на шаблонах - оцените реализацию - C++

Восстановить пароль Регистрация
Другие темы раздела
C++ Композиция и иерархия: класс "комната", "квартира" http://www.cyberforum.ru/cpp-beginners/thread1228389.html
(Композиция и иерархия). Создать класс комната, имеющая площадь. Определить конструктор и метод доступа. Создать класс однокомнатная квартира, содержащий комнату и кухню (их площадь), этаж (комната содержится в классе однокомнатная квартира). Определить конструкторы, методы доступа. Определить public-производный класс однокомнатных квартир разных городов (дополнительный параметр – название...
C++ Иерархия: класс "карта", "колода карт" (Иерархия). Создать класс карта, имеющая ранг и масть. Карту можно перевернуть и открыть. Создать класс – колода карт, содержащий карты. Создать два производных класса от колоды карт, в одном карты могут доставаться только по порядку, в другом - вытаскиваться произвольно http://www.cyberforum.ru/cpp-beginners/thread1228388.html
Написать функцию, которая сравнивает два целых числа C++
Написать функцию, которая сравнивает два целых числа и возвращает результат сравнения в виде одного из знаков: < > или =. Это код второй, но не доделал: char f(int a, int b) { if (a>b)return '>'; if (a<b)return '<'; return '='; }
C++ Выделение памяти в куче для строки для реализации длинной арифметики
Доброго времени суток, пишу класс string, на основе которого потом хочу реализовать класс для длинной арифметики. Поэтому мне понадобился такой конструктор: // constructor by integer string::string( const int number, const int base ) { char * buffer = (char *)realloc(NULL, sizeof(char)*sizeof(int)+5); _itoa(number, buffer, base ); length = strlen(buffer); takeMemory( NULL, length );...
C++ В какой последовательности выполняются действия вычисления ошибки исходя из кода http://www.cyberforum.ru/cpp-beginners/thread1228333.html
// A program to implement a calculator accepting parentheses #include <iostream> // For stream input/output #include <cstdlib> // For the exit() function #include <cctype> // For the isdigit() function #include <cstring> // For the strcpy() function using std::cin; using std::cout; using std::endl;
C++ Ошибки линковки при использовании шаблонного класса Есть заголовочной файл Utils.h, в котором определены 2 класса String и ArrayList<T>: class String : public Comparable<String> { private: friend class Object; string data; public: String() {} /**/ ArrayList<String>* split(const String delimiter) const; подробнее

Показать сообщение отдельно
GetHelp
-8 / 60 / 6
Регистрация: 27.02.2013
Сообщений: 1,112
17.07.2014, 19:58  [ТС]     Стек на шаблонах - оцените реализацию
Цитата Сообщение от 0x10 Посмотреть сообщение
Нормальным вариантом кажется посмотреть на реализацию в стандартной библиотеке и сделать по образу и подобию. Для этого не обязательно лезть глубоко, достатоно посмотреть интерфейсы стандартных контейнеров.
хотя бы тыкните пальцем что читать... ибо вот я открыл файл с объявлением этого стандартного стека... и нехрена не могу в нем понять вообще...
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
// stack standard header
#pragma once
#ifndef _STACK_
#define _STACK_
#ifndef RC_INVOKED
#include <deque>
 
 #pragma pack(push,_CRT_PACKING)
 #pragma warning(push,3)
_STD_BEGIN
        // TEMPLATE CLASS stack
template<class _Ty,
    class _Container = deque<_Ty> >
    class stack
    {   // LIFO queue implemented with a container
public:
    typedef stack<_Ty, _Container> _Myt;
    typedef _Container container_type;
    typedef typename _Container::value_type value_type;
    typedef typename _Container::size_type size_type;
    typedef typename _Container::reference reference;
    typedef typename _Container::const_reference const_reference;
 
    stack()
        : c()
        {   // construct with empty container
        }
 
    stack(const _Myt& _Right)
        : c(_Right.c)
        {   // construct by copying _Right
        }
 
    explicit stack(const _Container& _Cont)
        : c(_Cont)
        {   // construct by copying specified container
        }
 
    _Myt& operator=(const _Myt& _Right)
        {   // assign by copying _Right
        c = _Right.c;
        return (*this);
        }
 
    stack(_Myt&& _Right)
        : c(_STD move(_Right.c))
        {   // construct by moving _Right
        }
 
    explicit stack(_Container&& _Cont)
        : c(_STD move(_Cont))
        {   // construct by copying specified container
        }
 
    _Myt& operator=(_Myt&& _Right)
        {   // assign by moving _Right
        c = _STD move(_Right.c);
        return (*this);
        }
 
    void push(value_type&& _Val)
        {   // insert element at beginning
        c.push_back(_STD move(_Val));
        }
 
    template<class _Valty>
        void emplace(_Valty&& _Val)
        {   // insert element at beginning
        c.emplace_back(_STD forward<_Valty>(_Val));
        }
 
    void swap(_Myt&& _Right)
        {   // exchange contents with movable _Right
        c.swap(_STD move(_Right.c));
        }
 
    bool empty() const
        {   // test if stack is empty
        return (c.empty());
        }
 
    size_type size() const
        {   // test length of stack
        return (c.size());
        }
 
    reference top()
        {   // return last element of mutable stack
        return (c.back());
        }
 
    const_reference top() const
        {   // return last element of nonmutable stack
        return (c.back());
        }
 
    void push(const value_type& _Val)
        {   // insert element at end
        c.push_back(_Val);
        }
 
    void pop()
        {   // erase last element
        c.pop_back();
        }
 
    const _Container& _Get_container() const
        {   // get reference to container
        return (c);
        }
 
    void swap(_Myt& _Right)
        {   // exchange contents with _Right
        c.swap(_Right.c);
        }
 
protected:
    _Container c;   // the underlying container
    };
 
        // stack TEMPLATE FUNCTIONS
template<class _Ty,
    class _Container> inline
    void swap(stack<_Ty, _Container>& _Left,
        stack<_Ty, _Container>& _Right)
    {   // swap _Left and _Right stacks
    _Left.swap(_Right);
    }
 
template<class _Ty,
    class _Container> inline
    void swap(stack<_Ty, _Container>& _Left,
        stack<_Ty, _Container>&& _Right)
    {   // swap _Left and _Right stacks
    typedef stack<_Ty, _Container> _Myt;
    _Left.swap(_STD forward<_Myt>(_Right));
    }
 
template<class _Ty,
    class _Container> inline
    void swap(stack<_Ty, _Container>&& _Left,
        stack<_Ty, _Container>& _Right)
    {   // swap _Left and _Right stacks
    typedef stack<_Ty, _Container> _Myt;
    _Right.swap(_STD forward<_Myt>(_Left));
    }
 
template<class _Ty,
    class _Container> inline
    bool operator==(const stack<_Ty, _Container>& _Left,
        const stack<_Ty, _Container>& _Right)
    {   // test for stack equality
    return (_Left._Get_container() == _Right._Get_container());
    }
 
template<class _Ty,
    class _Container> inline
    bool operator!=(const stack<_Ty, _Container>& _Left,
        const stack<_Ty, _Container>& _Right)
    {   // test for stack inequality
    return (!(_Left == _Right));
    }
 
template<class _Ty,
    class _Container> inline
    bool operator<(const stack<_Ty, _Container>& _Left,
        const stack<_Ty, _Container>& _Right)
    {   // test if _Left < _Right for stacks
    return (_Left._Get_container() < _Right._Get_container());
    }
 
template<class _Ty,
    class _Container> inline
    bool operator>(const stack<_Ty, _Container>& _Left,
        const stack<_Ty, _Container>& _Right)
    {   // test if _Left > _Right for stacks
    return (_Right < _Left);
    }
 
template<class _Ty,
    class _Container> inline
    bool operator<=(const stack<_Ty, _Container>& _Left,
        const stack<_Ty, _Container>& _Right)
    {   // test if _Left <= _Right for stacks
    return (!(_Right < _Left));
    }
 
template<class _Ty,
    class _Container> inline
    bool operator>=(const stack<_Ty, _Container>& _Left,
        const stack<_Ty, _Container>& _Right)
    {   // test if _Left >= _Right for stacks
    return (!(_Left < _Right));
    }
_STD_END
 #pragma warning(pop)
 #pragma pack(pop)
 
#endif /* RC_INVOKED */
#endif /* _STACK_ */
 
/*
 * This file is derived from software bearing the following
 * restrictions:
 *
 * Copyright (c) 1994
 * Hewlett-Packard Company
 *
 * Permission to use, copy, modify, distribute and sell this
 * software and its documentation for any purpose is hereby
 * granted without fee, provided that the above copyright notice
 * appear in all copies and that both that copyright notice and
 * this permission notice appear in supporting documentation.
 * Hewlett-Packard Company makes no representations about the
 * suitability of this software for any purpose. It is provided
 * "as is" without express or implied warranty.
 */
 
/*
 * Copyright (c) 1992-2009 by P.J. Plauger.  ALL RIGHTS RESERVED.
 * Consult your license regarding permissions and restrictions.
V5.20:0009 */
 
Текущее время: 17:48. Часовой пояс GMT +3.
КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2016, vBulletin Solutions, Inc.
Рейтинг@Mail.ru