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

Реализация контейнера идентичного std::vector по Страуструпу - C++

Восстановить пароль Регистрация
 
 
Рейтинг: Рейтинг темы: голосов - 15, средняя оценка - 5.00
Cynacyn
 Аватар для Cynacyn
33 / 33 / 0
Регистрация: 02.05.2013
Сообщений: 109
19.08.2013, 11:44     Реализация контейнера идентичного std::vector по Страуструпу #1
При попытке скомпилировать код появляются ошибки, хотя делаю вроде как пишет Бьярне. Компилятор VSE 2010.
1>------ Построение начато: проект: EmptyConsole01, Конфигурация:Release Win32 ------
1> code.cpp
1>f:\projects\new\emptyconsole01\emptyconsole01\vvector.h(21): error C2663: std::allocator<_Ty>::allocate: для 2 перегрузок нет допустимого преобразования для указателя "this"
1> with
1> [
1> _Ty=int
1> ]
1> f:\projects\new\emptyconsole01\emptyconsole01\vvector.h(21): при компиляции функции-члена "vector_base<T,A>::vector_base(const A &,int)" класса шаблон
1> with
1> [
1> T=int,
1> A=std::allocator<int>
1> ]
1> f:\projects\new\emptyconsole01\emptyconsole01\vvector.h(27): см. ссылку на создание экземпляров класса шаблон при компиляции "vector_base<T,A>"
1> with
1> [
1> T=int,
1> A=std::allocator<int>
1> ]
1> code.cpp(10): см. ссылку на создание экземпляров класса шаблон при компиляции "vvector<T>"
1> with
1> [
1> T=int
1> ]
1>f:\projects\new\emptyconsole01\emptyconsole01\vvector.h(21): fatal error C1903: не удается восстановить после предыдущих ошибок; остановка компиляции
========== Построение: успешно: 0, с ошибками: 1, без изменений: 0, пропущено: 0 ==========
Код:
Содержание common.h(файл с набором часто используемых объявлений)

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
// common.h
#include <iostream>
#include <sstream>
#include <string>
//#include <vector>
using std::runtime_error;
using std::exception;
using std::cin;
using std::cout;
using std::endl;
using std::string;
using std::ostringstream;
//using std::vector;
//-------------------------------------------------------
 
 
inline void keep_window_open(string s)
{
    if (s=="") return;
    cin.clear();
    cin.ignore(120,'\n');
    for (;;) {
        cout << "Please enter " << s << " to exit\n";
        string ss;
        while (cin >> ss && ss!=s)
            cout << "Please enter " << s << " to exit\n";
        return;
    }
}
 
//-------------------------------------------------------
файл vvector.h (содержит определение структуры данных )
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
#include <iostream>
#include <memory>
#include <utility>
 
using std::cout;
using std::allocator;
using std::out_of_range;
using std::string;
using std::stringstream;
using std::swap;
//------------------------------------------------------------------------------
 
template<class T, class A>
struct vector_base {
    A alloc;
    T* elem;
    int sz;
    int space;
    vector_base() : sz(0), elem(0), space(0) {}
    vector_base(const A& a, int n)  : alloc(a), elem(a.allocate(n)), sz(n), space(n) {}
    ~vector_base() { alloc.deallocate(elem,space); }
 
};
//------------------------------------------------------------------------------
template<class T, class A = allocator<T> >
class vvector : private vector_base<T,A> {
/*
invariant:
    для 0<=n<sz elem[n] является n-м элементом
    sz<=space
    если sz<space, то после elem[sz-1] есть место
    для (space-sz) чисел типа double
*/
 
//  A alloc;
//  int sz;
//  T* elem;
//  int space;
        void copy(const vvector& arg); // copy elements value. don't carry about its size
 
public:
    vvector() {}
    explicit vvector(int s): // constructor; key-word "explicit"  have been added to prevent implicit conversion
        sz(s), elem(alloc.allocate(s)), space(s)
        {
            for(int i=0;i<sz;i++) elem[i]=T();
        }
  
    vvector(const vvector&);                       // copy constructor: define copy
    vvector& operator=(const vvector&);
  
    ~vvector() // destructor
    {
        
        for(int i=0; i<sz; i++) {
            alloc.destroy(&elem[i]);
        }
        alloc.deallocate(elem,space);
        
        // delete[] elem;
    }                  
    
    T& operator[](int n) {return elem[n];} // access without range checking
    const T& operator[](int n) const {return elem[n];} // access without range checking
    
    T& at(int n); // access with range checking
    const T& at(int n) const; // access with range checking
 
    int size() const { return sz; }               // the current size
    int capacity() const {return space; }
 
    void reserve(int newalloc);
    void resize(int newsize, T value = T());
    void push_back(T value);
};
 
//------------------------------------------------------------------------------
template<class T, class A>
vvector<T,A>::vvector(const vvector& arg)
// allocate elements, then initialize them by copying
    :sz(arg.sz), space(arg.sz), elem(alloc.allocate(arg.space))
{
    copy(arg);
    
}
 
//------------------------------------------------------------------------------
template<class T, class A>
vvector<T,A>& vvector<T,A>::operator=(const vvector& v) {
    if(this==&v) return *this;
 
    if(v.sz<=space) {
        copy(v);
        sz=v.sz;
        return *this;
    }
    T* p = alloc.allocate(v.space);
    for(int i=0; i<v.sz; i++)
        alloc.construct(&p[i],v.elem[i]);
    for(int i=0; i<sz; i++)
        alloc.destroy(&elem[i]);
    alloc.deallocate(elem,space);
    elem = p;
    space = sz = v.sz;
    return *this;
}
 
//------------------------------------------------------------------------------
template<class T, class A>
void vvector<T,A>::copy(const vvector& arg) {
    for(int i=0; i<arg.sz; i++) 
        alloc.construct(&elem[i],arg[i]);
}
 
//------------------------------------------------------------------------------
template<class T, class A>
void vvector<T,A>::reserve(int newalloc) {
    if(newalloc<=space) return;
 
    vector_base<T,A> b(alloc,newalloc);
    for(int i=0; i<sz; i++) 
        alloc.construct(&b.elem[i],elem[i]);
    for(int i=0; i<sz; i++) 
        alloc.destroy(&elem[i]);
    
    swap<vector_base<T,A>>(*this,b);
}
 
//------------------------------------------------------------------------------
template<class T, class A>
void vvector<T,A>::resize(int newsize, T value) {
    reserve(newsize);
    for(int i=sz; i<newsize; i++) 
        alloc.construct(&elem[i], value);
    for(int i=newsize; i<sz; i++) 
        alloc.destroy(&elem[i]);
    
 
    sz = newsize;
}
 
//------------------------------------------------------------------------------
template<class T, class A>
void vvector<T,A>::push_back(T value) {
    if(!space) reserve(8);
    else if (sz==space) reserve(2*space);
    alloc.construct(&elem[sz], value);
    ++sz;
}
 
//------------------------------------------------------------------------------
 
template<class T, class A> 
T& vvector<T,A>::at(int n) {
    
    if(n<0 || sz<=n) { 
        string s = "wrong index: ";
        stringstream ss;
        ss << n;
        s += ss.str();
        throw out_of_range(s);
    }
    return elem[n];
 
}
 
//------------------------------------------------------------------------------
template<class T, class A> 
const T& vvector<T,A>::at(int n) const {
    if(n<0 || sz<=n) { 
        string s = "wrong index: ";
        stringstream ss;
        ss << n;
        s += ss.str();
        throw out_of_range(s);
    }
    return elem[n];
 
}
 
