лёгкая STL библиотека

Мне нужна лёгкая библиотека стандартных шаблонов. Будет использоваться в микроконтроллере, так что места там не особо много, да и с быстродействием напряг. В Keil как-то она как-то косячно реализована. Мне нужны только списки и указатели. Keil добавляет сразу 30Кб со всеми функциями ввода-вывода и пр. Так что хотелось бы что-нибудь стороннее. Должны ведь быть какие-нибудь GNU, GPL или ещё что-нибудь в этом духе.

 

проще взять любую "тяжелую" и отпилить всю ненужную функциональность

 

GoldFinch не думаю, что именно проще. Скорее, лёгкую просто не найти. Главное, чтобы библиотека не была привязана всякими #pragma import и прочими платформенно зависимыми конструкциями к компилятору и железу.

 

cupuyc

STLPort?

 

Если нужны только списки и указатели, то можно выдернуть их из любой реализации STL и адаптировать для своих нужд.
Мы так работали, остались довольны.

 

_DEN_, из STLPort, по ходу дела, придётся выковыривать код.

Прошу прощения, но я не понимаю, зачем так усложнять библиотеку шаблонов? Почему для каждого класса нельзя сделать свой отдельный хидер с кодом. Кода получается не так уж и много. Берёшь любую библиотеку - там всё завязано на директивах препроцессора, что сходу даже и не разберёшься. Вот, слил STLPort - прописал путь в проекте к папке с библиотекой - не компилится. Т.е. нужно эту библиотеку устанавливать, что мне делать совсем не хочется.

 

это уже буст =)

 

Ещё одна вещь расстраивает. Вот слил palmstl. Вроде, то, что нужно. Ничего лишнего. Добавил в проект - куча ошибок. Видать, на VC вообще не собирается.

 

cupuyc

Скорее всего дело в том, что STL является очень performance critical во всех отношениях, и его стараются выдрочить блеска, в том числе и platform-dependent твиками.

 

облегчённый двусвязный список.

Код (Text):

1. /*
2. * C L i s t
3. */
4.  
5. template <typename t_base_element>
6. class CList
7. {
8. private:
9.   struct ListElement
10.   {
11.     t_base_element element;
12.     ListElement *p_next;
13.     ListElement *p_prev;
14.   };
15.  
16. public:
17.   class iterator
18.   {
19.   private:
20.     ListElement *m_p_current;
21.  
22.   private:
23.     friend class CList;
24.  
25.   private:
26.     inline iterator(ListElement* begin)
27.     {
28.       m_p_current = begin;
29.     }
30.  
31.   public:
32.     inline iterator(iterator& from)
33.     {
34.       m_p_current = from.m_p_current;
35.     }
36.  
37.     inline void operator ++ (int)
38.     {
39.       m_p_current = m_p_current->p_next;
40.     }
41.  
42.     inline void operator -- (int)
43.     {
44.       m_p_current = m_p_current->p_prev;
45.     }
46.  
47.     inline t_base_element& operator *() const
48.     {
49.       return m_p_current->element;
50.     }
51.  
52.     inline bool is_end() const
53.     {
54.       return m_p_current == 0;
55.     }
56.   };
57.  
58. protected:
59.   ListElement *m_p_first;
60.   ListElement *m_p_last;
61.  
62. public:
63.   CList()
64.   {
65.     m_p_first = 0;
66.     m_p_last = 0;
67.   }
68.  
69.   ~CList()
70.   {
71.   }
72.  
73.   t_base_element& push_back()
74.   {
75.     ListElement *new_element = new ListElement;
76.     new_element->p_next = 0;
77.     new_element->p_prev = m_p_last;
78.  
79.     if (m_p_last)
80.       m_p_last->p_next = new_element;
81.     else
82.       m_p_first = new_element;
83.  
84.     m_p_last = new_element;
85.     return m_p_last->element;
86.   }
87.  
88.   t_base_element& push_front()
89.   {
90.     ListElement *new_element = new ListElement;
91.     new_element->p_prev = 0;
92.     new_element->p_next = m_p_first;
93.  
94.     if (m_p_first)
95.       m_p_first->p_prev = new_element;
96.     else
97.       m_p_last = new_element;
98.  
99.     m_p_first = new_element;
100.     return m_p_first->element;
101.   }
102.  
103.   t_base_element& push_back(const t_base_element& element)
104.   {
105.     ListElement *new_element = new ListElement;
106.     new_element->p_next = 0;
107.     new_element->p_prev = m_p_last;
108.     new_element->element = element;
109.  
110.     if (m_p_last)
111.       m_p_last->p_next = new_element;
112.     else
113.       m_p_first = new_element;
114.  
115.     m_p_last = new_element;
116.     return m_p_last->element;
117.   }
118.  
119.   t_base_element& push_front(const t_base_element& element)
120.   {
121.     ListElement *new_element = new ListElement;
122.     new_element->p_prev = 0;
123.     new_element->p_next = m_p_first;
124.     new_element->element = element;
125.  
126.     if (m_p_first)
127.       m_p_first->p_prev = new_element;
128.     else
129.       m_p_last = new_element;
130.  
131.     m_p_first = new_element;
132.     return m_p_first->element;
133.   }
134.  
135.   void clear()
136.   {
137.     for (iterator &i = first(); !i.is_end(); )
138.     {
139.       i = remove(i);
140.     }
141.   }
142.  
143.   iterator remove(iterator& index)
144.   {
145.     if (index.m_p_current == m_p_first)
146.     {
147.       m_p_first = m_p_first->p_next;
148.       delete index.m_p_current;
149.  
150.       if (m_p_first == 0)
151.         m_p_last = 0;
152.       else
153.         m_p_first->p_prev = 0;
154.  
155.       return first();
156.     }
157.  
158.     if (index.m_p_current == m_p_last)
159.     {
160.       m_p_last = m_p_last->p_prev;
161.       m_p_last->p_next = 0;
162.       delete index.m_p_current;
163.  
164.       return last();
165.     }
166.  
167.     iterator res = index;
168.     ++ res;
169.  
170.     index.m_p_current->p_prev->p_next = index.m_p_current->p_next;
171.     index.m_p_current->p_next->p_prev = index.m_p_current->p_prev;
172.  
173.     delete index.m_p_current;
174.  
175.     return res;
176.   }
177.  
178.   inline iterator first() const
179.   {
180.     return iterator(m_p_first);
181.   }
182.  
183.   inline iterator last() const
184.   {
185.     return iterator(m_p_last);
186.   }
187. };

 

