C++学习记录（八）纯虚函数、虚析构、模板函数、模板类、栈模板

这是第八天的学习记录。

#include <iostream>

using namespace std;

class A
{
public:
    A() { cout << "A" << endl; }
    A(const A& a) { cout << "copy A" << endl; }
    //virtual ~A() { cout << "~A" << endl; }
    ~A() { cout << "~A" << endl; }

    //virtual void show() = 0;
    //virtual void showInfo() { cout << "A info" << endl; }
    void showInfo() { cout << "A info" << endl; }
};
class B : public A
{
    int *p;
public:
    B()
    {
        p = new int[1024];
        cout << "B" << endl;
    }
    ~B()
    {
        delete []p;
        cout << "~B" << endl;
    }

    //void show() override { cout << "hello" << endl; }
    //void showInfo() override { cout << "B info" << endl; }
};

int main()
{
    // -1- 纯虚函数,没有函数体的虚函数,含有纯虚函数的类叫抽象类
    // 主要用做基类使用virtual 返回值 函数名(形参) = 0；
    // 这种抽象类不可以产生对象，但是可以定义指针,子类可对其定义
    //A* a = new B;
    //a->show();

    // -2- 虚析构,在基类的虚构函数前叫virtual
    // 子类析构时，会自动调用基类中的析构
    // 主要用于多态发生时，无法调用子类析构而出现的内存泄露
    //a->showInfo();
    //delete a;

    // -3- 子类的初始化列表
    // 子类初始化列表不可以对父类初始化

    // -4- 拷贝构造和虚指针
    // 两个不同类之间的赋值，会发生拷贝构造函数

    // -5- 临时对象，两个对象不会指向同一个空间
    //A a1 = B();         // a1通过A的拷贝构造产生，B()为临时构造,生命周期为本行
    //const A& a2 = B();

    // -6- 常引用

    // -7- 右值引用
    // 临时对象又叫右值
    A&& a3 = B();
    a3.showInfo();

    //cout << "Hello World!" << endl;
    return 0;
}

#include <iostream>

using namespace std;

// 范型函数模板
template<class T>
T Add(T t1, T t2)
{
    return t1 + t2;
};
// 特化函数模板，一般不进行特化
template<class T>
T Add(int t1, int t2)
{
    return t1 + t2;
};

// 类模板
template<class A, class B, class C>
class Base
{
    A a;
    B b;
    C c;
public:
    void show(A a, B b) { cout << "show" << endl;}
};
template<class A, class B, class C, class D>
class Son : public Base<A, B, C>        // 模板写类的继承
{
public:
    void showInfo(A a, D d) { cout << "show Son" << endl; }
};

int main()
{
    // -1- 函数模板，类模板
    cout << Add<int>(2,3) << endl;
    cout << Add<float>(4,5) << endl;
    cout << Add(6,7) << endl;           // 不推荐使用这种

    // -2- 调用类模板去定义对象是，一定要显示指定具体值
    Base<int,float,string> a;
    a.show(1, 2.1);

    Son<int,float,string,double> b;
    b.showInfo(2,3.2);

    cout << "Hello World!" << endl;
    return 0;
}

#ifndef MY_STACK_H
#define MY_STACK_H

#include <iostream>
using namespace std;

template<class T>
class My_stack
{
private:
    int capacity;
    int size;
    T* data;
public:
    My_stack(int c = 10);
    ~My_stack();

    bool push(T t);
    bool pop();
    T top();
    bool empty();

};

template<class T>
My_stack<T>::My_stack(int c):size(0),capacity(c)
{
    data = new T[c];
}

template<class T>
My_stack<T>::~My_stack()
{
    delete []data;
}

template<class T>
bool My_stack<T>::push(T t)
{
    if (size > capacity) { return false;}
    data[size] = t;
    size++;
    return true;
}

template<class T>
bool My_stack<T>::pop()
{
    if (size == 0) { return false; }
    size--;
}

template<class T>
T My_stack<T>::top()
{
    if (size > 0)
    {
        T temp = data[size - 1];
        return temp;
    }
}

template<class T>
bool My_stack<T>::empty()
{
    if (size == 0) { return true; }
    return false;
}

#endif // MY_STACK_H

#include <iostream>
#include "my_stack.h"
using namespace std;

int main()
{
    My_stack<int> stack;
    stack.push(1);
    stack.push(2);
    stack.push(3);
    // 先入后出
    for (int i = 0; !stack.empty(); i++)
    {
        cout << stack.top() << endl;
        stack.pop();
    }
    //cout << "Hello World!" << endl;
    return 0;
}