//------------------------------------------------------------------------------
содержимое code.cpp (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
// code.cpp
#include "common.h" // error, keep_window_open, default declarations
#include "vvector.h"
 
using std::auto_ptr;
//-------------------------------------------------------
 
 
vvector<int>* make_vec() {
    auto_ptr<vvector<int>> p(new vvector<int>);
    for(int i=0; i<20; i++)
        p->push_back(i*i);
 
    cout << "p == " << &(*p) << endl;
    auto_ptr<vvector<int>> p2;
    p2 = p;
    cout << "After assigment: " << endl;
    cout << "p2 == " << &(*p2) << endl;
    cout << "p == " << &(*p) << endl;
    
    return p2.release();
 
}
 
 
//-------------------------------------------------------
 
int main ()
try{
    
    
    vvector<int>* v = make_vec();
    for(int i=0; i<v->size(); i++)
        cout << (*v)[i] << endl;
    
 
//  vvector<int>* v = new vvector<int>;
//  v->push_back(2);
 
  keep_window_open("~");
  return 0;
 }
 
catch(exception e) {
    cout << e.what();
    keep_window_open("~");
    return 1;
}
 
catch(...) {
    cout << "Error occurred!";
    keep_window_open("~");
    return 2;
}
 
//-------------------------------------------------------
Добавлено через 5 минут
Помогите пожалуйста разобраться в чём дело.
Similar
Эксперт
41792 / 34177 / 6122
Регистрация: 12.04.2006
Сообщений: 57,940
19.08.2013, 11:44     Реализация контейнера идентичного std::vector по Страуструпу
Посмотрите здесь:

std::map, std::vector и порядок обхода коллекции C++
Передача функции указатель на элемент std::vector<std::string> C++
C++ vector<vector<double>> + std::sort()
reallocation памяти контейнера std::vector C++
Какая реализация лучше? std::pointer_to_binary_function vs std::function C++
После регистрации реклама в сообщениях будет скрыта и будут доступны все возможности форума.
gray_fox
What a waste!
 Аватар для gray_fox
1244 / 1127 / 53
Регистрация: 21.04.2012
Сообщений: 2,350
Завершенные тесты: 3
19.08.2013, 12:50     Реализация контейнера идентичного std::vector по Страуструпу #2
Цитата Сообщение от Cynacyn Посмотреть сообщение
>f:\projects\new\emptyconsole01\emptyconsole01\vvector.h(21 ): error C2663: std::allocator<_Ty>::allocate: для 2 перегрузок нет допустимого преобразования для указателя "this"
Цитата Сообщение от Cynacyn Посмотреть сообщение
vector_base(const A& a, int n) : alloc(a), elem(a.allocate(n)), sz(n), space(n) {}
allocate - неконстантный метод, для a его вызвать нельзя (т.к. это ссылка на константу). Можно вызвать этот метод у alloc:
C++
1
vector_base(const A& a, int n) : alloc(a), elem(alloc.allocate(n)), sz(n), space(n) {}
Добавлено через 1 минуту
Только здесь надо следить, чтобы alloc был объявлен раньше elem в классе (поля класса инициализируются в порядке объявления).
Cynacyn
 Аватар для Cynacyn
33 / 33 / 0
Регистрация: 02.05.2013
Сообщений: 109
19.08.2013, 13:11  [ТС]     Реализация контейнера идентичного std::vector по Страуструпу #3
Вот ещё одна версия реализации, разница в методе vvector::reserve() и объявлении класса vvector.
Смысл задания было сравнить две реализации: с ипользованием базового класса vector_base, который бы управлял памятью, и с использованием std::auto_ptr, и ответить на вопрос, что лучше/легче реализовать.
Эта версия (с std::auto_ptr) реализации рабочая.


Кликните здесь для просмотра всего текста
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
#include <iostream>
#include <memory>
#include <utility>
 
using std::cout;
using std::allocator;
using std::out_of_range;
using std::runtime_error;
using std::string;
using std::stringstream;
using std::swap;
using std::auto_ptr;
 
//------------------------------------------------------------------------------
 
template<class T, class A = allocator<T> >
class vvector {
/*
invariant:
    для 0<=n<sz elem[n] является n-м элементом
    sz<=space
    если sz<space, то после elem[sz-1] есть место
    для (space-sz) чисел типа double
*/
 
    A alloc;
    int sz;
    T* elem;
    int space;
        void copy(const vvector& arg); // copy elements value. don't carry about its size
 
public:
    vvector() : sz(0), elem(0), space(0) {}
    explicit vvector(int s): // constructor; key-word "explicit"  have been added to prevent implicit conversion
        sz(s), elem(alloc.allocate(s)), space(s)
        {
            for(int i=0;i<sz;i++) elem[i]=T();
        }
  
    vvector(const vvector&);                       // copy constructor: define copy
    vvector& operator=(const vvector&);
  
    ~vvector() // destructor
    {
        
        for(int i=0; i<sz; i++) {
            alloc.destroy(&elem[i]);
        }
        alloc.deallocate(elem,space);
        
        // delete[] elem;
    }                  
    
    T& operator[](int n) {return elem[n];} // access without range checking
    const T& operator[](int n) const {return elem[n];} // access without range checking
    
    T& at(int n); // access with range checking
    const T& at(int n) const; // access with range checking
 
    int size() const { return sz; }               // the current size
    int capacity() const {return space; }
 
    void reserve(int newalloc);
    void resize(int newsize, T value = T());
    void push_back(T value);
};
 
//------------------------------------------------------------------------------
 
template<class T, class A>
vvector<T,A>::vvector(const vvector& arg)
// allocate elements, then initialize them by copying
    :sz(arg.sz), space(arg.sz), elem(alloc.allocate(arg.space))
{
    copy(arg);
    
}
 
//------------------------------------------------------------------------------
 
template<class T, class A>
vvector<T,A>& vvector<T,A>::operator=(const vvector& v) {
    if(this==&v) return *this;
 
    if(v.sz<=space) {
        copy(v);
        sz=v.sz;
        return *this;
    }
    T* p = alloc.allocate(v.space);
    for(int i=0; i<v.sz; i++)
        alloc.construct(&p[i],v.elem[i]);
    for(int i=0; i<sz; i++)
        alloc.destroy(&elem[i]);
    alloc.deallocate(elem,space);
    elem = p;
    space = sz = v.sz;
    return *this;
}
 
//------------------------------------------------------------------------------
 
template<class T, class A>
void vvector<T,A>::copy(const vvector& arg) {
    for(int i=0; i<arg.sz; i++) 
        alloc.construct(&elem[i],arg[i]);
}
 
//------------------------------------------------------------------------------
 
template<class T, class A>
void vvector<T,A>::reserve(int newalloc) {
    if(newalloc<=space) return;
    
    auto_ptr<T> aptr(alloc.allocate(newalloc));
        
    for(int i=0; i<sz; i++) try {
        alloc.construct(&aptr.get()[i],elem[i]);
    } catch(runtime_error re) {
        alloc.deallocate(aptr.release(),newalloc);
        throw;
    }
    
    for(int i=0; i<sz; i++) 
        alloc.destroy(&elem[i]);
    
    alloc.deallocate(elem,space);
    elem = aptr.release();
    space = newalloc;
 
}
 
//------------------------------------------------------------------------------
 
template<class T, class A>
void vvector<T,A>::resize(int newsize, T value) {
    reserve(newsize);
    for(int i=sz; i<newsize; i++) 
        alloc.construct(&elem[i], value);
    for(int i=newsize; i<sz; i++) 
        alloc.destroy(&elem[i]);
    
 
    sz = newsize;
}
 
//------------------------------------------------------------------------------
 
template<class T, class A>
void vvector<T,A>::push_back(T value) {
    if(!space) reserve(8);
    else if (sz==space) reserve(2*space);
    alloc.construct(&elem[sz], value);
    ++sz;
}
 
//------------------------------------------------------------------------------
 
template<class T, class A> 
T& vvector<T,A>::at(int n) {
    
    if(n<0 || sz<=n) { 
        string s = "wrong index: ";
        stringstream ss;
        ss << n;
        s += ss.str();
        throw out_of_range(s);
    }
    return elem[n];
 
}
 
//------------------------------------------------------------------------------
 
template<class T, class A> 
const T& vvector<T,A>::at(int n) const {
    if(n<0 || sz<=n) { 
        string s = "wrong index: ";
        stringstream ss;
        ss << n;
        s += ss.str();
        throw out_of_range(s);
    }
    return elem[n];
 
}
 
//------------------------------------------------------------------------------

Добавлено через 7 минут
Цитата Сообщение от gray_fox Посмотреть сообщение
allocate - неконстантный метод, для a его вызвать нельзя (т.к. это ссылка на константу). Можно вызвать этот метод у alloc:
C++
1
vector_base(const A& a, int n) : alloc(a), elem(alloc.allocate(n)), sz(n), space(n) {}
Добавлено через 1 минуту
Только здесь надо следить, чтобы alloc был объявлен раньше elem в классе (поля класса инициализируются в порядке объявления).
Спасибо!
Теперь компилируется, но вылетает изза повреждения кучи на 14 строке code.cpp внутри mave_vec() cout << "p == " << &(*p) << endl;
выводит на экран только "p == " второй оператор << не обрабатывается.


"EmptyConsole01.exe": Загружено: "F:\Projects\New\EmptyConsole01\Release\EmptyConsole01.exe", Символы загружены.
"EmptyConsole01.exe": Загружено: "C:\Windows\SysWOW64\ntdll.dll", Невозможно найти или открыть файл PDB
"EmptyConsole01.exe": Загружено: "C:\Windows\SysWOW64\kernel32.dll", Невозможно найти или открыть файл PDB
"EmptyConsole01.exe": Загружено: "C:\Windows\SysWOW64\KernelBase.dll", Невозможно найти или открыть файл PDB
"EmptyConsole01.exe": Загружено: "C:\Windows\SysWOW64\msvcr100.dll", Символы загружены.
"EmptyConsole01.exe": Загружено: "C:\Windows\SysWOW64\msvcp100.dll", Символы загружены.
Critical error detected c0000374
ОС Windows инициировала точку останова в EmptyConsole01.exe.

Это может быть вызвано повреждением кучи и указывает на ошибку в EmptyConsole01.exe или в одной из загруженных им DLL.

Возможной причиной так же может быть нажатие пользователем клавиши F12, когда фокус принадлежит EmptyConsole01.exe

Выведенное на экран окно содержит дополнительные данные для диагностики ошибки
Добавлено через 8 минут
Извините, часть вывода забыл вставить:
Выведенное на экран окно содержит дополнительные данные для диагностики ошибки
Первый этап обработки исключения в "0x7724e6c3" в "EmptyConsole01.exe": 0xC0000374: Куча была повреждена.
Необработанное исключение в "0x771a15de" в "EmptyConsole01.exe": 0xC0000374: Куча была повреждена.
Необработанное исключение в "0x771a15de" в "EmptyConsole01.exe": 0xC0000374: Куча была повреждена.
Поток 'Поток Win32' (0x7fc) завершился с кодом -1073741510 (0xc000013a).
Программа "[3632] EmptyConsole01.exe: Машинный код" завершилась с кодом -1073741510 (0xc000013a).
gray_fox
What a waste!
 Аватар для gray_fox
1244 / 1127 / 53
Регистрация: 21.04.2012
Сообщений: 2,350
Завершенные тесты: 3
19.08.2013, 13:17     Реализация контейнера идентичного std::vector по Страуструпу #4
Цитата Сообщение от Cynacyn Посмотреть сообщение
Теперь компилируется, но вылетает изза повреждения кучи на 14 строке code.cpp внутри mave_vec() cout << "p == " << &(*p) << endl;
Мне так сложно что-либо понять) Где то там, где работа с памятью, reserve может... Пройдись дебаггером, посмотри что происходит.
Cynacyn
 Аватар для Cynacyn
