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

С++ для начинающих

Войти
Регистрация
Восстановить пароль
 
 
Рейтинг: Рейтинг темы: голосов - 15, средняя оценка - 5.00
Cynacyn
33 / 33 / 0
Регистрация: 02.05.2013
Сообщений: 109
#1

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

19.08.2013, 11:44. Просмотров 2281. Ответов 20
Метки нет (Все метки)

При попытке скомпилировать код появляются ошибки, хотя делаю вроде как пишет Бьярне. Компилятор 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 минут
Помогите пожалуйста разобраться в чём дело.
0
Надоела реклама? Зарегистрируйтесь и она исчезнет полностью.
Similar
Эксперт
41792 / 34177 / 6122
Регистрация: 12.04.2006
Сообщений: 57,940
19.08.2013, 11:44
Здравствуйте! Я подобрал для вас темы с ответами на вопрос Реализация контейнера идентичного std::vector по Страуструпу (C++):

Reallocation памяти контейнера std::vector - C++
расширение памяти в этом контейнере происходит по логарифмическому закону. Объясните , пожалуйста, знатоки, зачем это нужно?

Реализация класса MyString. Стандартная библиотека, std::string, std::vector - C++
как добавить реализацию конкатенации строк через перегрузку оператора &quot;+=&quot; в классе MyString и почему ошибка выдается???#include...

На основе исходного std::vector<std::string> содержащего числа, создать std::vector<int> с этими же числами - C++
подскажите есть вот такая задача. Есть список . Создать второй список, в котором будут все эти же числа, но не в виде строк, а в виде...

Как передать целочисленную матрицу типа std::vector<std::vector<int> > в функцию? - C++
Здравствуйте. Почитал на форуме, но так и не понял что я делаю не так. Имеется двумерный вектор. Размера .. Нужно его передать в...

Примерная реализация std vector bool - C++
добрый вечер, не могу найти в сети реализацию st::vector&lt;bool&gt; - есть у кого под рукой?) Почитать)

Нужна реализация функции std::vector::insert() - C++
Нужна реализация функции std::vector::insert() 1)iterator insert (iterator position, const value_type&amp; val); 2) void insert (iterator...

20
nofx
7 / 7 / 1
Регистрация: 28.10.2012
Сообщений: 111
Завершенные тесты: 1
05.10.2016, 16:09 #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
0
castaway
Эксперт С++
4884 / 3019 / 370
Регистрация: 10.11.2010
Сообщений: 11,078
Записей в блоге: 10
Завершенные тесты: 1
05.10.2016, 16:17 #17
nofx, а какой компилятор? Приложение 32 или 64-битное?
0
nofx
7 / 7 / 1
Регистрация: 28.10.2012
Сообщений: 111
Завершенные тесты: 1
05.10.2016, 16:36 #18
Visual Studio 2013. Приложение (экзешник?) - 32-битное, так как студия 32-битная.
0
castaway
Эксперт С++
4884 / 3019 / 370
Регистрация: 10.11.2010
Сообщений: 11,078
Записей в блоге: 10
Завершенные тесты: 1
05.10.2016, 16:45 #19
nofx, LARGEADDRESSAWARE
Цитата Сообщение от nofx Посмотреть сообщение
134217728
- это размер вектора в элементах, или размер памяти в байтах?
0
nofx
7 / 7 / 1
Регистрация: 28.10.2012
Сообщений: 111
Завершенные тесты: 1
05.10.2016, 17:47 #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 не доходит.
0
castaway
Эксперт С++
4884 / 3019 / 370
Регистрация: 10.11.2010
Сообщений: 11,078
Записей в блоге: 10
Завершенные тесты: 1
05.10.2016, 18:01 #21
Цитата Сообщение от nofx Посмотреть сообщение
с включенной опцией все-равно до 4Gb не доходит.
А до чего доходит?
0
MoreAnswers
Эксперт
37091 / 29110 / 5898
Регистрация: 17.06.2006
Сообщений: 43,301
05.10.2016, 18:01
Привет! Вот еще темы с ответами:

Вывести значения std::vector<std::vector<int*> > - C++
Подскажите, как вывести значения? const size_t row = 3; const size_t col = 3; std::vector&lt;std::vector&lt;int*&gt; &gt; imatrix; //...

Как изменять размер std::vector<std::vector>? - C++
Здравствуйте, как нужно изменять размер std::vector&lt;std::vector&gt; например: std::vector&lt;std::vector&lt;float&gt;&gt; data; ...

Std::vector<std::pair<std::vector<int>::iterator, std::vector<int>::iterator> - C++
Вопрос по вектору. Допустим есть вектор, std::vector&lt;int&gt; vec; на каком - то этапе заполнения я ставлю закладку итератора, ...

Std::vector/QVector в классе или std::vector/QVector классов? - C++
Доброе время суток! Собственно вопрос в самой теме, есть некий класс class WorkJornal { private: string manager; ...


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

Или воспользуйтесь поиском по форуму:
21
Yandex
Объявления
05.10.2016, 18:01
Ответ Создать тему
Опции темы

КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2017, vBulletin Solutions, Inc.
Рейтинг@Mail.ru