STL-Lesson001_2_实现MyStack类

最新推荐文章于 2022-03-18 14:42:49 发布
最新推荐文章于 2022-03-18 14:42:49 发布
阅读量427 收藏
点赞数
分类专栏： STL
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011371629/article/details/78838392
版权

MyArray

/*MyArray.h*/

#ifndef _MYARRAY_H_
#define _MYARRAY_H_
#include <limits>

namespace PoEdu
{
    template<typename T>
    class MyArray
    {
    public:
        // Member functions
        MyArray();
        MyArray(const MyArray &other);
        MyArray(size_t n, const T &val);
        MyArray(const T *first, const T *last);
        MyArray &operator=(const MyArray &other);
        ~MyArray();

        // Iterators:
        T *Begin() const;
        T *End() const;
        T *Rbegin() const;
        T *Rend() const;

        // Capacity:
        size_t Size() const;
        size_t Max_size() const;
        void Resize(size_t len, T str);
        size_t Capacity() const;
        bool Empty() const;
        void Reserve(size_t len);

        // Element access:
        T &operator[](size_t index);
        const T &operator[](size_t index) const;
        T &At(size_t index);
        const T &At(size_t index) const;
        T &Front();
        const T &Front() const;
        T &Back();
        const T &Back() const;

        // Modifiers:
        void Assign(size_t len, const T& other);
        void Push_back(const T &val);
        void Pop_back();
        void Insert(size_t pos, size_t len, const T &other);
        T *Erase(size_t pos);
        T *Erase(size_t first, size_t last);
        void Swap(MyArray &other);
        void Clear();

    private:
        T *data_;
        size_t size_;
        // 加上默认分配一定空间大小的变量
        size_t capacity_;
        const size_t max_size_;
    };



