Stack类

/* Stack类

#include"Stack.h"

Stack sta;声明变量

sta.push(x);

sta.pop();

sta.getTopInt();

sta.getTopDouble();

sta.getTopChar();

sta.Empty();

sta.Size();

sta.Clear();

sta.DiplayDataType();*/

#include<stdio.h>

#include<stdlib.h>

#include<string.h>

class Stack

{

//成员变量

private:

int *Base_Int;

double *Base_Double;

char *Base_Char;

int Size_Stack;

int Size_Increase;

int Length_Stack;

int *Top_Int;

double *Top_Double;

char *Top_Char;

int flag;//标记数值类型

public:

//构造函数

Stack()

{

flag=0;

Size_Stack=50;

Size_Increase=20;

Length_Stack=0;

}

//析构函数

~Stack()

{

if(flag==1) free(Base_Int);

if(flag==2) free(Base_Double);

if(flag==3) free(Base_Char);

}

//成员函数

//push(int)函数

bool push(int Int)

{

if(!flag)

{

Base_Int = Top_Int = (int*)malloc(Size_Stack*sizeof(int));

if(!Base_Int) {printf("内存分配失败！\n");return false;}

flag=1;//标记为整型

}

if(flag==1)

{

if(Length_Stack>=Size_Stack)//内存不够

{

(int *)realloc(Base_Int,(Size_Stack + Size_Increase)*sizeof(int));

if(!Base_Int) {printf("内存分配失败！\n");return false;}

Top_Int = Base_Int+Size_Stack;

}

Size_Stack += Size_Increase;

++Length_Stack;

*Top_Int++=Int;

}

else {printf("数值类型不匹配！\n");return false;}

return true;

}

//push(double)函数

bool push(double Double)

{

if(!flag)

{

Base_Double = Top_Double = (double*)malloc(Size_Stack*sizeof(double));

if(!Base_Double) {printf("内存分配失败！\n");return false;}

flag=2;//标记为浮点型

}

if(flag==2)

{

if(Length_Stack>=Size_Stack)//内存不够

{

(double *)realloc(Base_Double,(Size_Stack + Size_Increase)*sizeof(double));

if(!Base_Double) {printf("内存分配失败！\n");return false;}

Top_Double = Base_Double+Size_Stack;

}

Size_Stack += Size_Increase;

++Length_Stack;

*Top_Double++=Double;

}

else {printf("数值类型不匹配！\n");return false;}

return true;

}

//push(char)函数

bool push(char Char)

{

if(!flag)

{

Base_Char = Top_Char = (char*)malloc(Size_Stack*sizeof(char));

if(!Base_Char) {printf("内存分配失败！\n");return false;}

flag=3;//标记为字符型

}

if(flag==3)

{

if(Length_Stack>=Size_Stack)//内存不够

{

(char *)realloc(Base_Char,(Size_Stack + Size_Increase)*sizeof(char));

if(!Base_Char) {printf("内存分配失败！\n");return false;}

Top_Char = Base_Char+Size_Stack;

}

Size_Stack += Size_Increase;

++Length_Stack;

*Top_Char++=Char;

}

else {printf("数值类型不匹配！\n");return false;}

return true;

}

//pop函数

void pop()

{

if(flag == 1 && Top_Int!=Base_Int)

{

//printf("@@");////

--Length_Stack;

--Top_Int;

if(!Length_Stack) {flag=0;free(Base_Int);}

}

else if(flag==2 && Top_Double!=Base_Double)

{

--Length_Stack;

--Top_Double;

if(!Length_Stack) {flag=0;free(Base_Double);}

}

else if(flag==3 && Top_Char!=Base_Char)

{

--Length_Stack;

--Top_Char;

if(!Length_Stack) {flag=0;free(Base_Char);}

}

}

//top函数

int getTopInt()

{

if(flag==1 && Top_Int!=Base_Int) return *(Top_Int-1);

else printf("操作有误！\n");

return 0;

}

double getTopDouble()

{

if(flag==2 && Top_Double!=Base_Double) return *(Top_Double-1);

else printf("操作有误！\n");

return 0.0;

}

char getTopChar()

{

if(flag==3 && Top_Char!=Base_Char) return *(Top_Char-1);

else printf("操作有误！\n");

return '\n';

}

//Empty函数

bool Empty()

{

return !Length_Stack;

}

//Size函数

int Size()

{

return Length_Stack;

}

//Clear函数

void Clear()

{

if(flag==1) Top_Int=Base_Int;

else if(flag==2) Top_Double=Base_Double;

else Top_Char=Base_Char;

Length_Stack=0;

if(flag==1) free(Base_Int);

else if(flag==2) free(Base_Double);

else if(flag==3) free(Base_Char);

flag=0;

}

//显示数据类型

void DisplayDataType()

{

if(flag==1) printf("int\n");

else if(flag==2) printf("double\n");

else if(flag==3) printf("char\n");

else printf("null\n");

}

};