33 / 33 / 0
Регистрация: 02.05.2013
Сообщений: 109
19.08.2013, 13:24  [ТС]     Реализация контейнера идентичного std::vector по Страуструпу #5
Цитата Сообщение от gray_fox Посмотреть сообщение
Мне так сложно что-либо понять) Где то там, где работа с памятью, reserve может... Пройдись дебаггером, посмотри что происходит.
Ок, пойду учиться пользоваться дебаггером (:
Cynacyn
 Аватар для Cynacyn
33 / 33 / 0
Регистрация: 02.05.2013
Сообщений: 109
21.08.2013, 11:45  [ТС]     Реализация контейнера идентичного std::vector по Страуструпу #6
Я ещё не добрался до мануалов по отладке, но я пытаюсь разобраться используя те знания что есть.
Я добавил операторы вывода в конструкторы/деструкторы и методы.
На скрине из вложения видно, что появляется лишний деструктор и нарушается инвариант структуры sz<=space.

Вывод:
"EmptyConsole01.exe": Загружено: "F:\Projects\New\EmptyConsole01\Release\EmptyConsole01.exe", Символы загружены.
"EmptyConsole01.exe": Загружено: "C:\Windows\SysWOW64\ntdll.dll", Невозможно найти или открыть файл PDB
"EmptyConsole01.exe": Загружено: "C:\Windows\SysWOW64\kernel32.dll", Невозможно найти или открыть файл PDB
"EmptyConsole01.exe": Загружено: "C:\Windows\SysWOW64\KernelBase.dll", Невозможно найти или открыть файл PDB
"EmptyConsole01.exe": Загружено: "C:\Windows\SysWOW64\msvcr100.dll", Символы загружены.
"EmptyConsole01.exe": Загружено: "C:\Windows\SysWOW64\msvcp100.dll", Символы загружены.
HEAP[EmptyConsole01.exe]: Heap block at 00203690 modified at 002036B8 past requested size of 20
ОС Windows инициировала точку останова в EmptyConsole01.exe.

Это может быть вызвано повреждением кучи и указывает на ошибку в EmptyConsole01.exe или в одной из загруженных им DLL.

Возможной причиной так же может быть нажатие пользователем клавиши F12, когда фокус принадлежит EmptyConsole01.exe

Выведенное на экран окно содержит дополнительные данные для диагностики ошибки
HEAP[EmptyConsole01.exe]: Invalid address specified to RtlFreeHeap( 00200000, 00203698 )
ОС Windows инициировала точку останова в EmptyConsole01.exe.

Это может быть вызвано повреждением кучи и указывает на ошибку в EmptyConsole01.exe или в одной из загруженных им DLL.

Возможной причиной так же может быть нажатие пользователем клавиши F12, когда фокус принадлежит EmptyConsole01.exe

Выведенное на экран окно содержит дополнительные данные для диагностики ошибки
Первый этап обработки исключения в "0x77457074" в "EmptyConsole01.exe": 0xC0000005: Нарушение прав доступа при чтении "0x00000011".
Первый этап обработки исключения в "0x774343d0" в "EmptyConsole01.exe": 0xC0000005: Нарушение прав доступа при чтении "0xababab04".
Первый этап обработки исключения в "0x77457074" в "EmptyConsole01.exe": 0xC0000005: Нарушение прав доступа при чтении "0x00000011".
Поток 'Основной поток' (0x15ec) завершился с кодом -1073741510 (0xc000013a).
Программа "[5860] EmptyConsole01.exe: Машинный код" завершилась с кодом -1073741510 (0xc000013a).
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
//vvector.h
#include <iostream>
#include <memory>
#include <utility>
 
using std::cout;
using std::allocator;
using std::out_of_range;
using std::string;
using std::stringstream;
using std::swap;
 
//------------------------------------------------------------------------------
template<class T, class A>
struct vector_base {
    A alloc;
    T* elem;
    int sz;
    int space;
    vector_base() : sz(0), elem(0), space(0) 
    {
        cout << this << " vector_base::vector_base()" << endl; 
    }
    vector_base(const A& a, int n)  : alloc(a), elem(alloc.allocate(n)), sz(n), space(n) 
    {
        cout << this << " vector_base::vector_base(const A& a, int n)" << endl; 
    }
    ~vector_base() 
    { 
        cout << this << " vector_base::~vector_base()" << endl; 
        alloc.deallocate(elem,space); 
    }
 
};
//------------------------------------------------------------------------------
template<class T, class A = allocator<T> >
class vvector : private vector_base<T,A> {
/*
invariant:
    для 0<=n<sz elem[n] является n-м элементом
    sz<=space
    если sz<space, то после elem[sz-1] есть место
    для (space-sz) чисел типа double
*/
 
//  A alloc;
//  int sz;
//  T* elem;
//  int space;
    void copy(const vvector& arg); // copy elements value. don't carry about its size
 
public:
    vvector() 
    {
        cout << this << " \tvvector::vvector()" << endl; 
    }
    explicit vvector(int s): // constructor; key-word "explicit"  have been added to prevent implicit conversion
        sz(s), elem(alloc.allocate(s)), space(s)
        {
            for(int i=0;i<sz;i++) elem[i]=T();
            cout << this << " \tvvector::vvector(int s)" << endl; 
        }
  
    vvector(const vvector&);                       // copy constructor: define copy
    vvector& operator=(const vvector&);
  
    ~vvector() {cout << this << " \tvvector::~vvector()" << endl;} // destructor
             
    
    T& operator[](int n) {return elem[n];} // access without range checking
    const T& operator[](int n) const {return elem[n];} // access without range checking
    
    T& at(int n); // access with range checking
    const T& at(int n) const; // access with range checking
 
    int size() const { return sz; }               // the current size
    int capacity() const {return space; }
 
    void reserve(int newalloc);
    void resize(int newsize, T value = T());
    void push_back(T value);
};
 
//------------------------------------------------------------------------------
template<class T, class A>
vvector<T,A>::vvector(const vvector& arg)
// allocate elements, then initialize them by copying
    :sz(arg.sz), space(arg.sz), elem(alloc.allocate(arg.space))
{
    cout << this << " \t\tvvector::vvector(const vvector& arg)" << endl;
    copy(arg);
    
}
 
//------------------------------------------------------------------------------
template<class T, class A>
vvector<T,A>& vvector<T,A>::operator=(const vvector& v) {
    cout << this << " \t\tvvector::operator=(const vvector& v)" << endl;
    if(this==&v) return *this;
 
    if(v.sz<=space) {
        copy(v);
        sz=v.sz;
        return *this;
    }
    T* p = alloc.allocate(v.space);
    for(int i=0; i<v.sz; i++)
        alloc.construct(&p[i],v.elem[i]);
    for(int i=0; i<sz; i++)
        alloc.destroy(&elem[i]);
    alloc.deallocate(elem,space);
    elem = p;
    space = sz = v.sz;
    return *this;
}
 
//------------------------------------------------------------------------------
template<class T, class A>
void vvector<T,A>::copy(const vvector& arg) {
    for(int i=0; i<arg.sz; i++) 
        alloc.construct(&elem[i],arg[i]);
}
 
//------------------------------------------------------------------------------
template<class T, class A>
void vvector<T,A>::reserve(int newalloc) {
 
    cout << this << " \t\tvvector::reserve(int newalloc)" << endl;
    if(newalloc<=space) return;
 
    vector_base<T,A> b(alloc,newalloc);
    for(int i=0; i<sz; i++) 
        alloc.construct(&b.elem[i],elem[i]);
    for(int i=0; i<sz; i++) 
        alloc.destroy(&elem[i]);
    
    swap<vector_base<T,A>>(*this,b);
    
}
 
//------------------------------------------------------------------------------
template<class T, class A>
void vvector<T,A>::resize(int newsize, T value) {
    cout << this << " \t\tvvector::resize(int newsize, T value)" << endl;
 
    reserve(newsize);
    for(int i=sz; i<newsize; i++) 
        alloc.construct(&elem[i], value);
    for(int i=newsize; i<sz; i++) 
        alloc.destroy(&elem[i]);
    
 
    sz = newsize;
}
 
//------------------------------------------------------------------------------
template<class T, class A>
void vvector<T,A>::push_back(T value) {
    cout << this << " \t\tvvector::push_back(T value)" << endl;
    if(!space) reserve(8);
    else if (sz==space) reserve(2*space);
    alloc.construct(&elem[sz], value);
    ++sz;
}
 
//------------------------------------------------------------------------------
template<class T, class A> 
T& vvector<T,A>::at(int n) {
    
    if(n<0 || sz<=n) { 
        string s = "wrong index: ";
        stringstream ss;
        ss << n;
        s += ss.str();
        throw out_of_range(s);
    }
    return elem[n];
 
}
 
//------------------------------------------------------------------------------
template<class T, class A> 
const T& vvector<T,A>::at(int n) const {
    if(n<0 || sz<=n) { 
        string s = "wrong index: ";
        stringstream ss;
        ss << n;
        s += ss.str();
        throw out_of_range(s);
    }
    return elem[n];
 
}
 
//------------------------------------------------------------------------------
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
// code.cpp
#include "common.h" // error, keep_window_open, default declarations
#include "vvector_vbase.h"
#include <memory>
using std::auto_ptr;
 
//-------------------------------------------------------
 
vvector<int>* make_vec() {
    auto_ptr<vvector<int>> p(new vvector<int>);
    for(int i=0; i<20; i++)
        p->push_back(i*i);
    (*p)[0] = -1;
    cout << "p == "; 
    cout << p.get() << endl;
    auto_ptr<vvector<int>> p2;
    p2 = p;
    cout << "After assigment: " << endl;
    cout << "p2 == " << &(*p2) << endl;
    cout << "p == " << &(*p) << endl;
    
    return p2.release();
 
}
 
//-------------------------------------------------------
 
void f() {
    cout << "f()" << endl;
    vvector<int> vi;
    for(int i=0; i<10; i++)
        vi.push_back(i+10);
    cout <<  "vi.sz == "<< vi.size() << "; vi.space == " << vi.capacity() << endl;
}
 
//-------------------------------------------------------
 
int main ()
try{
    //
    //vvector<int>* v = make_vec();
    //for(int i=0; i<v->size(); i++)
    //  cout << (*v)[i] << endl;
    //
    cout << "main(). Before f()" << endl;
    f();
    cout << "main(). After f()" << endl;
//  for(int i=0; i<vi.size(); i++)
//      cout << vi[i] << endl;
 
 
  keep_window_open("~");
  return 0;
 }
 
catch(exception e) {
    cout << e.what();
    keep_window_open("~");
    return 1;
}
 
catch(...) {
    cout << "Error occurred!";
    keep_window_open("~");
    return 2;
}
 
//-------------------------------------------------------
Миниатюры
Реализация контейнера идентичного std::vector по Страуструпу  
Croessmah
Модератор
Эксперт С++
 Аватар для Croessmah
11828 / 6807 / 769
Регистрация: 27.09.2012
Сообщений: 16,878
Записей в блоге: 2
Завершенные тесты: 1
21.08.2013, 12:09     Реализация контейнера идентичного std::vector по Страуструпу #7
Где конструктор копий для vector_base?
Cynacyn
 Аватар для Cynacyn
33 / 33 / 0
Регистрация: 02.05.2013
Сообщений: 109
21.08.2013, 12:11  [ТС]     Реализация контейнера идентичного std::vector по Страуструпу #8
Я устранил нарушение инварианта структуры (изменения коснулись строк 23 и 130 в vvector.h).
Прошу помощи, совета в каком направлении копать.
В этот раз вылетает при попытке добавить 9-й элемент.

Вывод.
"EmptyConsole01.exe": Загружено: "F:\Projects\New\EmptyConsole01\Release\EmptyConsole01.exe", Символы загружены.
"EmptyConsole01.exe": Загружено: "C:\Windows\SysWOW64\ntdll.dll", Невозможно найти или открыть файл PDB
"EmptyConsole01.exe": Загружено: "C:\Windows\SysWOW64\kernel32.dll", Невозможно найти или открыть файл PDB
"EmptyConsole01.exe": Загружено: "C:\Windows\SysWOW64\KernelBase.dll", Невозможно найти или открыть файл PDB
"EmptyConsole01.exe": Загружено: "C:\Windows\SysWOW64\msvcr100.dll", Символы загружены.
"EmptyConsole01.exe": Загружено: "C:\Windows\SysWOW64\msvcp100.dll", Символы загружены.
Critical error detected c0000374
ОС Windows инициировала точку останова в EmptyConsole01.exe.

Это может быть вызвано повреждением кучи и указывает на ошибку в EmptyConsole01.exe или в одной из загруженных им DLL.

Возможной причиной так же может быть нажатие пользователем клавиши F12, когда фокус принадлежит EmptyConsole01.exe

Выведенное на экран окно содержит дополнительные данные для диагностики ошибки
Поток 'Основной поток' (0x18ac) завершился с кодом -1073741510 (0xc000013a).
Программа "[6300] EmptyConsole01.exe: Машинный код" завершилась с кодом -1073741510 (0xc000013a).
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
//vvector.h
#include <iostream>
#include <memory>
#include <utility>
 
using std::cout;
using std::allocator;
using std::out_of_range;
using std::string;
using std::stringstream;
using std::swap;
 
//------------------------------------------------------------------------------
template<class T, class A>
struct vector_base {
    A alloc;
    T* elem;
    int sz;
    int space;
    vector_base() : sz(0), elem(0), space(0) 
    {
        cout << this << " vector_base::vector_base()" << endl; 
    }
    vector_base(const A& a, int elems, int newcapacity) : alloc(a), elem(alloc.allocate(newcapacity)), sz(elems), space(newcapacity) 
    {
        cout << this << " vector_base::vector_base(const A& a, int n)" << endl; 
    }
    ~vector_base() 
    { 
        cout << this << " vector_base::~vector_base()" << endl; 
        alloc.deallocate(elem,space); 
    }
 
};
//------------------------------------------------------------------------------
template<class T, class A = allocator<T> >
class vvector : private vector_base<T,A> {
/*
invariant:
    для 0<=n<sz elem[n] является n-м элементом
    sz<=space
    если sz<space, то после elem[sz-1] есть место
    для (space-sz) элементов типа T 
*/
 
//  A alloc;
//  int sz;
//  T* elem;
//  int space;
    void copy(const vvector& arg); // copy elements value. don't carry about its size
 
public:
    vvector() 
    {
        cout << this << " \tvvector::vvector()" << endl; 
    }
    explicit vvector(int s): // constructor; key-word "explicit"  have been added to prevent implicit conversion
        sz(s), elem(alloc.allocate(s)), space(s)
        {
            for(int i=0;i<sz;i++) elem[i]=T();
            cout << this << " \tvvector::vvector(int s)" << endl; 
        }
  
    vvector(const vvector&);                       // copy constructor: define copy
    vvector& operator=(const vvector&);
  
    ~vvector() {cout << this << " \tvvector::~vvector()" << endl;} // destructor
             
    
    T& operator[](int n) {return elem[n];} // access without range checking
    const T& operator[](int n) const {return elem[n];} // access without range checking
    
    T& at(int n); // access with range checking
    const T& at(int n) const; // access with range checking
 
    int size() const { return sz; }               // the current size
    int capacity() const {return space; }
 
    void reserve(int newalloc);
    void resize(int newsize, T value = T());
    void push_back(T value);
};
 
//------------------------------------------------------------------------------
template<class T, class A>
vvector<T,A>::vvector(const vvector& arg)
// allocate elements, then initialize them by copying
    :sz(arg.sz), space(arg.sz), elem(alloc.allocate(arg.space))
{
    cout << this << " \t\tvvector::vvector(const vvector& arg)" << endl;
    copy(arg);
    
}
 
//------------------------------------------------------------------------------
template<class T, class A>
vvector<T,A>& vvector<T,A>::operator=(const vvector& v) {
    cout << this << " \t\tvvector::operator=(const vvector& v)" << endl;
    if(this==&v) return *this;
 
    if(v.sz<=space) {
        copy(v);
        sz=v.sz;
        return *this;
    }
    T* p = alloc.allocate(v.space);
    for(int i=0; i<v.sz; i++)
        alloc.construct(&p[i],v.elem[i]);
    for(int i=0; i<sz; i++)
        alloc.destroy(&elem[i]);
    alloc.deallocate(elem,space);
    elem = p;
    space = sz = v.sz;
    return *this;
}
 
//------------------------------------------------------------------------------
template<class T, class A>
void vvector<T,A>::copy(const vvector& arg) {
    for(int i=0; i<arg.sz; i++) 
        alloc.construct(&elem[i],arg[i]);
}
 
//------------------------------------------------------------------------------
template<class T, class A>
void vvector<T,A>::reserve(int newalloc) {
 
    cout << this << " \t\tvvector::reserve(int newalloc)" << endl;
    if(newalloc<=space) return;
 
    vector_base<T,A> b(alloc,sz,newalloc);
    for(int i=0; i<sz; i++) 
        alloc.construct(&b.elem[i],elem[i]);
    for(int i=0; i<sz; i++) 
        alloc.destroy(&elem[i]);
    
    swap<vector_base<T,A>>(*this,b);
    
}
 
//------------------------------------------------------------------------------
template<class T, class A>
void vvector<T,A>::resize(int newsize, T value) {
    cout << this << " \t\tvvector::resize(int newsize, T value)" << endl;
 
    reserve(newsize);
    for(int i=sz; i<newsize; i++) 
        alloc.construct(&elem[i], value);
    for(int i=newsize; i<sz; i++) 
        alloc.destroy(&elem[i]);
    sz = newsize;
}
 
//------------------------------------------------------------------------------
template<class T, class A>
void vvector<T,A>::push_back(T value) {
    cout << this << " \t\tvvector::push_back(T value), size==" << sz << "; space==" << space << endl;
    if(!space) reserve(8);
    else if (sz==space) reserve(2*space);
    alloc.construct(&elem[sz], value);
    ++sz;
}
 
//------------------------------------------------------------------------------
template<class T, class A> 
T& vvector<T,A>::at(int n) {
    
    if(n<0 || sz<=n) { 
        string s = "wrong index: ";
        stringstream ss;
        ss << n;
        s += ss.str();
        throw out_of_range(s);
    }
    return elem[n];
 
}
 
//------------------------------------------------------------------------------
template<class T, class A> 
const T& vvector<T,A>::at(int n) const {
    if(n<0 || sz<=n) { 
        string s = "wrong index: ";
        stringstream ss;
        ss << n;
        s += ss.str();
        throw out_of_range(s);
    }
    return elem[n];
 
}
 
//------------------------------------------------------------------------------


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
// code.cpp
#include "common.h" // error, keep_window_open, default declarations
#include "vvector_vbase.h"
 
//-------------------------------------------------------
 
void f() {
    cout << "f()" << endl;
    vvector<int> vi;
    for(int i=0; i<10; i++)
        vi.push_back(i+10);
    cout <<  "vi.sz == "<< vi.size() << "; vi.space == " << vi.capacity() << endl;
}
 
//-------------------------------------------------------
 
int main ()
try{
 
    cout << "main(). Before f()" << endl;
    f();
    cout << "main(). After f()" << endl;
 
 
  keep_window_open("~");
  return 0;
 }
 
catch(exception e) {
    cout << e.what();
    keep_window_open("~");
    return 1;
}
 
catch(...) {
    cout << "Error occurred!";
    keep_window_open("~");
    return 2;
}
 
//-------------------------------------------------------
Миниатюры
Реализация контейнера идентичного std::vector по Страуструпу  
Cynacyn
 Аватар для Cynacyn
33 / 33 / 0
Регистрация: 02.05.2013
Сообщений: 109
21.08.2013, 12:15  [ТС]     Реализация контейнера идентичного std::vector по Страуструпу #9
Цитата Сообщение от Croessmah Посмотреть сообщение
Где конструктор копий для vector_base?
Ох.
Его нет.
Croessmah
Модератор
Эксперт С++
 Аватар для Croessmah
11828 / 6807 / 769
Регистрация: 27.09.2012
Сообщений: 16,878
Записей в блоге: 2
Завершенные тесты: 1
21.08.2013, 12:18     Реализация контейнера идентичного std::vector по Страуструпу #10
Цитата Сообщение от Cynacyn Посмотреть сообщение
Цитата Сообщение от Croessmah Посмотреть сообщение
Где конструктор копий для vector_base?
Строки 86-94 и 119-123.
vvector_base, а не vvector

Добавлено через 2 минуты
И operator= тоже надо бы
Cynacyn
 Аватар для Cynacyn
33 / 33 / 0
Регистрация: 02.05.2013
Сообщений: 109
21.08.2013, 12:22  [ТС]     Реализация контейнера идентичного std::vector по Страуструпу #11
Цитата Сообщение от Croessmah Посмотреть сообщение
vvector_base, а не vvector

Добавлено через 2 минуты
И operator= тоже надо бы
Спасибо.
Буду, реализовывать.
Croessmah
Модератор
Эксперт С++
 Аватар для Croessmah
11828 / 6807 / 769
Регистрация: 27.09.2012
Сообщений: 16,878
Записей в блоге: 2
Завершенные тесты: 1
21.08.2013, 12:23     Реализация контейнера идентичного std::vector по Страуструпу #12
У Вас тут:
C++
1
swap<vector_base<T,A>>(*this,b);
примерно такой обмен:
C++
1
2
3
4
5
swap ( Параметр1 , Параметр2 ){
Временный vector_base = параметр1 ; //Теперь elem указывает на одну и ту же память в двух объектах
Параметр1 = Параметр2 ; //Тут всё просто
Параметр2 = Временный vector_base ;
}//А тут для временного объекта вызывается деструктор - тот самый, который лишний. deallocate памяти тоже тут
Cynacyn
 Аватар для Cynacyn
33 / 33 / 0
Регистрация: 02.05.2013
Сообщений: 109
22.08.2013, 11:43  [ТС]     Реализация контейнера идентичного std::vector по Страуструпу #13
Цитата Сообщение от Croessmah Посмотреть сообщение
У Вас тут:
C++
1
swap<vector_base<T,A>>(*this,b);
примерно такой обмен:
C++
1
2
3
4
5
swap ( Параметр1 , Параметр2 ){
Временный vector_base = параметр1 ; //Теперь elem указывает на одну и ту же память в двух объектах
Параметр1 = Параметр2 ; //Тут всё просто
Параметр2 = Временный vector_base ;
}//А тут для временного объекта вызывается деструктор - тот самый, который лишний. deallocate памяти тоже тут
Прояснилось)
Спасибо!