    template<typename T>
    MyArray<T>::MyArray() : max_size_(UINT_MAX / 4)
    {
        size_ = 0;
        capacity_ = 5;
        data_ = new T[capacity_];
    }
    template<typename T>
    inline MyArray<T>::MyArray(const MyArray & other) : max_size_(UINT_MAX / 4)
    {
        if (&other != this)
        {
            size_ = other.size_;
            capacity_ = other.capacity_;
            data_ = new T[capacity_];
            for (size_t i = 0; i < size_; ++i)
            {
                data_[i] = other.data_[i];
            }
        }
    }
    template<typename T>
    MyArray<T>::MyArray(size_t n, const T & val) : max_size_(UINT_MAX / 4)
    {
        size_ = n;
        capacity_ = 5;
        while (capacity_ < size_)
        {
            capacity_ *= 2;
        }
        data_ = new T[size_];
        for (size_t i = 0; i < size_; ++i)
        {
            data_[i] = val; // 等号一定是提升出来的
        }
    }
    template<typename T>
    MyArray<T>::MyArray(const T * first, const T * last) : max_size_(UINT_MAX / 4)
    {
        size_ = (last - first) / sizeof(T);
        data_ = new T[capacity_];
        T *pAddr = const_cast<T *>(first);

        for (size_t i = 0; i < size_; ++i)
        {
            data_[i] = *pAddr;
            pAddr += sizeof(T);
        }
    }
    template<typename T>
    MyArray<T> & MyArray<T>::operator=(const MyArray & other)
    {
        if (&other != this)
        {
            delete[] data_;
            size_ = other.size_;
            capacity_ = other.capacity_;
            data_ = new T[capacity_];
            for (size_t i = 0; i < size_; ++i)
            {
                data_[i] = other.data_[i];
            }
        }

        return *this;
    }
    template<typename T>
    MyArray<T>::~MyArray()
    {
        delete[] data_;
    }
    template<typename T>
    T * MyArray<T>::Begin() const
    {
        return data_;
    }
    template<typename T>
    T * MyArray<T>::End() const
    {
        return &(data_[size_]);
    }
    template<typename T>
    T * MyArray<T>::Rbegin() const
    {
        return End();
    }
    template<typename T>
    T * MyArray<T>::Rend() const
    {
        return Begin();
    }
    template<typename T>
    size_t MyArray<T>::Size() const
    {
        return size_;
    }
    template<typename T>
    size_t MyArray<T>::Max_size() const
    {
        return size_;
    }
    template<typename T>
    void MyArray<T>::Resize(size_t len, T str)
    {
        if (len < size_)
        {
            // 销毁后面的几个元素
            for (size_t index = size_ - 1; index >= len; --index)
            {
                Pop_back();
            }
        }
        else
        {
            // 以str来填充后面的元素
            for (size_t index = size_; index < len; ++index)
            {
                Push_back(str);
            }
        }
    }
    template<typename T>
    size_t MyArray<T>::Capacity() const
    {
        return capacity_;
    }
    template<typename T>
    bool MyArray<T>::Empty() const
    {
        return !size_;
    }
    template<typename T>
    void MyArray<T>::Reserve(size_t len)
    {
        if (len > size_)
        {
            for (size_t index = size_; index < len; ++index)
            {
                Push_back("");
            }
        }
    }
    template<typename T>
    T& MyArray<T>::operator[](size_t index)
    {
        return const_cast<T&>(static_cast<const MyArray &>(*this)[index]);
    }
    template<typename T>
    const T & MyArray<T>::operator[](size_t index) const
    {
        return data_[index];
    }
    template<typename T>
    T & MyArray<T>::At(size_t index)
    {
        return const_cast<T &>(static_cast<const MyArray &>(*this).At(index));
    }
    template<typename T>
    const T & MyArray<T>::At(size_t index) const
    {
        size_t temp = index;
        if (index >= size_)
        {
            std::cout << "超出范围" << std::endl;
            temp = size_ - 1;
        }

        return data_[temp];
    }
    template<typename T>
    T & MyArray<T>::Front()
    {
        return const_cast<T &>(static_cast<const MyArray &>(*this).Front());
    }
    template<typename T>
    const T & MyArray<T>::Front() const
    {
        return At(0);
    }
    template<typename T>
    T & MyArray<T>::Back()
    {
        return const_cast<T &>(static_cast<const MyArray &>(*this).Back());
    }
    template<typename T>
    const T & MyArray<T>::Back() const
    {
        return At(size_ - 1);
    }
    template<typename T>
    void MyArray<T>::Assign(size_t len, const T & other)
    {
        delete[] data_;
        memset(data_, 0, capacity_ * sizeof(T));
        if (len < size_)
        {
            for (size_t index = 0; index < len; ++index)
            {
                data_[index] = other;
            }
        }
        else
        {
            size_ = len;
            while (capacity_ < size_)
            {
                capacity_ *= 2;
            }
            data_ = new T[capacity_];
            for (size_t index = 0; index < size_; ++index)
            {
                data_[index] = other;
            }
        }
    }
    template<typename T>
    void MyArray<T>::Push_back(const T & val)
    {
        while (capacity_ < size_)
        {
            capacity_ += 5;
        }
        T *temp = new T[size_ + 1];
        for (size_t i = 0; i < size_; ++i)
        {
            temp[i] = data_[i];
        }
        temp[size_] = val;
        size_ += 1;
        delete[] data_;
        data_ = temp;
    }
    template<typename T>
    void MyArray<T>::Pop_back()
    {
        T *temp = new T[capacity_];
        memset(temp, 0, capacity_ * sizeof(T));
        --size_;
        for (size_t index = 0; index < size_; ++index)
        {
            temp[index] = data_[index];
        }
        delete[] data_;
        data_ = temp;
    }
    template<typename T>
    void MyArray<T>::Insert(size_t pos, size_t len, const T & other)
    {
        T *temp = new T[size_ + len];
        for (size_t index = 0; index < pos; ++index)
        {
            temp[index] = data_[index];
        }
        for (size_t index = pos; index < pos + len; ++index)
        {
            temp[index] = other;
        }
        for (size_t index = pos + len; index < size_ + len; ++index)
        {
            temp[index] = data_[index - len];
        }
        size_ += len;
        delete[] data_;
        data_ = temp;
    }
    template<typename T>
    T * MyArray<T>::Erase(size_t pos)
    {
        T *temp = new T[capacity_];
        memset(temp, 0, capacity_ * sizeof(T));
        for (size_t index = 0; index < pos; ++index)
        {
            temp[index] = data_[index];
        }
        for (size_t index = pos; index < size_ - 1; ++index)
        {
            temp[index] = data_[index + 1];
        }
        --size_;
        delete[] data_;
        data_ = temp;

        return &(data_[pos]);
    }
    template<typename T>
    T * MyArray<T>::Erase(size_t first, size_t last)
    {
        T *temp = new T[capacity_];
        memset(temp, 0, capacity_ * sizeof(T));
        for (size_t index = 0; index < first; ++index)
        {
            temp[index] = data_[index];
        }
        for (size_t index = first; index < size_ - (last - first); ++index)
        {
            temp[index] = data_[index + last - first];
        }

        size_ -= (last - first);
        delete[] data_;
        data_ = temp;

        return &(data_[first]);
    }
    template<typename T>
    void MyArray<T>::Swap(MyArray & other)
    {
        MyArray temp(other);
        other = *this;
        *this = temp;
    }
    template<typename T>
    void MyArray<T>::Clear()
    {
        delete[] data_;
    }
}

