0 / 0 / 0
Регистрация: 29.06.2013
Сообщений: 63
1

allocator, при компиляции ошибка

06.08.2013, 08:43. Показов 980. Ответов 10
Метки нет (Все метки)

C++
1
2
3
4
5
6
7
8
9
template<class T> 
class Vec
{ 
public:
...
private:
allocator<T> alloc;
...
}
При компиляции выдает ошибки C4430, C2238 и C2143 и каждая указывает на строку allocator<t> alloc;
В чем может быть ошибка?
Миниатюры
allocator, при компиляции ошибка  
__________________
Помощь в написании контрольных, курсовых и дипломных работ, диссертаций здесь
0
Programming
Эксперт
94731 / 64177 / 26122
Регистрация: 12.04.2006
Сообщений: 116,782
06.08.2013, 08:43
Ответы с готовыми решениями:

Ошибка при использовании std::allocator
Пытаюсь разобраться с использование std::allocator. Вот пример кода: template &lt;typename T,...

Распределитель памяти идентичный std::allocator. Непонятные синтаксис и концепция std::allocator::construct
Компилятор: MSVC 2010 Exress код моего класса распределяющего память под спойлером #include...

Ошибка с allocator
Приветствую. Пользуюсь Dev-C++. При выполнении кода, ошибка, что на скрине. #include...

Ошибка при компиляции. Где ошибка? (Работа с классом)
Уважаемые форумчане! При компиляции проекта возникает ошибка &quot; undefined reference to...

10
621 / 475 / 58
Регистрация: 18.09.2012
Сообщений: 1,688
06.08.2013, 09:14 2
karl 777, скиньте весь код, кажется вы забыл где-то точку с запятой)

Добавлено через 59 секунд
Цитата Сообщение от karl 777 Посмотреть сообщение
template<class T>
class Vec
{
public:
...
private:
allocator<T> alloc;
...
};
в последней строчке она нужна
0
0 / 0 / 0
Регистрация: 29.06.2013
Сообщений: 63
06.08.2013, 09:28  [ТС] 3
Пунктуацию я всю проверил, все на месте и template также закрывает.
Если убрать строку с аллокатором, то компилятор не выводит ошибки, что это такое?
0
621 / 475 / 58
Регистрация: 18.09.2012
Сообщений: 1,688
06.08.2013, 09:30 4
Глуппо но вместо class вставьте typename

Добавлено через 15 секунд
В template
0
0 / 0 / 0
Регистрация: 29.06.2013
Сообщений: 63
06.08.2013, 09:34  [ТС] 5
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
    template<class T>
    class Vec
    {
    public:
        typedef T* iterator;
        typedef const T* const_iterator;
        typedef size_t size_type;
        typedef T value_type;
        typedef T& reference;
        typedef const T& const_reference;
 
         Vec()                                                                  // Конструктор, который говорит, что вектор пустой
         {
            create();
         }
         explicit Vec(size_type n, const T& val=T())                            // Конструктор, который веделяет память на n объектов типа T
         {
             create(n, val);
         }
 
         size_type size() const                                                 // Функция определяющая размер вектора
         {
             return avail-data;
         }
 
         T& operator[](size_type i)                                             // Доступ к i-ому элементу
         {
             return data[i];
         }
         const T& operator[](size_type i) const
         {
             return data[i];
         }
 
         iterator begin()                                                       // Возвращает итератор на начало вектора
         {
             return data;
         }
         const_iterator begin() const
         {
             return data;
         }
         iterator end()                                                         // Возвращает итератор на конец вектора
         {
             return avail;
         }
         const_iterator end() const
         {
             return avail;
         }
 
         Vec(const Vec& v)                                                      // Конструктор копирования         
         {
             create(v.begin(), v.end());
         }
 
         Vec& operator=(const Vec&);                                            // Конструктор присваивания
 
         ~Vec()                                                                 // Деструктор для разрушения вектора
         {
             uncreate();                                                    
         }
 
         void push_back(const T& t)
         {
             if(avail==limit)
                 grow();
             unchecked_append(t);
         }
 
    private:
        iterator data;                                                          // Начало инициализированых элементов
        iterator avail;                                                         // Конец инициализированых элементов и начало неицилизированых
        iterator limit;                                                         // Конец неинициализированых элементов
        
        allocator<T> alloc;                                                     // Объект, управляющий выделением памяти
 
        // Средства размещения в памяти базового массива и его инициализации
        void create();                                                          // Создает пустой vector - объект
        void create(size_type, const T&);                                       // Выделяет кол-во памяти и инициализирует эти элементы
        void create(const_iterator, const_iterator);                            // Работает как две предыдущие
 
        // Средства разрушения элементов массива и освобождения памяти
        void uncreate();
 
        // Вспомогающие процедуры для push_back
        void grow();                                                            // Выделение памяти для хранения хотя бы еще одного элемента
        void unchecked_append(const T&);                                        // Создает элемент в первой ячейки памяти расположенной за уже созданной
    };
 
