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;
}