#endif // !_MYARRAY_H_


/*MyArray.cpp*/

#include "MyArray.h"
都在头文件中已经实现了

MyStack

/*MyStack.h*/

#ifndef _MYSTACK_H_
#define _MYSTACK_H_
#include "MyArray.h"

namespace PoEdu
{
    template <typename T, typename CON = MyArray<T> >
    class MyStack
    {
    public:
        MyStack() : c(){}
        MyStack(const MyStack &other) : c(other){}
        explicit MyStack(const CON &val) : c(val){}
        MyStack& operator=(const MyStack& other)
        {
            c = other.c;
            return (*this);
        }

        bool Empty() const
        {
            return c.Empty();
        }

        size_t Size() const
        {
            return c.Size();
        }

        T &Top()
        {
            return c.Back();
        }
        const T &Top() const
        {
            return c.Back();
        }

        void Push(const T& val)
        {
            c.Push_back(val);
        }

        // 先假定和Push是一模一样的
        void Emplace(const T& val)
        {
            c.Push_back(val);
        }

        void Pop()
        {
            c.Pop_back();
        }

        void Swap(MyStack &other) noexcept
        {
            c.Swap(other.c);
        }


    protected:
        CON c;
        //MyArray c;
    };
}

#endif // !_MYSTACK_H_


/*MyStack.cpp*/
// 都在头文件中实现了

Test

#include <iostream>
#include "MyStack.h"