//------------------------------------
 
    template <class T>                                                          // Cоздаем пустой вектор
    void Vec<T>::create()
    {
        data=avail=limit=0;                                     // Вектор пуст
    }
 
//------------------------------------
 
    template <class T> 
    void Vec<T>::create(size_type n, const T& val)                              // Выделяет памяти на n элементов типа val
    {
        data=alloc.llocate(n);                                  // Выделяется кол-во памяти для хранения n элементов
        limit=avail=data+n;
        uninitialized_fill(data, limit, val);                   // Инициализация всех элементов вектора длинною n
    }
 
//-------------------------------------
 
    template <class T> 
    void Vec<T>::create(const_iterator i, const_iterator j)                     // Выделение памяти и инициализация элементов
    {
        data=alloc.allocate(j-i);                               // Выделяет кол-во памяти для хранения j-i элементов 
        limit=avail=uninitialized_copy(i, j, data);             // Инициализация элементов с i по j(посредством копирования), возвращает итератор на элемент за j
    }
 
//-------------------------------------
 
    template <class T> 
    void Vec<T>::uncreate()                                                     // Уничтожает последствия работы функция create
    {
        if (data)
        {
            iterator it=limit;
            while(it!=data)
                alloc.destroy(--it);                            // Разрушаем каждый элемент по очереди
            alloc.deallocate(data, limit-data);                 // Освобождаем всю занятую ранее память
        }
        data=avail=limit=0;                                     // Говорим о том, что вектор пуст
    }
 
//--------------------------------------
 
    template <class T> 
    void Vec<T>::grow()                                                         // Выделение памяти для последуещего элемента
    {
        size_type new_size=max(2*(limit-data), ptrdiff_t(1));   // При увеличении объекта выделяемой области памяти, вдвое большую используемой в данный момент
                                                                // ptrdiff_t(1) - имеет тот же тип, что и limit-data
 
        iterator new_data=alloc.allocate(new_size);             // Веделяем память для хранения new_size элементов
        iterator new_avail=uninitialized_copy(data, avail, new_data); // Инициализация элементов
 
        uncreate();                                             // Освобождаем память
 
        // Переводим указатели на новое место
        data=new_data;
        avail=new_avail;
        limit=data+new_size;
    }
 
//---------------------------------------------
 
    template <class T> 
    void Vec<T>::unchecked_append(const T& val)                                 // Создание элемента в первой ячейке памяти за уже существующей
    {
        allос.construct(avail++, val);                            // Создание элемента на место avail++ типа val
    }
0
621 / 475 / 58
Регистрация: 18.09.2012
Сообщений: 1,688
06.08.2013, 09:40 6
karl 777,
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
 template<typename T>
    class Vec
    {
    public:
        typedef T* iterator;
        typedef const T* const_iterator;
        typedef size_t size_type;
        typedef T value_type;
        typedef T& reference;
        typedef const T& const_reference;
 
         Vec()                                                                  // Конструктор, который говорит, что вектор пустой
         {
            create();
         }
         explicit Vec(size_type n, const T& val=T())                            // Конструктор, который веделяет память на n объектов типа T
         {
             create(n, val);
         }
 
         size_type size() const                                                 // Функция определяющая размер вектора
         {
             return avail-data;
         }
 
         T& operator[](size_type i)                                             // Доступ к i-ому элементу
         {
             return data[i];
         }
         const T& operator[](size_type i) const
         {
             return data[i];
         }
 
         iterator begin()                                                       // Возвращает итератор на начало вектора
         {
             return data;
         }
         const_iterator begin() const
         {
             return data;
         }
         iterator end()                                                         // Возвращает итератор на конец вектора
         {
             return avail;
         }
         const_iterator end() const
         {
             return avail;
         }
 
         Vec(const Vec& v)                                                      // Конструктор копирования       
         {
             create(v.begin(), v.end());
         }
 
         Vec& operator=(const Vec&);                                            // Конструктор присваивания
 
         ~Vec()                                                                 // Деструктор для разрушения вектора
         {
             uncreate();                                                    
         }
 
         void push_back(const T& t)
         {
             if(avail==limit)
                 grow();
             unchecked_append(t);
         }
 
    private:
        iterator data;                                                          // Начало инициализированых элементов
        iterator avail;                                                         // Конец инициализированых элементов и начало неицилизированых
        iterator limit;                                                         // Конец неинициализированых элементов
        
        allocator<T> alloc;                                                     // Объект, управляющий выделением памяти
 
        // Средства размещения в памяти базового массива и его инициализации
        void create();                                                          // Создает пустой vector - объект
        void create(size_type, const T&);                                       // Выделяет кол-во памяти и инициализирует эти элементы
        void create(const_iterator, const_iterator);                            // Работает как две предыдущие
 
        // Средства разрушения элементов массива и освобождения памяти
        void uncreate();
 
        // Вспомогающие процедуры для push_back
        void grow();                                                            // Выделение памяти для хранения хотя бы еще одного элемента
        void unchecked_append(const T&);                                        // Создает элемент в первой ячейки памяти расположенной за уже созданной
    };
 