Добавлено через 22 часа 59 минут
Ещё раз спасибо, gray_fox, Croessmah!

Если кому интересно, вот исправленный код:

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
// Принципы и практика использования C++ Глава 19
// Principles and Practice Using C++ Chapter 19
 
#include <iostream>
#include <memory>
#include <utility>
 
using std::cout;
using std::allocator;
using std::out_of_range;
using std::string;
using std::stringstream;
using std::swap;
using std::auto_ptr;
//------------------------------------------------------------------------------
 
template<class T, class A>
struct vector_base {
    A alloc;
    T* elem;
    int sz;
    int space;
    vector_base() : sz(0), elem(0), space(0) 
    {
        //cout << this << " vector_base::vector_base()" << endl; 
    }
    vector_base(const A& a, int n)  : alloc(a), elem(alloc.allocate(n)), sz(n), space(n)
    {
        //cout << this << " vector_base::vector_base(const A& a, int n)" << endl; 
    }
    vector_base(const vector_base&);
    vector_base& operator=(const vector_base&);
    ~vector_base() 
    { 
        //cout << this << " vector_base::~vector_base()" << endl; 
        alloc.deallocate(elem,space); 
    }
 
};
 
//------------------------------------------------------------------------------
template<class T, class A>
vector_base<T,A>::vector_base(const vector_base& arg)
    :   sz(arg.sz), space(arg.space), elem(alloc.allocate(arg.space))
{
    //cout << this << " vector_base::vector_base(const vector_base& arg)" << endl; 
    
    for(int i=0; i<arg.sz; i++)
        alloc.construct(&elem[i],arg.elem[i]);
}
 