int main()
{
    using namespace PoEdu;

    MyStack<int, MyArray<int> > Demo;
    MyStack<int, MyArray<int> > Other;

    std::cout << "Demo before Push.." << std::endl;
    std::cout << "whether Empty: " << Demo.Empty() << std::endl;
    std::cout << "Demo test Push, Top, Size, and Empty..." << std::endl;
    Demo.Push(1);
    std::cout << "Push element: " << 1 << std::endl;
    std::cout << "Top elmemt: " << Demo.Top() << std::endl;
    std::cout << "stack size: " << Demo.Size() << std::endl;
    std::cout << "whether Empty: " << Demo.Empty() << std::endl;
    Demo.Push(2);
    std::cout << "Push element: " << 2 << std::endl;
    std::cout << "Top elmemt: " << Demo.Top() << std::endl;
    std::cout << "stack Size: " << Demo.Size() << std::endl;
    std::cout << "whether Empty: " << Demo.Empty() << std::endl;
    std::cout << std::endl;

    std::cout << "Other before Emplace.." << std::endl;
    std::cout << "whether Empty: " << Other.Empty() << std::endl;
    std::cout << "Other test Emplace, Top, Size, and Empty..." << std::endl;
    Other.Emplace(11);
    std::cout << "Emplace element: " << 11 << std::endl;
    std::cout << "top Elmemt: " << Other.Top() << std::endl;
    std::cout << "stack Size: " << Other.Size() << std::endl;
    std::cout << "whether Empty: " << Other.Empty() << std::endl;
    Other.Emplace(12);
    std::cout << "emplace Element: " << 12 << std::endl;
    std::cout << "top Elmemt: " << Other.Top() << std::endl;
    std::cout << "stack Size: " << Other.Size() << std::endl;
    std::cout << "whether Empty: " << Other.Empty() << std::endl;
    std::cout << std::endl;

    std::cout << "test Swap, Top..." << std::endl;
    Demo.Swap(Other);
    std::cout << "Demo Top: " << Demo.Top() << std::endl;
    std::cout << "Other top: " << Other.Top() << std::endl;
    std::cout << std::endl;

    std::cout << "Demo test Pop.." << std::endl;
    std::cout << "Demo before Pop.." << std::endl;
    std::cout << "Top elmemt: " << Demo.Top() << std::endl;
    std::cout << "stack size: " << Demo.Size() << std::endl;
    std::cout << "whether Empty: " << Demo.Empty() << std::endl;
    Demo.Pop();
    std::cout << "Top elmemt: " << Demo.Top() << std::endl;
    std::cout << "stack Size: " << Demo.Size() << std::endl;
    std::cout << "whether Empty: " << Demo.Empty() << std::endl;
    Demo.Pop();
    std::cout << "whether Empty: " << Demo.Empty() << std::endl;
    std::cout << std::endl;

    return 0;
}

这里写图片描述

