成长随心记4

3.24

1，继承下同名的属性处理
    1）编译器默认是子类的属性或者成员函数
    2）如果想要访问父类的，需要添加作用域
    例：父类：class father，子类：class son
         语法：    son s ;s.father::fan();

2，可以继承多个对象
    语法：例：class son：public father1,public father2

3，菱形继承问题
    解释：就是两个类同时继承一个类，又有另外一个类继承这两个类，这样就会造成歧义
    解决：继承前添加virtual,使之变成虚继承，如下：
        class father {//虚基类
    public :
        int set;
    };
    class son1:virtual public father {};
    class son2:virtual public father {};

    class grandson :public son1, public son2 {
    public:
        void fan(){
            grandson q;
            cout << q.set;
        }
    };

4，数据结构-栈
    a）特殊的顺序表，要求只能表尾插入，表尾删除
    b）静态存储的顺序栈
    #define max 10
    typedef struct {
        int data[max];//数据域
        int top;//栈顶指针
    }sqstack;
    bool init(sqstack& s) {
        s.top = -1;//栈一开始指向的是-1，不是0
        return true;
    }
    bool put(sqstack& s, int e) {//入栈
        if (s.top == max-1)//如果栈满，返回错误
            return false;
        s.top += 1;//首先栈顶指针加一指向空位
        s.data[s.top] = e;//把e放入空位
        return true;
    }
    bool show(sqstack& s) {//栈的展示
        for (int i = 0; i <= s.top; i++) {
            cout << s.data[i];
        }
        return true;
    }    
    bool del(sqstack& s,int& e) {//出栈
        if (s.top == -1)//如果栈空，返回错误
            return false;
        e = s.data[s.top];//用e返回此时的栈顶元素
        s.top -= 1;
        return true;
    }
    bool search(sqstack& s, int& e) {//查找栈顶元素
        if (s.top == -1)
            return false;
        e = s.data[s.top];
        return true;
    }
    int main()
    {
        sqstack s;
        init(s);
        for (int i = 0; i < 10; i++) {
            put(s, i);
        }
        show(s);
        int e = 0;
        del(s,e);
        show(s);
    }

    c）动态存储的链式栈：在表头的位置进行插入和删除操作的单链表
    typedef struct Lnode{
        int data;//数据域
        struct Lnode* next;//指向下一节点的指针
    }Lnode,*linklist;//Lnode表示节点，linklist表示栈表

    bool init(linklist& s) {//栈的初始化
        s = new Lnode;//这是一个带头节点的栈
        s->next = NULL;//头结点指向空
        return true;
    }
    bool put(linklist& s, int e) {//入栈
        Lnode* p = new Lnode;//定义一个新节点
        p->data = e;//里面的数据时e
        p->next = s->next;//p指向s指向的位置，也就是头结点的后一个位置，这不就是头插法嘛
        s->next = p;//头结点指向p
        return true;
    }
    bool show(linklist& s) {//栈的展示
        if (s->next == NULL)//如果栈空，返回错误
            return false;
        Lnode* p = s->next;//p指向第一个数据位置，即栈顶数据
        while (p) {//p依次向后遍历，直到指向空
            cout << p->data;
            p = p->next;
        }
        return true;
    }
    bool del(linklist& s, int& e) {//出栈
        if (s->next == NULL)//如果栈空，返回错误
            return false;
        Lnode* p = s->next;//p指向第一个数据位置
        e = p->data;//用e返回第一数据，即栈顶数据
        s->next = p->next;//头指针指向第二个数据位置
        delete p;//释放p
        return true;
    }

    bool search(linklist& s, int& e) {//栈顶元素的查找
        if (s->next == NULL)
            return false;
        e = s->next->data;
        return true;
    }
    int main()
    {
        linklist s;
        init(s);
        for (int i = 0; i < 10; i++) {
            put(s, i);
        }
        show(s);
        int e = 0;
        del(s, e);
        show(s);
    }

5，c语言编译过程
    预编译    main.i text.i    是一种展开，宏的展开，函数的展开
    编译    main.s text .o    检查语法，生成汇编
    汇编    main.o text.o    汇编代码转机器码
    链接    a.outs        将源文件中用到的库函数与汇编生成的目标文件.o合并生成可执行文件