//------------------------------------
 
    template <class T>                                                          // Cоздаем пустой вектор
    void Vec<T>::create()
    {
        data=avail=limit=0;                                     // Вектор пуст
    }
 
//------------------------------------
 
    template <class T> 
    void Vec<T>::create(size_type n, const T& val)                              // Выделяет памяти на n элементов типа val
    {
        data=alloc.llocate(n);                                  // Выделяется кол-во памяти для хранения n элементов
        limit=avail=data+n;
        uninitialized_fill(data, limit, val);                   // Инициализация всех элементов вектора длинною n
    }
 
//-------------------------------------
 
    template <class T> 
    void Vec<T>::create(const_iterator i, const_iterator j)                     // Выделение памяти и инициализация элементов
    {
        data=alloc.allocate(j-i);                               // Выделяет кол-во памяти для хранения j-i элементов 
        limit=avail=uninitialized_copy(i, j, data);             // Инициализация элементов с i по j(посредством копирования), возвращает итератор на элемент за j
    }
 
//-------------------------------------
 
    template <class T> 
    void Vec<T>::uncreate()                                                     // Уничтожает последствия работы функция create
    {
        if (data)
        {
            iterator it=limit;
            while(it!=data)
                alloc.destroy(--it);                            // Разрушаем каждый элемент по очереди
            alloc.deallocate(data, limit-data);                 // Освобождаем всю занятую ранее память
        }
        data=avail=limit=0;                                     // Говорим о том, что вектор пуст
    }
 
//--------------------------------------
 
    template <class T> 
    void Vec<T>::grow()                                                         // Выделение памяти для последуещего элемента
    {
        size_type new_size=max(2*(limit-data), ptrdiff_t(1));   // При увеличении объекта выделяемой области памяти, вдвое большую используемой в данный момент
                                                                // ptrdiff_t(1) - имеет тот же тип, что и limit-data
 
        iterator new_data=alloc.allocate(new_size);             // Веделяем память для хранения new_size элементов
        iterator new_avail=uninitialized_copy(data, avail, new_data); // Инициализация элементов
 
        uncreate();                                             // Освобождаем память
 
        // Переводим указатели на новое место
        data=new_data;
        avail=new_avail;
        limit=data+new_size;
    }
 
//---------------------------------------------
 
    template <class T> 
    void Vec<T>::unchecked_append(const T& val)                                 // Создание элемента в первой ячейке памяти за уже существующей
    {
        allос.construct(avail++, val);                          // Создание элемента на место avail++ типа val
    }
Попробуйте.
0
0 / 0 / 0
Регистрация: 29.06.2013
Сообщений: 63
06.08.2013, 09:59  [ТС] 7
Все равно выводит те же ошибки.
0
What a waste!
1607 / 1299 / 180
Регистрация: 21.04.2012
Сообщений: 2,726
06.08.2013, 10:19 8
Инклюды нужные на месте?
C++
1
2
3
#include <memory>
 
std::allocator<T> alloc;
1
1179 / 892 / 94
Регистрация: 03.08.2011
Сообщений: 2,461
06.08.2013, 10:22 9
А заголовок memory включЕн в файл?

PS: опоздал чутка xD
0
0 / 0 / 0
Регистрация: 29.06.2013
Сообщений: 63
06.08.2013, 10:22  [ТС] 10
Спасибо, прописал <memory>.
0
621 / 475 / 58
Регистрация: 18.09.2012
Сообщений: 1,688
06.08.2013, 10:23 11
Блин, даже не думал в эту сторону...
0
IT_Exp
Эксперт
87844 / 49110 / 22898
Регистрация: 17.06.2006
Сообщений: 92,604
06.08.2013, 10:23
Помогаю со студенческими работами здесь

Ошибка памяти при выполнении, при компиляции не выводит ошибки
ПОмогите плс программа вводит строку символов до точки, а после вычисляет процент согласных в этой...

Не является внутренней или внешней командой - ошибка не при компиляции а при работе программы
В VS скомпилировал код #include &lt;iostream&gt; using namespace std; int main() { int a;...

Использование шаблонов при наследовании, ошибка при компиляции
При изучении списков написал шаблон протестировал, все работает. После написал класс наследник от...

При компиляции ошибка. Ошибка c++ C2678
Ошибка c++ C2678 #include &lt;windows.h&gt; #include &lt;string&gt; #include &lt;iostream&gt; #include &lt;conio.h&gt;...


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

Или воспользуйтесь поиском по форуму:
11
Ответ Создать тему
Опции темы

КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin
Copyright ©2000 - 2022, CyberForum.ru