allocator写这个的时候出错了但是不明白哪里错了,报错信息很奇怪

mirrorsir

#include <iostream>
#include <stdio.h>
using namespace std;

template<typename T>
class Allocator {
public:
        T* allocate(size_t _size = 10)
        {
                return (T*)malloc(sizeof(T) * _size);
        }
        void freeallocate(void* p)
        {
                free(p);
        }
        void construct(T* p, const T& value)
        {
                new (p) T(value);
        }
        void deleteallocate(T* p)
        {
                p->~T();
        }
};

template<typename T, typename Alloc = Allocator<T>>
class vector {
private:
        T* _first;
        T* _last;
        T* _end;
        Alloc _alloc;

        void expand()
        {
                int _size = _end - _first;
                _size = _size * 2;
                //T* _new_first = new T [_size];
                T* _new_first = _alloc.allocate(_size);
                int _len = _last - _first;
                for (int i = 0; i < _len; i++)
                {
                        //_new_first[i] = _first[i];
                        _alloc.construct(_new_first[i], _first[i]);
                }
                for (T* p = _first; p != _last; ++p) {
                        _alloc.deleteallocate(p);
                }
                _alloc.freeallocate(_first);
                _first = _new_first;
                _last = _first + _len;
                _end = _first + _size;
        }
public:
        vector<T>(int _size = 10)
        {
                //_first = new T [_size];
                _first = _alloc.allocate(_size);
                _last = _first;
                _end = _first + _size;
        }
        vector<T>(const vector<T>& st)
        {
                int _size = st._end - st._first;
                //_first = new T [_size];
                _first = _alloc.allocate(_size);
                int _len = st._last - st._first;
                for (int i = 0; i < _len; i++)
                {
                        //_first[i] = st._first[i];
                        _alloc.construct(_first[i], st._first[i]);
                }
                _last = _first + _len;
                _end = _first + _size;
        }

        vector<T>& operator=(const vector<T>& st)
        {
                if (st == *this)
                        return *this;
                //delete[] _first;
                for (T* p = _first; p != _last; ++p) {
                        _alloc.deleteallocate(p);
                }
                _alloc.freeallocate(_first);
                int _size = st._end - st._first;
                //_first = new T [_size];
                _first = _alloc.allocate(_size);
                int _len = st._last - st._first;
                for (int i = 0; i < _len; i++)
                {
                        //_first[i] = st._first[i];
                        _alloc.construct(_first[i], st._first[i]);
                }
                _last = _first + _len;
                _end = _first + _size;
                return *this;
        }
        ~vector<T>()
        {
                for (T* p = _first; p != _last; ++p) {
                        _alloc.deleteallocate(p);
                }
                _alloc.freeallocate(_first); // 释放内存
                _first = nullptr;
                _last = nullptr;
                _end = nullptr;
        }

        void push(T val)
        {
                if (_end == _last)
                {
                        expand();
                }
                //*_last++ = val;
                _alloc.construct(_last++, val);

        }
        void popback()
        {
                if (_first == _last)
                        return;
                _last--;
                _alloc.deleteallocte(_last);
        }
        T back()
        {
                return *(_last - 1);
        }
        bool empty()
        {
                return _first == _last;
        }
        int size()
        {
                return _last - _first;
        }

};



int main()
{
        vector<int> p;
        for (int i = 0; i < 15; i++)
        {
                p.push(rand() % 100);
        }

        cout << p.size() << endl;
        while (!p.empty())
        {
                cout << p.back() << "  ";
                p.popback();
        }
        cout << endl;

}

FishC

你好，鱼油。你提供的代码有一些小问题导致编译错误或运行时错误。以下是改进的代码以及一些注意事项：

1. 确保包含所需的头文件。
2. 修复模板定义中的语法错误。
3. 修复删除析构函数时的拼写错误。
4. 修复分配和构造对象的代码。
5. 修正比较运算符中的逻辑错误，以及打印输出的部分。

1. #include <iostream>
   
2. #include <cstdlib>
   
3. using namespace std;
   
4. 
   
5. template <typename T>
   
6. class Allocator {
   
7. public:
   
8.     T* allocate(size_t _size = 10)
   
9.     {
   
10.         return (T*)malloc(sizeof(T) * _size);
    
11.     }
    
12. 
    
13.     void freeallocate(void* p)
    
14.     {
    
15.         free(p);
    
16.     }
    
17. 
    
18.     void construct(T* p, const T& value)
    
19.     {
    
20.         new (p) T(value);
    
21.     }
    
22. 
    
23.     void deleteallocate(T* p)
    
24.     {
    
25.         p->~T();
    
26.     }
    
27. };
    