//------------------------------------------------------------------------------
template<class T, class A>
vector_base<T,A>& vector_base<T,A>::operator=(const vector_base& arg) {
    //cout << this << " vector_base& vector_base::operator=(const vector_base& arg)" << endl; 
 
    if(&arg==this) return *this; // self-assignment
 
    if(arg.space <= space) {
        for(int i=0; i<arg.sz; i++)
            alloc.construct(&elem[i],arg.elem[i]);
        sz = arg.sz;
        return *this;
    }
    
    auto_ptr<T> p(alloc.allocate(arg.space));
 
    for(int i=0; i<arg.sz; i++)
        alloc.construct(&p.get()[i],arg.elem[i]);
    for(int i=0; i<sz; i++)
        alloc.destroy(&elem[i]);
    
    alloc.deallocate(elem,space);
    elem = p.release();
    sz = arg.sz;
    space = arg.space;
    return *this;
 
}
//------------------------------------------------------------------------------
 
template<class T, class A = allocator<T> >
class vvector : private vector_base<T,A> {
/*
invariant:
    для 0<=n<sz elem[n] является n-м элементом
    sz<=space
    если sz<space, то после elem[sz-1] есть место
    для (space-sz) элементов типа T 
*/
 
    void copy(const vvector& arg); // copy elements value. don't carry about its size
 
public:
    vvector() 
    {
        //cout << this << " \tvvector::vvector()" << endl; 
    }
    explicit vvector(int s): // constructor; key-word "explicit"  have been added to prevent implicit conversion
        sz(s), elem(alloc.allocate(s)), space(s)
        {
            for(int i=0;i<sz;i++) elem[i]=T();
            //cout << this << " \tvvector::vvector(int s)" << endl; 
        }
  
