自定义Stack、Queue类

stack.cc
自定义stack类 使用数组元素模仿当中数据成员 若栈溢出则结束当前进程
circular_queue.cc
自定义队列类 使用数组元素模仿其中数据成员 循环队列避免单向队列的假溢出

#include <iostream>
#include <string.h>    //包含对于字符串的处理函数
using std::cout;
using std::endl;

class string{
public:
    string();
    string(const char* pstr);
    string(const string & rhs);
    string & operator=(const string & rhs);
    ~string();
    void print();
private:
    char *_pstr;
};

string::string()
:_pstr(new char [1])
{
    //*_pstr='\0';
    cout<< "string()"<<endl;
}

string::string(const char* pstr)             //带参数的构造函数初始化
:_pstr(new char [strlen(pstr)+1])
{
    cout<< "string(const char* pstr)"<<endl;
    strcpy(_pstr,pstr);
}

string::string(const string & rhs)       //复制构造函数  对象的复制
:_pstr(new char [strlen(rhs._pstr)+1])
{
    cout<< "string(const string & rhs)"<<endl;
    strcpy(_pstr,rhs._pstr);                
}

#if 0
string & string::operator=(const string & rhs)
{
    cout<< "string & operator=(const string & rhs)"<<endl;
    _pstr=new char [strlen(rhs._pstr)+1];    //初始化表达式只能用于构造函数初始化成员变量
    strcpy(_pstr,rhs._pstr);                  //strcpyh会补加'\0'
}
#endif

string & string::operator=(const string & rhs)
{
    if(this != &rhs) //1. 考虑自复制
    {
        delete [] _pstr;//2. 回收左操作数的空间,方便重新定义空间大小
        _pstr = new char[strlen(rhs._pstr) + 1]();//3. 再去进行深拷贝
        strcpy(_pstr, rhs._pstr);
    }
    return *this;
}


string::~string()
{
    delete  _pstr;
    _pstr=NULL;                            //避免出现野指针
    cout<<"~string() ok"<<endl;
}

void string::print(){
    cout<<"str = "<< _pstr <<endl;
}

int main(int argc,char** argv)
{
    string str1;
    str1.print();                        //无参数的构造函数

    string str2 = "Hello";    
    string str3("world");                //带参数的构造函数

    str2.print();       
    str3.print();   

    string str4 = str3;    // 深拷贝复制构造函数     类名(const 类名 & rhs)
    str4.print();

    str4 = str2;     //运算符的重载        类名 & operator=(const 类名 & rhs)
    str4.print();

    return 0;
}

circular_queue.cc
自定义队列类 使用数组元素模仿其中数据成员 循环队列避免单向队列的假溢出

//循环队列避免单向队列的假溢出
// front指向队首元素，rear指向队尾元素的下一个元素
//少用一个元素空间，约定  队空时： front==rear  队满时： (rear+1)%maxsize==front

#include <iostream>       
using std::cout;
using std::endl;
#define MaxSize 10

class queue{
private:
    unsigned int size;
    int* member;
    unsigned int _front;
    unsigned int rear;
public:
    queue();
    ~queue();
    void push(int);
    void pop();
    int front();
    int back();
    bool empty();
    bool full();

    int getrear();
    int get_front();
};

queue::queue()
:size(0)
,member(new int[MaxSize])
,_front(0)
,rear(0){}

queue::~queue(){
    delete [] member;
}

void queue::push(int num){
    if((rear+1)%MaxSize == _front) return ;
    else{
        member[rear]=num;
        rear = (rear+1)%MaxSize;
    }
}

void queue::pop(){
    if(rear==_front) return ;
    else _front = (_front+1)%MaxSize;
}

int queue::front(){
    if(rear!=_front) return member[_front];
}

int queue::back(){
    //if(rear!=_front) return member[rear-1];     //error 考虑元素不断pop,push后，rear==0时,rear-1成为负数
    /*if(rear!=_front){    //元素不为空
        if(rear==0) return member[MaxSize-1];
        else return member[rear-1];
    }*/
    if(rear!=_front) return member[(rear-1+MaxSize)%MaxSize];         //更加优雅
}

bool queue::empty(){
    return rear==_front?true:false;
}

bool queue::full(){
    return (rear+1)%MaxSize==_front?true:false;
}

int queue::getrear(){
    return rear;
}

int queue::get_front(){
    return _front;
}


int main(int argc,char** argv){
    queue que;
    cout<<"empty?"<<que.empty()<<endl;

    que.push(10);
    que.push(11);
    que.push(12);
    que.push(13);
    que.push(14);
    que.push(15);
    que.push(16);
    que.push(17);
    que.push(18);    //此时满队列

    cout<<"full?"<<que.full()<<endl;
    cout<<"front="<<que.front()<<endl;
    cout<<"rear="<<que.back()<<endl;

    que.pop();
    cout<<"full?"<<que.full()<<endl;
    cout<<"after pop,front="<<que.front()<<endl;
    cout<<"rear="<<que.back()<<"   "<<que.getrear()<<endl;

    que.push(19);
    cout<<"front="<<que.front()<<endl;
    cout<<"rear="<<que.back()<<"   "<<que.getrear()<<endl;
    cout<<"full?"<<que.full()<<endl;
    return 0;
}