Форум программистов, компьютерный форум, киберфорум
Наши страницы

Можно ли узнать размер одного элемента в STL контейнере? - C++

Войти
Регистрация
Восстановить пароль
Другие темы раздела
C++ Реализация численного метода решения СЛАУ http://www.cyberforum.ru/cpp-beginners/thread556031.html
Помогите разработать ПО для реализации численного метода простой итерации решения СЛАУ.
C++ Информация о файле Выбрать произвольный формат файлов (avi, bmp, doc, exe, mp3, zip и т.п.) и написать программу, выводящую на экран общую информацию о заданном файле данного формата (размеры картинки, количество... http://www.cyberforum.ru/cpp-beginners/thread556000.html
Не могу понять как написать программу C++
У меня 20 чисел(1-20), программа должна выводить все варианты 5-ти значных чисел, при этом числа не должны повторяться(12345 и 54321).
Вектор и пара C++
Всем привет! В этом куске кода явно есть ошибка (он не компилируется), но я так и не смог её найти: vector<char> d; vector<pair<char ,int> > sw ; int s,t,n,m,t1,t2,u ; char t3; int main() { ...
C++ Как вернуть прежние настройки в Visual Studio 2010? http://www.cyberforum.ru/cpp-beginners/thread555915.html
Здравствуйте. Есть Visual Studio 2010. Когда установил было так: открываю проект, посредине текстовый редактор, внизу окошко где выводятся ошибки/предупреждения, слева окошко где список файлов...
C++ Напечатать все слова, которые встречаются в предложении по одному разу Доброго времени суток! Помогите, пожалуйста, решить задачу: Дано предложение. Напечатать все слова, которые встречаются в нём по одному разу. подробнее

Показать сообщение отдельно
ForEveR
В астрале
Эксперт С++
7983 / 4742 / 321
Регистрация: 24.06.2010
Сообщений: 10,545
Завершенные тесты: 3
24.04.2012, 08:49
fasked, Одного элемента. Не всего контейнера а одного элемента в контейнере. Причем не value_type-а, а по внутренней реализации. Допустим для списка:
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
    struct _List_node_base
    {
      _List_node_base* _M_next;
      _List_node_base* _M_prev;
      
      static void
      swap(_List_node_base& __x, _List_node_base& __y) throw ();
      
      void
      _M_transfer(_List_node_base* const __first,
          _List_node_base* const __last) throw ();
      
      void
      _M_reverse() throw ();
      
      void
      _M_hook(_List_node_base* const __position) throw ();
      
      void
      _M_unhook() throw ();
    };
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
  /// An actual node in the %list.
  template<typename _Tp>
    struct _List_node : public __detail::_List_node_base
    {
      ///< User's data.
      _Tp _M_data;
 
#ifdef __GXX_EXPERIMENTAL_CXX0X__
      template<typename... _Args>
        _List_node(_Args&&... __args)
    : __detail::_List_node_base(), _M_data(std::forward<_Args>(__args)...) 
        { }
#endif
    };
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
  /// See bits/stl_deque.h's _Deque_base for an explanation.
  template<typename _Tp, typename _Alloc>
    class _List_base
    {
    protected:
      // NOTA BENE
      // The stored instance is not actually of "allocator_type"'s
      // type.  Instead we rebind the type to
      // Allocator<List_node<Tp>>, which according to [20.1.5]/4
      // should probably be the same.  List_node<Tp> is not the same
      // size as Tp (it's two pointers larger), and specializations on
      // Tp may go unused because List_node<Tp> is being bound
      // instead.
      //
      // We put this to the test in the constructors and in
      // get_allocator, where we use conversions between
      // allocator_type and _Node_alloc_type. The conversion is
      // required by table 32 in [20.1.5].
      typedef typename _Alloc::template rebind<_List_node<_Tp> >::other
        _Node_alloc_type;
 
      typedef typename _Alloc::template rebind<_Tp>::other _Tp_alloc_type;
 
      struct _List_impl 
      : public _Node_alloc_type
      {
    __detail::_List_node_base _M_node;
 
    _List_impl()
    : _Node_alloc_type(), _M_node()
    { }
 
    _List_impl(const _Node_alloc_type& __a)
    : _Node_alloc_type(__a), _M_node()
    { }
      };
 
      _List_impl _M_impl;
C++
1
2
  template<typename _Tp, typename _Alloc = std::allocator<_Tp> >
    class list : protected _List_base<_Tp, _Alloc>

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
  /**
   *  @brief A list::iterator.
   *
   *  All the functions are op overloads.
  */
  template<typename _Tp>
    struct _List_iterator
    {
      typedef _List_iterator<_Tp>                _Self;
      typedef _List_node<_Tp>                    _Node;
 
      typedef ptrdiff_t                          difference_type;
      typedef std::bidirectional_iterator_tag    iterator_category;
      typedef _Tp                                value_type;
      typedef _Tp*                               pointer;
      typedef _Tp&                               reference;
 
      _List_iterator()
      : _M_node() { }
 
      explicit
      _List_iterator(__detail::_List_node_base* __x)
      : _M_node(__x) { }
 
      // Must downcast from _List_node_base to _List_node to get to _M_data.
      reference
      operator*() const
      { return static_cast<_Node*>(_M_node)->_M_data; }
 
      pointer
      operator->() const
      { return std::__addressof(static_cast<_Node*>(_M_node)->_M_data); }
 
      _Self&
      operator++()
      {
    _M_node = _M_node->_M_next;
    return *this;
      }
 
      _Self
      operator++(int)
      {
    _Self __tmp = *this;
    _M_node = _M_node->_M_next;
    return __tmp;
      }
 
      _Self&
      operator--()
      {
    _M_node = _M_node->_M_prev;
    return *this;
      }
 
      _Self
      operator--(int)
      {
    _Self __tmp = *this;
    _M_node = _M_node->_M_prev;
    return __tmp;
      }
 
      bool
      operator==(const _Self& __x) const
      { return _M_node == __x._M_node; }
 
      bool
      operator!=(const _Self& __x) const
      { return _M_node != __x._M_node; }
 
      // The only member points to the %list element.
      __detail::_List_node_base* _M_node;
    };
Итого. Каждый элемент это _List_node_base, а если точнее _List_node<T>.
Каждый элемент списка занимает 8 + sizeof(T) байт на 32-битной машине.
Проверка.

C++
1
2
3
4
5
6
7
8
9
10
#include <iostream>
#include <list>
 
int main()
{
   std::list<int> lst = {1};
   std::list<int>::iterator iter = lst.begin();
   std::cout << "Sizeof 1 element: " << 
      sizeof(*reinterpret_cast<std::_List_node<int>*>(iter._M_node)) << std::endl;
}
http://liveworkspace.org/code/fd33c1353d6c285e9a334c50144bfbc7
1
 
КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2017, vBulletin Solutions, Inc.
Рейтинг@Mail.ru