    vvector(const vvector&);                       // copy constructor: define copy
    vvector& operator=(const vvector&);
  
    ~vvector() { // destructor
        //cout << this << " \tvvector::~vvector()" << endl;
    } 
             
    
    T& operator[](int n) {return elem[n];} // access without range checking
    const T& operator[](int n) const {return elem[n];} // access without range checking
    
    T& at(int n); // access with range checking
    const T& at(int n) const; // access with range checking
 
    int size() const { return sz; }               // the current size
    int capacity() const {return space; }
 
    void reserve(int newalloc);
    void resize(int newsize, T value = T());
    void push_back(T value);
};
 
//------------------------------------------------------------------------------
template<class T, class A>
void vvector<T,A>::copy(const vvector& arg) {
    for(int i=0; i<arg.sz; i++) 
        alloc.construct(&elem[i],arg.elem[i]);
}
 
//------------------------------------------------------------------------------
template<class T, class A>
vvector<T,A>::vvector(const vvector& arg)
// allocate elements, then initialize them by copying
{
    //cout << this << " \t\tvvector::vvector(const vvector& arg)" << endl;
    sz = arg.sz;
    space = arg.sz;
    elem = alloc.allocate(arg.sz);
    copy(arg);
}
 
//------------------------------------------------------------------------------
template<class T, class A>
vvector<T,A>& vvector<T,A>::operator=(const vvector& arg) {
    //cout << this << " \t\tvvector::operator=(const vvector& v)" << endl;
    if(this==&arg) return *this;
 
    if(arg.sz<=space) {
        copy(arg);
        sz=arg.sz;
        return *this;
    }
    auto_ptr<T> p(alloc.allocate(arg.space));
    for(int i=0; i<arg.sz; i++)
        alloc.construct(&p.get()[i],arg.elem[i]);
    for(int i=0; i<sz; i++)
        alloc.destroy(&elem[i]);
    alloc.deallocate(elem,space);
    elem = p.release();
    space = sz = arg.sz;
    return *this;
}
 
 
//------------------------------------------------------------------------------
template<class T, class A>
void vvector<T,A>::reserve(int newalloc) {
 
    //cout << this << " \t\tvvector::reserve(int newalloc), newalloc==" << newalloc << endl;
    if(newalloc<=space) return;
 
    vector_base<T,A> b(alloc,newalloc);
    b.sz = sz;
    for(int i=0; i<sz; i++) 
        alloc.construct(&b.elem[i],elem[i]);
    for(int i=0; i<sz; i++) 
        alloc.destroy(&elem[i]);
    
    swap<vector_base<T,A>>(*this,b);
    //cout << "vvector<T,A>::reserve, space == " << space << endl;
    
}
 
//------------------------------------------------------------------------------
template<class T, class A>
void vvector<T,A>::resize(int newsize, T value) {
    //cout << this << " \t\tvvector::resize(int newsize, T value)" << endl;
 
    reserve(newsize);
    for(int i=sz; i<newsize; i++) 
        alloc.construct(&elem[i], value);
    for(int i=newsize; i<sz; i++) 
        alloc.destroy(&elem[i]);
    sz = newsize;
}
 
//------------------------------------------------------------------------------
template<class T, class A>
void vvector<T,A>::push_back(T value) {
    //cout << this << " \t\tvvector::push_back(T value), size==" << sz << "; space==" << space << endl;
    if(!space) reserve(8);
    else if (sz==space) reserve(2*space);
    alloc.construct(&elem[sz], value);
    ++sz;
}
 
//------------------------------------------------------------------------------
template<class T, class A> 
T& vvector<T,A>::at(int n) {
    
    if(n<0 || sz<=n) { 
        string s = "wrong index: ";
        stringstream ss;
        ss << n;
        s += ss.str();
        throw out_of_range(s);
    }
    return elem[n];
 
}
 
//------------------------------------------------------------------------------
template<class T, class A> 
const T& vvector<T,A>::at(int n) const {
    if(n<0 || sz<=n) { 
        string s = "wrong index: ";
        stringstream ss;
        ss << n;
        s += ss.str();
        throw out_of_range(s);
    }
    return elem[n];
 
}
 
//------------------------------------------------------------------------------
Добавлено через 17 минут
Правильно же говорят: "Поспешишь, людей насмешишь."
Ниже исправление исправленной версии.

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
// Принципы и практика использования C++ Глава 19
// Principles and Practice Using C++ Chapter 19
#include <iostream>
#include <memory>
#include <utility>
 
using std::cout;
using std::allocator;
using std::out_of_range;
using std::string;
using std::stringstream;
using std::swap;
using std::auto_ptr;
//------------------------------------------------------------------------------
 
template<class T, class A>
struct vector_base {
    A alloc;
    T* elem;
    int sz;
    int space;
    vector_base() : sz(0), elem(0), space(0) 
    {
        //cout << this << " vector_base::vector_base()" << endl; 
    }
    vector_base(const A& a, int e,  int n)  : alloc(a), elem(alloc.allocate(n)), sz(e), space(n)
    {
        //cout << this << " vector_base::vector_base(const A& a, int n)" << endl; 
    }
    vector_base(const vector_base&);
    vector_base& operator=(const vector_base&);
    ~vector_base() 
    { 
        //cout << this << " vector_base::~vector_base()" << endl; 
        alloc.deallocate(elem,space); 
    }
 
};
 
//------------------------------------------------------------------------------
template<class T, class A>
vector_base<T,A>::vector_base(const vector_base& arg)
    :   sz(arg.sz), space(arg.space), elem(alloc.allocate(arg.space))
{
    //cout << this << " vector_base::vector_base(const vector_base& arg)" << endl; 
    
    for(int i=0; i<arg.sz; i++)
        alloc.construct(&elem[i],arg.elem[i]);
}
 
//------------------------------------------------------------------------------
template<class T, class A>
vector_base<T,A>& vector_base<T,A>::operator=(const vector_base& arg) {
    //cout << this << " vector_base& vector_base::operator=(const vector_base& arg)" << endl; 
 
    if(&arg==this) return *this; // self-assignment
 
    if(arg.space <= space) {
        for(int i=0; i<arg.sz; i++)
            alloc.construct(&elem[i],arg.elem[i]);
        sz = arg.sz;
        return *this;
    }
    
    auto_ptr<T> p(alloc.allocate(arg.space));
 
    for(int i=0; i<arg.sz; i++)
        alloc.construct(&p.get()[i],arg.elem[i]);
    for(int i=0; i<sz; i++)
        alloc.destroy(&elem[i]);
    
    alloc.deallocate(elem,space);
    elem = p.release();
    sz = arg.sz;
    space = arg.space;
    return *this;
 
}
//------------------------------------------------------------------------------
 