28. 
    
29. template <typename T, typename Alloc = Allocator<T>>
    
30. class vector {
    
31. private:
    
32.     T* _first;
    
33.     T* _last;
    
34.     T* _end;
    
35.     Alloc _alloc;
    
36. 
    
37.     void expand()
    
38.     {
    
39.         int _size = _end - _first;
    
40.         _size = _size * 2;
    
41.         T* _new_first = _alloc.allocate(_size);
    
42.         int _len = _last - _first;
    
43.         for (int i = 0; i < _len; i++)
    
44.         {
    
45.             _alloc.construct(_new_first + i, _first[i]);
    
46.         }
    
47.         for (T* p = _first; p != _last; ++p) {
    
48.             _alloc.deleteallocate(p);
    
49.         }
    
50.         _alloc.freeallocate(_first);
    
51.         _first = _new_first;
    
52.         _last = _new_first + _len;
    
53.         _end = _new_first + _size;
    
54.     }
    
55. 
    
56. public:
    
57.     vector(int _size = 10)
    
58.     {
    
59.         _first = _alloc.allocate(_size);
    
60.         _last = _first;
    
61.         _end = _first + _size;
    
62.     }
    
63. 
    
64.     vector(const vector& st)
    
65.     {
    
66.         int _size = st._end - st._first;
    
67.         _first = _alloc.allocate(_size);
    
68.         int _len = st._last- st._first;
    
69.         for (int i = 0; i < _len; i++)
    
70.         {
    
71.             _alloc.construct(_first + i, st._first[i]);
    
72.         }
    
73.         _last = _first + _len;
    
74.         _end = _first + _size;
    
75.     }
    
76. 
    
77.     vector& operator=(const vector& st)
    
78.     {
    
79.         if (this == &st)
    
80.             return *this;
    
81. 
    
82.         for (T* p = _first; p != _last; ++p) {
    
83.             _alloc.deleteallocate(p);
    
84.         }
    
85.         _alloc.freeallocate(_first);
    
86. 
    
87.         int _size = st._end - st._first;
    
88.         _first = _alloc.allocate(_size);
    
89.         int _len = st._last - st._first;
    
90.         for (int i = 0; i < _len; i++)
    
91.         {
    
92.             _alloc.construct(_first + i, st._first[i]);
    
93.         }
    
94.         _last = _first + _len;
    
95.         _end = _first + _size;
    
96.         return *this;
    
97.     }
    
98. 
    
99.     ~vector()
    
100.     {
     
101.         for (T* p = _first; p != _last; ++p) {
     
102.             _alloc.deleteallocate(p);
     
103.         }
     
104.         _alloc.freeallocate(_first);
     
105.     }
     
106. 
     
107.     void push(T val)
     
108.     {
     
109.         if (_end == _last)
     
110.         {
     
111.             expand();
     
112.         }
     
113.         _alloc.construct(_last++, val);
     
114.     }
     
115. 
     
116.     void popback()
     
117.     {
     
118.         if (_first == _last)
     
119.             return;
     
120.         _alloc.deleteallocate(--_last);
     
121.     }
     
122. 
     
123.     T back()
     
124.     {
     
125.         return *(_last - 1);
     
126.     }
     
127. 
     
128.     bool empty()
     
129.     {
     
130.         return _first == _last;
     
131.     }
     
132. 
     
133.     int size()
     
134.     {
     
135.         return _last - _first;
     
136.     }
     
137. };
     
138. 
     
139. int main()
     
140. {
     
141.     vector<int> p;
     
142.     for (int i = 0; i < 15; i++)
     
143.     {
     
144.         p.push(rand() % 100);
     
145.     }
     
146. 
     
147.     cout << "Vector contains: ";
     
148.     while (!p.empty())
     
149.     {
     
150.         cout << p.back() << " ";
     
151.         p.popback();
     
152.     }
     
153.     cout << endl;
     
154.     return 0;
     
155. }

复制代码

几个要点说明：
1. 使用 `template <typename T>` 来定义模板。
2. 确认使用 `new (p) T(value)` 来调用构造函数。
3. 注意将 `deleteallocte` 拼写改为 `deleteallocate`。
4. 在拷贝构造函数和赋值运算符中，正确地构造新的元素。
5. 在 `expand` 方法中，正确地将 `_first` 的元素迁移到新分配的内存。

希望这些改动可以解决你的问题！

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。