1. memcpy是內存的二進制格式拷貝，將一段內存空間中內容原封不動的拷貝到另外一段內存空間中 2. 如果拷貝的是自定義類型的元素， memcpy 既高效又不會出錯，但 如果拷貝的是自定義類型元素，并且自定義類型元素中涉及到資源管理時，就會出錯，因為memcpy的拷貝實際是淺拷貝。

這個和之前講拷貝構造的時候很像，都是淺拷貝導致的問題。?可能會引起內存泄漏甚至程序崩潰。

在前面就已經看過了二維數組的題了，這里不過多介紹，還是介紹一下memcpy也會使內存崩潰的結果：

要解決這個問題，我們還是要進行深拷貝，這是下面的reserve的模擬實現代碼來解決這個問題：

我們可以通過這個一個對象賦值的方式來進行深拷貝

templateclass vector
    {
    public:
        // Vector的迭代器是一個原生指針
            typedef T* iterator;
            typedef const T* const_iterator;

            iterator begin()
            {
                return _start;
            }
            iterator end()
            {
                return _end;
            }
            const_iterator cbegin()
            {
                return _start;
            }
            const_iterator cend() const
            {
                return _end;
            }

            // construct and destroy

            vector()
                :_start(nullptr)
                ,_end(nullptr)
                ,_endOfStorage(nullptr)
            {}

            vector(int n, const T& value = T())
                :_start(nullptr)
                , _end(nullptr)
                , _endOfStorage(nullptr)
            {
                reserve(n);
                for (int i = 0; i< n; ++i)
                {
                    push_back(value);
                }
            }

            templatevector(InputIterator first, InputIterator last)
                :_start(nullptr)
                , _end(nullptr)
                , _endOfStorage(nullptr)
            {
                while (first != last)
                {
                    push_back(*first);
                    ++first;
                }
            }

            vector(const vector& v)
                :_start(nullptr)
                , _end(nullptr)
                , _endOfStorage(nullptr)
            {
                //找個工具人
                vectortmp(v._start, v._end);
                swap(tmp);
            }

            vector& operator= (vectorv)
            {
                swap(v);
                return *this;
            }

            ~vector()
            {
                delete[] _start;
                _start = _end = _endOfStorage = nullptr;
            }

            // capacity

            size_t size() const
            {
                return _end - _start;
            }

            size_t capacity() const
            {
                return _endOfStorage - _start;
            }

            void reserve(size_t n)
            {
                //堅持不縮容
                if (n >capacity())
                {
                    //開辟新的空間，然后賦值過去
                    T* tmp = new T[n];
                    size_t oldsize = size();
                    if (_start)
                    {
                        for (size_t i = 0; i< oldsize; ++i)
                        {
                            tmp[i] = _start[i];
                        }
                        delete[]_start;
                    }
               
                    _start = tmp;
                    _end = _start + oldsize;
                    _endOfStorage = _start + n;
                }
            }

            void resize(size_t n, const T& value = T())
            {
                //要擴容
                if (n >capacity())
                {
                    int newcapacity = capacity() == 0 ? 4 : 2 * capacity();
                    reserve(newcapacity);
                }
    
                if (n >size())
                {
                    while (_end != _start + n)
                    {
                        push_back(value);
                    }
                }
                else
                {
                    _end = _start + n;
                }
            }



            ///access///

            T& operator[](size_t pos)
            {
                assert(pos< size());
                return _start[pos];
            }

            const T& operator[](size_t pos)const
            {
                assert(pos< size());
                return _start[pos];
            }



            ///modify/

            void push_back(const T& x)
            {
                if (size() == capacity())
                {
                    int newcapacity = capacity() == 0 ? 4 : 2 * capacity();
                    reserve(newcapacity);
                }
                *_end = x;
                ++_end;
            }

            void pop_back()
            {
                assert(_end >_start);
                --_end;
            }

            void swap(vector& v)
            {
                std::swap(_start, v._start);
                std::swap(_end, v._end);
                std::swap(_endOfStorage, v._endOfStorage);
            }

            iterator insert(iterator pos, const T& x)
            {
                assert(_start<= pos);
                assert(_end >pos);
                //判斷增容
                int distance = pos - _start;
                if (_end == _endOfStorage)
                {
                    int newcapacity = capacity() == 0 ? 4 : 2 * capacity();
                    reserve(newcapacity);
                    //這里的擴容不處理會導致迭代器失效
                    pos = _start + distance;
                }
                //挪動數據，插入
                auto end = _end -1;
                while (end >= pos)
                {
                    *(end+1) = *end;
                    --end;
                }
                *pos = x;
                ++_end;
                return pos;
            }

            iterator erase(iterator pos)
            {
                assert(pos >= _start);
                assert(pos< _end);
                //挪動數據
                iterator  ret = pos + 1;
                while (ret< _end)
                {
                    *(ret - 1) = *ret;
                    ++ret;
                }
                --_end;
                return pos;
            }

    private:
        iterator _start; // 指向數據塊的開始
        iterator _end; // 指向有效數據的尾
        iterator _endOfStorage; // 指向存儲容量的尾
    };

其中實現過程中最容易錯誤的就是insert以及erase擴容問題，這是最容易出錯的。

擴容是防止淺拷貝，所有把利用賦值來實現深拷貝。insert以及erase要注意更新迭代器，防止迭代器失效。

你是否還在尋找穩定的海外服務器提供商？創新互聯www.cdcxhl.cn海外機房具備T級流量清洗系統配攻擊溯源，準確流量調度確保服務器高可用性，企業級服務器適合批量采購，新人活動首月15元起，快前往官網查看詳情吧

網頁題目：C++vector-創新互聯
網站路徑：http://www.yijiale78.com/article6/dddpog.html

成都網站建設公司_創新互聯，為您提供建站公司、網站排名、營銷型網站建設、Google、云服務器、網站制作

廣告

聲明：本網站發布的內容（圖片、視頻和文字）以用戶投稿、用戶轉載內容為主，如果涉及侵權請盡快告知，我們將會在第一時間刪除。文章觀點不代表本網站立場，如需處理請聯系客服。電話：028-86922220；郵箱：631063699@qq.com。內容未經允許不得轉載，或轉載時需注明來源： 創新互聯