template<class T, class A = allocator<T> >
class vvector : private vector_base<T,A> {
/*
invariant:
    для 0<=n<sz elem[n] является n-м элементом
    sz<=space
    если sz<space, то после elem[sz-1] есть место
    для (space-sz) элементов типа T 
*/
 
    void copy(const vvector& arg); // copy elements value. don't carry about its size
 
public:
    vvector() 
    {
        //cout << this << " \tvvector::vvector()" << endl; 
    }
    explicit vvector(int s) // constructor; key-word "explicit"  have been added to prevent implicit conversion
    {
        sz = s;
        space = s;
        elem = alloc.allocate(s);
        for(int i=0;i<sz;i++) elem[i]=T();
        //cout << this << " \tvvector::vvector(int s)" << endl; 
    }
  
    vvector(const vvector&);                       // copy constructor: define copy
    vvector& operator=(const vvector&);
  
    ~vvector() { // destructor
        //cout << this << " \tvvector::~vvector()" << endl;
    } 
             
    
    T& operator[](int n) {return elem[n];} // access without range checking
    const T& operator[](int n) const {return elem[n];} // access without range checking
    
    T& at(int n); // access with range checking
    const T& at(int n) const; // access with range checking
 
    int size() const { return sz; }               // the current size
    int capacity() const {return space; }
 
    void reserve(int newalloc);
    void resize(int newsize, T value = T());
    void push_back(T value);
};
 
//------------------------------------------------------------------------------
template<class T, class A>
void vvector<T,A>::copy(const vvector& arg) {
    for(int i=0; i<arg.sz; i++) 
        alloc.construct(&elem[i],arg.elem[i]);
}
 
//------------------------------------------------------------------------------
template<class T, class A>
vvector<T,A>::vvector(const vvector& arg)
// allocate elements, then initialize them by copying
{
    //cout << this << " \t\tvvector::vvector(const vvector& arg)" << endl;
    sz = arg.sz;
    space = arg.sz;
    elem = alloc.allocate(arg.sz);
    copy(arg);
}
 
//------------------------------------------------------------------------------
template<class T, class A>
vvector<T,A>& vvector<T,A>::operator=(const vvector& arg) {
    //cout << this << " \t\tvvector::operator=(const vvector& v)" << endl;
    if(this==&arg) return *this;
 
    if(arg.sz<=space) {
        copy(arg);
        sz=arg.sz;
        return *this;
    }
    auto_ptr<T> p(alloc.allocate(arg.space));
    for(int i=0; i<arg.sz; i++)
        alloc.construct(&p.get()[i],arg.elem[i]);
    for(int i=0; i<sz; i++)
        alloc.destroy(&elem[i]);
    alloc.deallocate(elem,space);
    elem = p.release();
    space = sz = arg.sz;
    return *this;
}
 
 
//------------------------------------------------------------------------------
template<class T, class A>
void vvector<T,A>::reserve(int newalloc) {
 
    //cout << this << " \t\tvvector::reserve(int newalloc), newalloc==" << newalloc << endl;
    if(newalloc<=space) return;
 
    vector_base<T,A> b(alloc,sz,newalloc);
    for(int i=0; i<sz; i++) 
        alloc.construct(&b.elem[i],elem[i]);
    for(int i=0; i<sz; i++) 
        alloc.destroy(&elem[i]);
    
    swap<vector_base<T,A>>(*this,b);
    //cout << "vvector<T,A>::reserve, space == " << space << endl;
    
}
 
//------------------------------------------------------------------------------
template<class T, class A>
void vvector<T,A>::resize(int newsize, T value) {
    //cout << this << " \t\tvvector::resize(int newsize, T value)" << endl;
 
    reserve(newsize);
    for(int i=sz; i<newsize; i++) 
        alloc.construct(&elem[i], value);
    for(int i=newsize; i<sz; i++) 
        alloc.destroy(&elem[i]);
    sz = newsize;
}
 
//------------------------------------------------------------------------------
template<class T, class A>
void vvector<T,A>::push_back(T value) {
    //cout << this << " \t\tvvector::push_back(T value), size==" << sz << "; space==" << space << endl;
    if(!space) reserve(8);
    else if (sz==space) reserve(2*space);
    alloc.construct(&elem[sz], value);
    ++sz;
}
 
//------------------------------------------------------------------------------
template<class T, class A> 
T& vvector<T,A>::at(int n) {
    
    if(n<0 || sz<=n) { 
        string s = "wrong index: ";
        stringstream ss;
        ss << n;
        s += ss.str();
        throw out_of_range(s);
    }
    return elem[n];
 
}
 
//------------------------------------------------------------------------------
template<class T, class A> 
const T& vvector<T,A>::at(int n) const {
    if(n<0 || sz<=n) { 
        string s = "wrong index: ";
        stringstream ss;
        ss << n;
        s += ss.str();
        throw out_of_range(s);
    }
    return elem[n];
 
}
 
//------------------------------------------------------------------------------
nofx
7 / 7 / 1
Регистрация: 28.10.2012
Сообщений: 85
Завершенные тесты: 1
04.10.2016, 00:12     Реализация контейнера идентичного std::vector по Страуструпу #14
Тоже читаю Бьярне
Сам свой вектор не смог осилить, за основу взял Ваш. Немного переделал его по своему (вариант c auto_ptr проще):
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
template<class T, class A = allocator<T> >
class vvector {
 
private:
    int sz;
    int space;
    T* elem;
    void copy(const vvector& arg);
 
protected:
    A alloc;
 
public:
    
    vvector() :sz(0), space(0), elem(0) {}
    vvector(int _sz, int _space) : sz(_sz), space(_space)
    {
        elem = alloc.allocate(space);
        std::uninitialized_fill_n(elem, sz, T());
    }
    vvector(int _sz, int _space, T val): sz(_sz), space(_space)
    {
        elem = alloc.allocate(space);
        std::uninitialized_fill_n(elem, sz, val);
    }
 
    vvector(const vvector&); 
    vvector& operator=(const vvector&);
 
    virtual ~vvector() { // destructor
        for (int i = 0; i < sz; i++)
            alloc.destroy(&elem[i]);
        alloc.deallocate(elem, space);
    }
 
    T& operator[](int n) { return elem[n]; } // access without range checking
    const T& operator[](int n) const { return elem[n]; } // access without range checking
 
    T& at(int n); // access with range checking
    const T& at(int n) const; // access with range checking
 
    int size() const { return sz; }  // the current size
    int capacity() const { return space; }
 
    void reserve(int newalloc);
    void resize(int newsize, T value = T());
    void push_back(T value);
};
Кстати, если позабивать память таким образом (Ram = 8 Gb) то максимально доходит до 1 гб, почему вся не забивается?
Какие-то опции компилятору поставить пади?
C++
1
2
3
4
5
6
7
8
9
10
11
12
while (true)
    {
        try
        {
            vd3.push_back(rand());
        }
        catch (std::bad_alloc ba_exp)
        {
            cerr << ba_exp.what() << endl;
            break;
        }
    }
castaway
Эксперт С++
4844 / 2983 / 367
Регистрация: 10.11.2010
Сообщений: 11,016
Записей в блоге: 10
Завершенные тесты: 1
04.10.2016, 08:20     Реализация контейнера идентичного std::vector по Страуструпу #15
Цитата Сообщение от nofx Посмотреть сообщение
Кстати, если позабивать память таким образом (Ram = 8 Gb) то максимально доходит до 1 гб, почему вся не забивается?
А что случается потом?
Где реализация?
Какой тип хранимых объектов?
Максимальное значение, хранящиеся в int - 2 147 483 647.
nofx
7 / 7 / 1
Регистрация: 28.10.2012
Сообщений: 85
Завершенные тесты: 1
05.10.2016, 16:09     Реализация контейнера идентичного std::vector по Страуструпу #16
Цитата Сообщение от castaway Посмотреть сообщение
Где реализация?
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
#include "myvector.h"
 
using namespace std;
 
int main()
{           
    setlocale(LC_ALL, "RUS");
 
    vvector <double> vd;
    srand(1);
 
    while (true)
    {
        try
        {
            vd.push_back(rand());
        }
        catch (std::bad_alloc ba_exp)
        {
            cerr << ba_exp.what() << endl;
            break;
        }
    }
 
    cout << "vd.sz == " << vd.size() << "; vd.space == " << vd.capacity() << endl;
 
    getchar();
    return 0;
}
myvector.h
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
// Принципы и практика использования C++ Глава 19
// Principles and Practice Using C++ Chapter 19
#include <iostream>
#include <memory>
#include <utility>
 
using std::cout;
using std::allocator;
using std::out_of_range;
using std::string;
using std::stringstream;
using std::auto_ptr;
//------------------------------------------------------------------------------
 