艺术人生666
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
MyStack 一个堆栈的模板类
02-21
自己写的堆栈模板类,感觉很好用，不过push 和 pop直接返回对象 所以，对象一点要有拷贝构造，
mystack.zip
03-15
使用C++模板类实现基本数据结构--栈，封装MyStack类，可以用于学习堆栈的基本操作。使用时，包含头文件，创建对象即可，方便快捷！
Java、利用继承实现MyStack
m0_62659797的博客
03-18 614
package pack1; import java.util.ArrayList; public class MyStack<E> extends ArrayList<E> { public MyStack() { } public MyStack(int initialCapacity) { super(initialCapacity); } public boolean push(E element) { ...
使用js栈stack类的实现
weixin_33852020的博客
04-06 149
使用js栈stack类的实现 /*使用栈stack类的实现*/ function stack() { this.dataStore = [];//保存栈内元素，初始化为一个空数组 this.top = 0;//栈顶位置，初始化为0 this.push = push;//入栈 this.pop = pop;//出栈 this.peek = peek;//查看...
java 实现 堆栈
lining213的专栏
11-26 437
<br /><br />package com.fanxing.lining.last;<br /> <br />public class LinkStack <T>{<br />private class Node<U>{<br />U item;<br />Node<U> next;<br />Node(){<br />this.item=null;<br />this.next=null;<br />}<br />Node(U item,Node<U> next){<br />this.item=it
MyStack
weixin_34175509的博客
09-05 191
#pragma once class MyQueue { public: MyQueue(); ~MyQueue(); void Insert(int aValue); int Top(); void Pop(); void PrintQueue(); void PrintHead(); privat...
SGI-STL-.rar_STL_sgi stl
09-21
这个压缩包“SGI-STL-.rar_STL_sgi stl”包含了SGI（Silicon Graphics, Inc.）版本的STL源码，这是一个经典的STL实现，对深入理解STL的内部工作原理非常有帮助。STL由Alexander Stepanov和Menas C. Kafatos在1985年...
STL-queue--.rar_stl queue
09-24
在这个压缩包中，重点是关于STL中的`queue`容器及其应用的实现，主要针对VC++环境。`queue`在C++中是一个非常基础且实用的数据结构，它模拟了现实世界中的先进先出（FIFO，First In First Out）原则，通常用于处理...
STL-.rar_C 知识点
09-24
在STL中，`std::stack`模板类实现了栈的功能。你可以使用任何支持迭代器的容器作为底层实现，如`std::vector`或`std::deque`。栈的主要操作包括`push()`（入栈）、`pop()`（出栈）、`top()`（查看栈顶元素）和`empty...
stl-view.rar_ STL _stl view_stl 3D_stl 3d view_stl-view
09-23
"stl-view.rar" 是一个压缩包，其中包含了一个名为 "stl-view" 的小软件，这个软件专门用于查看STL文件。用户可以通过这个工具自由地旋转3D模型，以便从不同角度检查模型的细节。对于设计师、工程师和3D打印爱好者来...
STL-Manual.rar_stl chm
09-23
STL手册，如"STL-Manual.rar_stl chm"中包含的"STL Manual.chm"，是一个极其重要的资源，适合开发者在学习和开发过程中查阅。下面我们将深入探讨STL的核心概念和关键组件。 1. 容器： - **vector**：动态数组，...
javaMyStack源代码
08-16
因为SUN的Stack不是严格意义上的stack,因此需要重写下，是这样的
ArrayList类的实现
Jock的博客
01-27 523
首先来说明实现细节： MyArrayList将保持基础数组，数组的容量，以及存储在MyArrayList中的当前项数。 MyArrayList将提供一种机制来改变基础数组的容量，通过获得一个新的数组，并将老数组拷贝到新数组中来改变数组容量。 MyArrayList将提供get、set的实现 MyArrayList将提供基本的例程，如size、isEmpty和clear，以及remove和a
堆栈和队列的实现
丿灬安之若死
04-12 364
1.使用数组实现,代码和结果如下所示: 要求： 写Stack.java，实现堆栈功能，使用int数组保存数据特点：先进后处 后进先出    写Queue.java，实现队列功能，使用int数组保存数据特点：先进先出 后进后出  使用Test.java对堆栈和队列进行测试 如下所示，分别为实现方法： 首先实现stack.java类，其代码如下所示：
继承的拓展(利用组合来实现复用)
qq_1689651368的博客
07-13 529
假设有3个类：Animal、Wolf、Bird 新建一个Animal类            全部在包中 package org; class Animal{ private void beat(){ System.out.println("心脏跳动..."); } public void breath(){ beat(); System.out.println("吸一口气,
关于stack
weixin_34284188的博客
03-24 66
下面是MyStack.h的代码： #pragma once #ifndef MY_STACK #define MY_STACK class MyStack { struct Link{ void * data; Link * next; void initialize(void * dat,Link * nxt)...
CUDA_VISIBLE_DEVICES=0 python end2end.py --config_env configs/env.yml --config_exp configs/end2end/end2end_cifar10.yml CUDA_VISIBLE_DEVICES=0 python end2end.py --config_env configs/env.yml --config_exp configs/end2end/end2end_cifar20.yml CUDA_VISIBLE_DEVICES=0 python end2end.py --config_env configs/env.yml --config_exp configs/end2end/end2end_imagenet10.yml CUDA_VISIBLE_DEVICES=0 python end2end.py --config_env configs/env.yml --config_exp configs/end2end/end2end_imagenet_dogs.yml CUDA_VISIBLE_DEVICES=0 python end2end.py --config_env configs/env.yml --config_exp configs/end2end/end2end_tiny_imagenet.yml CUDA_VISIBLE_DEVICES=0 python end2end.py --config_env configs/env.yml --config_exp configs/end2end/end2end_stl10.yml
最新发布
07-08
例如，第一个命令 `CUDA_VISIBLE_DEVICES=0 python end2end.py --config_env configs/env.yml --config_exp configs/end2end/end2end_cifar10.yml` 表示使用第一个GPU设备运行 `end2end.py` 脚本，并传递 `configs/...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值