автоуказатель.

Код (Text):

1. #ifndef __auto_ptr__h__
2. #define __auto_ptr__h__
3.  
4. /*
5. * C A u t o P t r
6. */
7.  
8. template <typename t_base>
9. class CAutoPtr
10. {
11. private:
12.   t_base *m_p;
13.  
14. public:
15.   CAutoPtr()
16.   {
17.     m_p = 0;
18.   }
19.  
20.   CAutoPtr(CAutoPtr<t_base> &ptr)
21.   {
22.     m_p = ptr.detach();
23.   }
24.  
25.   CAutoPtr(t_base *p)
26.   {
27.     m_p = p;
28.   }
29.  
30.   ~CAutoPtr()  
31.   {
32.     free();
33.   }
34.  
35.   void free()
36.   {
37.     if (m_p != 0)
38.       delete m_p;
39.  
40.     m_p = 0;
41.   }
42.  
43.   void attach(t_base *p)
44.   {
45.     if (m_p != 0)
46.       throw new CError(ecMemoryLeaks);
47.      
48.     m_p = p;
49.   }
50.  
51.   t_base* detach()
52.   {
53.     t_base* p = m_p;
54.     m_p = 0;
55.     return p;
56.   }
57.  
58.   inline t_base* operator -> () const
59.   {
60.     return m_p;
61.   }
62.  
63.   CAutoPtr<t_base>& operator = (CAutoPtr<t_base>& ptr)
64.   {
65.     if (m_p == ptr.m_p)
66.     {
67.       throw new CError(ecInvalidArgument);
68.     }
69.  
70.     free();
71.     attach(ptr.detach());
72.  
73.     return *this;
74.   }
75.  
76.   inline operator t_base* () const
77.   {
78.     return m_p;
79.   }
80. };
81.  
82. #endif // __auto_ptr__h__

 

cupuyc

эээ што?

 

STLPort навороченная поскольку поддерживает разные бажные борланды. Для твоих нужд наверно хватит оригинальной HP STL

 

inline operator t_base* () const

То есть можно неявно сохранить указатель, std::auto_ptr не имеет такой проблемы, поэтому я бы рекомендовал использовать проверенный дизайн вместо велосипеда. Еще лучше unique_ptr, его можно хранить в std::list.

 

J0E, я срисовывал с ATL.

 

Семантика авто поинтера это обеспечивать управление памятью за счет монопольного владения объекта. Неужали буквы ATL как-то защищают от возможных ошибок?

 

J0E, хм.. неужели буквы буквы STL как-то защищают от возможных ошибок? )

 

cupuyc

STL разрабатывают самые светлые умы планеты, а ATL - не обремененный вселенской гармонией Microsoft.

 

Во первых, в std::auto_ptr приведение к голому указателю делается явно вызовом get(), или release() поэтому случайной ошибки быть не может по дизайну, название не играет роли.
Во вторых, количество пользователей STL несравнимо больше ATL, что позволило выявить проблемы и у auto_ptr, поэтому его апгрейдили до unique_ptr.
В третих.... а в третьих итераторы ATL lits не совместимы с алгоритмами STL !!!111 то есть придется писать новый код вместо готового )

 

J0E, _DEN_, я ведь не спорю, что взять готовую STL библиотеку - идеальный вариант. Другое дело, что мне нужно 500 строк кода, а чтобы выдрать их из STLPort нужно потратить больше времени, чем написать.