template<class T, class A = allocator<T> >
class vvector {
 
private:
    int sz;
    int space;
    T* elem;
    void copy(const vvector& arg);
 
protected:
    A alloc;
 
public:
    
    vvector() :sz(0), space(0), elem(0) {}
    vvector(int _sz, int _space) : sz(_sz), space(_space)
    {
        elem = alloc.allocate(space);
        std::uninitialized_fill_n(elem, sz, T());
    }
    vvector(int _sz, int _space, T val): sz(_sz), space(_space)
    {
        elem = alloc.allocate(space);
        std::uninitialized_fill_n(elem, sz, val);
    }
 
    vvector(const vvector&); 
    vvector& operator=(const vvector&);
 
    virtual ~vvector() { // destructor
        for (int i = 0; i < sz; i++)
            alloc.destroy(&elem[i]);
        alloc.deallocate(elem, space);
    }
 
    T& operator[](int n) { return elem[n]; } // access without range checking
    const T& operator[](int n) const { return elem[n]; } // access without range checking
 
    T& at(int n); // access with range checking
    const T& at(int n) const; // access with range checking
 
    int size() const { return sz; }  // the current size
    int capacity() const { return space; }
 
    void reserve(int newalloc);
    void resize(int newsize, T value = T());
    void push_back(T value);
};
 
//------------------------------------------------------------------------------
template<class T, class A>
void vvector<T, A>::copy(const vvector& arg) {
    for (int i = 0; i<arg.sz; i++)
        alloc.construct(&elem[i], arg.elem[i]);
}
 
//------------------------------------------------------------------------------
template<class T, class A>
vvector<T, A>::vvector(const vvector& arg)
// allocate elements, then initialize them by copying, then reserve memory
{
    cout << this << " \t\tvvector::vvector(const vvector& arg)" << endl;
    sz = arg.sz;
    elem = alloc.allocate(arg.sz);
    copy(arg);
    reserve(arg.space);
}
 
//------------------------------------------------------------------------------
template<class T, class A>
vvector<T, A>& vvector<T, A>::operator=(const vvector& arg) {
    cout << this << " \t\tvvector::operator=(const vvector& v)" << endl;
    if (this == &arg) return *this;
 
    if (arg.sz <= space) {
        copy(arg);
        sz = arg.sz;
        return *this;
    }
    auto_ptr<T> p(alloc.allocate(arg.space));
    for (int i = 0; i<arg.sz; i++)
        alloc.construct(&p.get()[i], arg.elem[i]);
    
    for (int i = 0; i<sz; i++)
        alloc.destroy(&elem[i]);
    alloc.deallocate(elem, space);
    
    elem = p.release();
    sz = arg.sz;
    reserve(arg.space);
    
    return *this;
}
 
//------------------------------------------------------------------------------
/*
template<class T, class A>
void vvector<T, A>::reserve(int newalloc) {
 
    cout << this << " vvector::reserve(int newalloc), newalloc==" << newalloc << endl;
    if (newalloc <= space) return;
 
    vector_base<T, A> b(alloc, sz, newalloc);
    for (int i = 0; i<sz; i++)
        alloc.construct(&b.elem[i], elem[i]);
    for (int i = 0; i<sz; i++)
        alloc.destroy(&elem[i]);
 
    swap<vector_base<T, A>>(*this, b);
    cout << "vvector<T,A>::reserve, space == " << space << endl;
 
}
*/
template<class T, class A>
void vvector<T, A>::reserve(int newalloc) {
 
    cout << this << " vvector::reserve(int newalloc), newalloc==" << newalloc << endl;
    if (newalloc <= space) return;
    
    auto_ptr<T> pa(alloc.allocate(newalloc));
    
    for (int i = 0; i < sz; i++)
    {
        alloc.construct(&pa.get()[i], elem[i]);
        alloc.destroy(&elem[i]);
    }
 
    elem = pa.release();
    space = newalloc;
    cout << this << " vvector<T,A>::reserve, space == " << space << endl;
 
}
 
//------------------------------------------------------------------------------
template<class T, class A>
void vvector<T, A>::resize(int newsize, T value) {
    cout << this << " \t\tvvector::resize(int newsize, T value)" << endl;
 
    reserve(newsize);
    for (int i = sz; i<newsize; i++)
        alloc.construct(&elem[i], value); 
    
    for (int i = newsize; i<sz; i++)
        alloc.destroy(&elem[i]);
    
    sz = newsize;
}
 
//------------------------------------------------------------------------------
template<class T, class A>
void vvector<T, A>::push_back(T value) {
    if (!space) reserve(8);
    else if (sz == space) reserve(2 * space);
    alloc.construct(&elem[sz], value);
    ++sz;
}
 
//------------------------------------------------------------------------------
template<class T, class A>
T& vvector<T, A>::at(int n) {
 
    if (n<0 || sz <= n) {
        string s = "wrong index: ";
        stringstream ss;
        ss << n;
        s += ss.str();
        throw out_of_range(s);
    }
    return elem[n];
 
}
 
//------------------------------------------------------------------------------
template<class T, class A>
const T& vvector<T, A>::at(int n) const {
    if (n<0 || sz <= n) {
        string s = "wrong index: ";
        stringstream ss;
        ss << n;
        s += ss.str();
        throw out_of_range(s);
    }
    return elem[n];
 
}
//------------------------------------------------------------------------------
Цитата Сообщение от castaway Посмотреть сообщение
Какой тип хранимых объектов?
-да, извините не указал выше...double
Цитата Сообщение от castaway Посмотреть сообщение
Максимальное значение, хранящиеся в int - 2 147 483 647.
- в пределах, вектор не резервирует блок для doublе размером 134217728 и

C++
1
auto_ptr<T> pa(alloc.allocate(newalloc)); //кидает bad_alloc  при newalloc = 134217728
castaway
Эксперт С++
4844 / 2983 / 367
Регистрация: 10.11.2010
Сообщений: 11,016
Записей в блоге: 10
Завершенные тесты: 1
05.10.2016, 16:17     Реализация контейнера идентичного std::vector по Страуструпу #17
nofx, а какой компилятор? Приложение 32 или 64-битное?
nofx
7 / 7 / 1
Регистрация: 28.10.2012
Сообщений: 85
Завершенные тесты: 1
05.10.2016, 16:36     Реализация контейнера идентичного std::vector по Страуструпу #18
Visual Studio 2013. Приложение (экзешник?) - 32-битное, так как студия 32-битная.
castaway
Эксперт С++
4844 / 2983 / 367
Регистрация: 10.11.2010
Сообщений: 11,016
Записей в блоге: 10
Завершенные тесты: 1
05.10.2016, 16:45     Реализация контейнера идентичного std::vector по Страуструпу #19
nofx, LARGEADDRESSAWARE
Цитата Сообщение от nofx Посмотреть сообщение
134217728
- это размер вектора в элементах, или размер памяти в байтах?
MoreAnswers
Эксперт
37091 / 29110 / 5898
Регистрация: 17.06.2006
Сообщений: 43,301
05.10.2016, 17:47     Реализация контейнера идентичного std::vector по Страуструпу
Еще ссылки по теме:

Вывести значения std::vector<std::vector<int*> > C++
C++ Error C2664: std::vector<_Ty>::push: невозможно преобразовать параметр 1 из 'double' в 'const std::string &'
Как изменять размер std::vector<std::vector>? C++

Искать еще темы с ответами

Или воспользуйтесь поиском по форуму:
nofx
7 / 7 / 1
Регистрация: 28.10.2012
Сообщений: 85
Завершенные тесты: 1
05.10.2016, 17:47     Реализация контейнера идентичного std::vector по Страуструпу #20
Цитата Сообщение от castaway Посмотреть сообщение
- это размер вектора в элементах, или размер памяти в байтах?
- число элементов под которые allocator пытается выделить память.

C++
1
size_t max_size = alloc.max_size();
- а это,как я понял, максимальное такое число. в отладчике max_size = 536870911 unsigned int

Добавлено через 7 минут
считаем так: 8 байт (double) * max_size(536870911) и переводим в мегабайты = 4096 мегабайт

По факту: 8 * 134217728 = .... = 1024 мегабайт выделяется

Добавлено через 10 минут
Цитата Сообщение от castaway Посмотреть сообщение
LARGEADDRESSAWARE
- с включенной опцией все-равно до 4Gb не доходит.
Yandex
Объявления
05.10.2016, 17:47     Реализация контейнера идентичного std::vector по Страуструпу
Ответ Создать тему
Опции темы

Текущее время: 01:09. Часовой пояс GMT +3.
КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2016, vBulletin Solutions, Inc.
Рейтинг@Mail.ru