模板实现vector\List；适配器适配栈和队列

最新推荐文章于 2023-02-09 15:26:22 发布
最新推荐文章于 2023-02-09 15:26:22 发布
阅读量210 收藏 1
点赞数 1
分类专栏： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cx2479750196/article/details/80293086
版权
这篇博客讨论了在实现模板类vector时遇到的深浅拷贝问题，特别是在处理如string这样的数据类型时可能出现的二次深浅拷贝错误。文章通过分析vector的内存管理和memcpy函数的使用，揭示了错误的原因。同时，博客还介绍了List、Queue和Stack的模板实现及其适配器的应用。
摘要由CSDN通过智能技术生成

1、vector.h

#pragma once
template <class T>
#include<string>//这里使用不带有.h的头文件
class vector{
public:
    void PushBack(const T& x){
        size_t size = Size();
        check_capacity();
        *_finish = x;
        _finish++;
    }

    void PopBack(){
        if (_start != _finish){
            --_finish;
        }
    }

    void Insert(size_t pos, const T& x){
        size_t size = Size();
        assert(pos <= size&&pos >= 0);
        check_capacity();
        for (size_t i = size; i > pos; i--){
            _start[i] = _start[i - 1];
        }
        _start[pos] = x;
        ++_finish;
    }

    void Erase(size_t pos){
        size_t size = Size();
        assert(pos <= size&&pos >= 0);
        for (size_t i = pos + 1; i < size; i++){
            _start[i - 1] = _start[i];
        }
        --_finish;
    }

    vector()//构造函数
        :_start(NULL)
        , _finish(NULL)
        , _endofstorage(NULL)
    {}

    vector(const vector<T>& v){
        //拷贝的时候会涉及到开空间，
        //如果拷贝的数据类型依然存在浅拷贝的问题则使用循环拷贝,切记不要使用memcpy
        size_t size = v.Size();
        T* tmp = new T[size];
        for (size_t i = 0; i < size; i++){
            tmp[i] = v[i];
        }
        delete[] _start;
        _start = tmp;
        _finish = _start + size;
        _endofstorage = _finish;
        //此处注意v的size一定要提前保存，不能使用_finish=_start+Size()
        //因为原空间已经释放Size()=finish-start就会出错
    }

    ~vector(){
        if (_start){
            delete[]_start;
            _start = _finish = _endofstorage = NULL;
        }
    }

    void Print(){
        size_t size = Size();
        for (size_t i = 0; i < size; i++){
            cout << _start[i] << " ";
        }
        cout << endl;
    }

    size_t Size(){
        return _finish - _start;
    }
    size_t Capacity(){
        return _endofstorage - _start;
    }
    void check_capacity(){
        //有错误
        /*size_t size = Size();
        size_t capacity = Capacity();
        if (size >= capacity){
            size_t n = 2 * capacity + 3;
            T* tmp = new T[n];
            delete[]_start;
            memcpy(_start, tmp, sizeof(T)*size);
            _start = tmp;
            _finish = _start + size;
            _endofstorage = _start + n;
        }*/
        if (size >= capacity){
            size_t n = 2 * capacity + 3;
            T* tmp = new T[n];
            for (size_t i = 0; i < size; i++){
                tmp[i] = _start[i];
            }
            delete[] _start;
            _start = tmp;
            _finish = _start + size;
            _endofstorage = _start + n;
        }
    }

    bool Empty(){
        return _start == _finish;
    }
    T& Front(){
        return _start[0];
    }
    const T& Front()const{
        return _start[0];
    }
    const T& Top()const{
        return *(_finish - 1);
    }
protected:
    T* _start;
    T* _finish;
    T* _endofstorage;
};

说一下vector在检查空间不够用是开空间的情况下，会涉及深浅拷贝问题，使用memcpy函数来拷贝原来的空间和数据会出错
因为这个出错不是说所有的数据类型都会出错，而是想string这样的类型本来就涉及深浅拷贝，开空间还要在涉及一次深浅拷贝，所以就有二次深浅拷贝这里写图片描述
为什么会出现这样的错误呢？
这里写图片描述
当字符长度不超过buf时，字符串存放在buf中，（buf是对象的成员）所以memcpy可以实现拷贝；但是当字符串超过那个长度就会用一个指针_start
来存放指向字符串的指针，拷贝空间时会析构原空间，所以析构掉_start
就会找不到对应的字符串了。

2、List.h

#pragma once
#include<assert.h>

template<class T>
class ListNode{
public:
    ListNode<T>* _prev;
    ListNode<T>* _next;
    T  _data;
    ListNode(const T& x)
        :_data(x)
        , _next(NULL)
        , _prev(NULL)
    {}
};


