C++|一个简单小实例了解结构体与类自定义顺序栈及模板

一个实例了解诸多语法特性：

由一个简单的十进制转二进制的小实例开始。

可以写成递归的顺序，比较一下迭代与递归的对应关系。

可以同时实现控制台输出与文件输出。

可以使用标准库提供的栈。

也可以使用结构体+全局函数自定义一个顺序栈结构体及操作。

也可以使用类自（数据成员+成员函数）定义一个顺序栈类。

也可以将顺序栈类升级为模板类。

这些可以大致了解C++的抽象过程（当然未包括其精髓所在：继承与多态，需要更深入，这里只是入门一下C++的语法）。

细节见代码注释：

#include <stdio.h>
#include <stack>
using namespace std;

void d2bSeqenceStack(int n)// decimal to binary
{
    int data[64] = {0};
    int top = 0;
    do
        data[top++] = n%2;
    while(n/=2);
    for(int i=top-1;i>=0;i--)
        printf("%d",data[i]);
}

void d2bIncursion(int n)
{
    if(n>0)
    {
        d2bIncursion(n/2);
        FILE *fp;
        fp = fopen("C:\\test.txt","a+");
        if(!fp)
        {
            printf("打开文件出了问题！");
            exit(-1);
        }
        fputc(n%2+'0',fp);
        printf("%d",n%2);
        fclose(fp);
    }
}

void d2bOutput2File()
{
    for(int i=0;i<128;i++)
    {
        FILE *fp = fopen("C:\\test.txt","a+");
        fprintf(fp,"%d %c\t",i,i);
        //fflush(fp);
        printf("%d %c\t",i,i);
        d2bIncursion(i);
        fputc('\n',fp);
        fclose(fp);
        printf("\n");
    }
}

// 为方便对比，将结构体+函数 与类+成员函数的代码对照写
#define MAXSIZE 64
typedef struct mySequenceStack{   // 固定大小的stack类，后面搭配全局函数
    int data[MAXSIZE];
    int idx;
    mySequenceStack(){
        idx = 0;
    }
}Mss;

class CMss                          // 固定大小的stack类，搭配成员函数
{
    int *data;
    int idx;
public:
    CMss(){
        data = new int[MAXSIZE];
        idx = 0;
    }
    bool isFull();
    bool push(int val);
    bool empty();
    bool pop();
    int top();
};

bool CMss::isFull(){
    return idx>=MAXSIZE;
}

bool isFull(Mss& mss){
    return mss.idx>=MAXSIZE;
}

bool push(Mss& mss,int val){
    if(!isFull(mss))
    {
        mss.data[mss.idx++] = val;
        return true;
    }
    else
        return false;
}

bool CMss::push(int val){
    if(!isFull())
    {
        data[idx++] = val;
        return true;
    }
    else
        return false;
}

bool empty(Mss& mss){
    return mss.idx<=0;
}

bool CMss::empty(){
    return idx<=0;
}

bool pop(Mss& mss)
{
    if(empty(mss))
    {
        return false;
    }
    else{
        mss.idx--;
        return true;
    }
}

bool CMss::pop()
{
    if(empty())
    {
        return false;
    }
    else{
        idx--;
        return true;
    }
}

int top(Mss& mss){
    return mss.data[mss.idx];
}

int CMss::top(){
    return data[idx];
}

void d2bByLibStack(int n)
{
    stack<int> st;      // 标准库中的stack
    do
         st.push(n%2);
    while(n/=2);
    while(!st.empty())
    {
        printf("%d",st.top());
        st.pop();
    }
}

void d2bByMyStack(int n)
{
    Mss st;         // 自定义C的MyStack
    do
         push(st,n%2);
    while((n/=2) && (!isFull(st)));
    while(!empty(st))
    {
        
        pop(st);
        printf("%d",top(st));
    }
}

void d2bByMyStackClass(int n)
{
    CMss st;        // 自定义C++的MyStack（固定大小）
    do
         st.push(n%2);
    while((n/=2) && (!st.isFull()));
    while(!st.empty())
    {
        st.pop();
        printf("%d",st.top());
    }
}

class CMssD           // 定义一个能动态增长空间的stack类
{
    int *data;
    int idx;
    int capacity;
public:
    CMssD(){
        data = new int[MAXSIZE];
        capacity = MAXSIZE;
        idx = 0;
    }
    bool push(int val);
    bool empty();
    bool pop();
    int top();
};

bool CMssD::push(int val){
    if(capacity > idx)
    {
        data[idx++] = val;
        return true;
    }
    else
    {
        int* tmpp = new int[capacity + MAXSIZE];
        
        if(data != NULL)
        {
            for(int i=0;i<idx;i++)
                tmpp[i] = data[i];
            data = tmpp;
            data[idx++] = val;
        }
        else
            return false;
    }    
}

bool CMssD::empty(){
    return idx<=0;
}

bool CMssD::pop()
{
    if(empty())
    {
        return false;
    }
    else{
        idx--;
        return true;
    }
}

int CMssD::top(){
    return data[idx];
}

void d2bByMyStackClassD(int n)
{
    CMssD st;               // 自定义C++的MyStack（动态大小）
    do
         st.push(n%2);
    while(n/=2);
    while(!st.empty())
    {
        st.pop();
        printf("%d",st.top());
    }
}

template <typename T>
class CMssDT       
{
    T *data;
    int idx;
    int capacity;
public:
    CMssDT(){
        data = new T[MAXSIZE];
        capacity = MAXSIZE;
        idx = 0;
    }
    bool push(T val);
    bool empty();
    bool pop();
    int top();
};

template <typename T>          // 看一下类模板的简单写法，只要修修改改即可
bool CMssDT<T>::push(T val){
    if(capacity > idx)
    {
        data[idx++] = val;
        return true;
    }
    else
    {
        int* tmpp = new T[capacity + MAXSIZE];
        
        if(data != NULL)
        {
            for(int i=0;i<idx;i++)
                tmpp[i] = data[i];
            data = tmpp;
            data[idx++] = val;
        }
        else
            return false;
    }    
}

template <typename T>
bool CMssDT<T>::empty(){
    return idx<=0;
}

template <typename T>
bool CMssDT<T>::pop()
{
    if(empty())
    {
        return false;
    }
    else{
        idx--;
        return true;
    }
}

template <typename T>
int CMssDT<T>::top(){
    return data[idx];
}

void d2bByMyStackClassDT(int n)
{
    CMssDT<int> st;               // 自定义C++的MyStack模板类（动态大小）
    do
         st.push(n%2);
    while(n/=2);
    while(!st.empty())
    {
        st.pop();
        printf("%d",st.top());
    }
}

int main()
{
    d2bOutput2File();
    int i = 1;
    for(i=10;i<21;i++)
    {
        printf("%d\t",i);
        d2bByMyStackClassDT(i);
        printf("\n");
    }

restart:
    goto restart;
    return 0;
}
/*

*/

运行效果：

输出到文件中的内容：

－End－