template<class T>
class List{
    typedef ListNode<T> Node;//ListNode是类名；ListNode<T>是类型
public:
    List(){
        _head = new Node(T());//利用缺省参数类型可以解决char、string等类型的参数传参
        _head->_prev = _head;
        _head->_next = _head;
    }
    ~List(){
        delete _head;
        _head = NULL;
    }
    void Insert(Node* pos, const T& x){
        assert(pos);
        //不论什么位置、有无节点都可以涵盖
        Node* pre = pos->_prev;
        Node* new_node = new Node(x);
        pre->_next = new_node;
        new_node->_prev = pre;
        new_node->_next = pos;
        pos->_prev = new_node;
    }
    void Erase(Node* pos){
        assert(pos || _head->_next != _head);
        Node* pre = pos->_prev;
        Node* next = pos->_next;
        delete pos;
        pre->_next = next;
        next->_prev = pre;
    }
    Node* Find(const T& x){
        /*if (head->_next == head){
            return NULL;
        }*/
        Node* cur = _head->_next;
        while (cur != _head){
            if (cur->_data == x){
                return cur;
            }
            cur = cur->_next;
        }
        return NULL;
    }
    void PushBack(const T& x){
        Insert(_head, x);
    }
    void PopBack(){
        Erase(_head->_prev);
    }
    void PushFront(const T& x){
        Insert(_head->_next, x);
    }
    void PopFront(){
        Erase(_head->_next);
    }
    //拷贝构造
    List(const List<T>& l){
        _head = new Node(T());
        _head->_prev = _head;
        _head->_next = _head;

        Node* cur = (l._head)->_next;
        while (cur != l._head){
            this->PushBack(cur->_data);
            cur = cur->_next;
        }
    }
    List<T>& operator=(const List<T>& l){
        if (this != &l){
            Node* cur = (l._head)->_next;
            while (cur != _head){
                this->PushBack(cur->_data);
                cur = cur->_next;
            }
        }
        return *this;
    }
    size_t Size(){
        Node* cur = _head->_next;
        size_t size = 0;
        while (cur != _head){
            size++;
            cur = cur->_next;
        }
        return size;
    }
    void Clear(){
        //删除头结点以外的节点
        Node* cur = _head->_next;
        while (cur != _head){
            Node* next = cur->_next;
            delete cur;
            cur = next;
        }
        _head->_prev = _head;
        _head->_next = _head;
    }
    bool Empty(){
        return _head->_next == _head;
    }
    const T& Front()const{
        return _head->_next->_data;
    }
    void Print(){
        Node* cur = _head->_next;
        while (cur != _head){
            cout << cur->_data << " ";
            cur = cur->_next;
        }
    }
protected:
    Node* _head;
};

3、Queue.h

#include"List.h"
#pragma once
template <class T, class Container>
class Queue{
public:
    void Push(const T& x){
        _con.PushBack(x);
    }
    void Pop(){
        _con.PopFront();
    }
    const T& Front()const{
        return _con.Front();
    }
    size_t Size(){
        return _con.Size();
    }
    bool Empty(){
        return _con.Empty();
    }
protected:
    Container _con;
};

4、Stack.h

#include"vector.h"
#pragma once
template <class T,class Container>
class Stack{
public:
    void Push(const T& x){
        _con.PushBack(x);
    }
    void Pop(){
        _con.PopBack();
    }
    const T& Top()const{
        return _con.Top();
    }
    size_t Size(){
        return _con.Size();
    }
    bool Empty(){
        return _con.Empty();
    }
protected:
    Container _con;
    //Container <T> _con;在容器这里将类型统一，
    //避免Stack<int,vector<char>> s;大于127时造成的缺陷
};
开始迷茫了
关注
专栏目录
适配器适配栈和队列
baidu_37964044的博客
03-05 212
适配器：其他容器转换适配出来，此篇博客就是用双向链表和顺序表适配出栈和队列 Queue.h #pragma once using namespace std; #include"List.h" #include"SeqList.h" template class Queue { public: void Push(const T&x) { _con.PushBack(x); }
【C++】STL之适配器---用deque实现栈和队列
最新发布
m0_63198468的博客
09-22 2524
本介绍了什么是适配器，deque，并且使用queue去实现了stack和queue，重点介绍了他们函数接口的使用，以及后面的stack和queue模拟实现。
vector实现栈（多多指教）
03-15
自己在学习的过程中写的，拿出来现一下，其实我是想拿分。。。
C++ STL 栈stack 向量vector 队列queue的用法
小白_努力
04-17 6732
栈的用法： 1.声明一个stack    stack s1;    stack s2; 2.stack中的操作     stack s;     s.push(x)      无返回值，将元素x压栈     s.pop();       退栈，无返回值     s.top();        取栈顶元素，返回栈顶元素     s.e
通过List和Vector来实现栈和队列
贵在坚持,我相信只要我努力,未来肯定是美好的!
05-06 748
栈/队列目录:一.实现栈(stack)1.Vector实现栈2.List实现栈二.实现队列(queue)1.List实现队列 目录: 一.实现栈(stack) 1.Vector实现栈 实现还是比较简单的,我们直接通过调用对应的迭代器来进行操作就可以了. class Stack1{ public: void push(const T& val){ _st.push_back(val); //直接调用vector的尾插操作 } void pop(){ _st.pop_.
适配器list
gongyaqi的博客
10-09 170
List newslist; Context cex; public Listbase(List newslist, Context cex) { this.newslist = newslist; this.cex = cex; } @Override public int getCount() { return newslist.size(); } @Overri
STL的栈和队列
w1724556613的博客
05-12 575
在stl库中，栈和队列是有其相对应的库的，所以我们不必再去写栈和队列，直接可以用库里的就行了，但是栈和队列在库中是如何实现的呢？让我们走进他们吧！ 首先我们可以了解一下使用，使用基本没啥差别，stack中有栈顶的插入删除，有大小，是否空等接口。 push 栈顶插入 pop 栈顶删除 size 大小 empty 判空 top 栈顶数据 queue中 只有取数据的时候，是front 和back，队头和队尾的数据。 了解完使用后，我们可以去想想，既然我们在C语言中实现它们是用数组和链表的，是不是stl中也是这样的
栈和队列--容器适配器
Ds19415169988的博客
12-08 713
stack.cpp #include <iostream> #include <stack> #include <queue> #include <forward_list> #include <algorithm> #include <list> using namespace std; //栈--后进先出 void test_stack() { stack<int> st; st.push(1); st.push(
C++:模板参数及利用容器适配器实现Stack和Queue
mxrrr_sunshine的博客
07-24 469
当我们再写栈和队列时，要借助数组或链表实现，c++就提供了这样一种方式：容器适配器。 用vector或list为容器，适配出一个stack或queue。具体是如何适配的？ 只要我vector或list提供的接口可以适合你stack或queue，就可以通过适配器适配出一个stack，queue。 template &amp;lt;class T,class Container&amp;gt; cla...
C++ 【list，priority_queue模拟实现】
我心如火
10-21 869
list模拟实现，迭代器和const迭代器，反向迭代器，priority_queue优先级队列，仿函数
android登录页面和adapter适配器实现的list列表
05-18
本程序实现了android登录功能以及list的adapter列表功能
STL （vector 栈 队列）
m0_63517133的博客
02-09 900
vector 队列 栈 STL的实现
【c++】模板实现vector和list
f2016913的博客
03-02 698
前面我们也知道模板是泛型编程的基础，是实现类型无关的代码，是一种代码复用的重要手段。 一：模板实现Vector: .h文件 #pragma once   #include #include #include using namespace std; template class Vector { public:     //构造     Vector()
使用deque容器适配器完成栈，队列的创建，使用vector实现优先级队列的创建，仿函数类的简单实现
weixin_40218502的博客
04-01 209
用container的deque实现栈和队列，以及仿函数类比较大小的实现 用deque实现栈stack template<class T,class Container = deque<T>> class Stack { public: void push(const T& val) { _c.push_back(val); } void pop() { _c.pop_back(); } const T& top() { return
ListAdapter列表适配器
weixin_30672019的博客
12-13 200
ListAdapter列表适配器其实是继承了BaseAdapter 示例图： MainActivity package com.shaoxin.mylistadapter; import android.app.ListActivity; import android.os.Bundle; import android.util.Log; import android.v...
栈和队列之间的转换
Wpan的博客
07-28 814
1、栈和队列都是限制性的线性表结构。 （1）、栈的元素存储顺序为：LIFO（先进后出） （2）、队列的元素粗春顺序为：FIFO（先进先出）   2、栈和队列之间相互转换的两个问题 （1）、用两个栈实现一个队列 思路：由于栈的存储顺序为“先进后出”，所以： 1）、可以将栈1作为一个插入栈，栈2作为一个弹出栈。 2）、将元素插入栈1，并判断栈2是否为
【技巧】通过适配器模式完成栈的数据结构
weixin_34362875的博客
03-18 88
学习了模板，我们发现，c++中的众多数据结构，如栈与队列跟模板，只是方法上与线性表不同，其真正意义上的结构，也就是线性表，代码如下：template<typenameT> classSeqList { private: int_size; int_capacity; T*_data; }; //temp...
java list适配器_详解listview的四种适配器模式
weixin_42100032的博客
03-02 820
ListView是Android开发中比较常用的一个组件，它以列表的形式展示具体内容，并且能够根据数据的长度自适应显示。比如说我们手机里的通讯录就使用到了ListView显示联系人信息。ListView同时也是所有Android UI控件中最为麻烦的控件，之所以麻烦就是因为它的各种的适配器特别麻烦。创建ListView有两种方式：1、直接创建ListView2、让Activity继承ListAct...
容器适配器-实现vector
MaiDang_的博客
03-14 333
#include&lt;iostream&gt; #include&lt;stack&gt; using namespace std; template&lt;typename _Ty&gt; class Vector { public: typedef _Ty value_type; public: Vector() { parr = new _Ty[2](); cursize...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值