C++中的抽象类

# include<iostream>

usingnamespace std;

/* 动物类 */class Animal
{
public:
    /* 纯虚函数 */virtualvoid eat() = 0;
    /* 虚析构函数:保证子类的析构函数被调用正确 */
    ~Animal() {};
};

/* 狗类 */class Dog:public Animal
{
public:
    virtualvoid eat()
    {
        cout << "狗吃骨头..." << endl;
    }
};

/* 猫类 */class Cat :public Animal
{
public:
    virtualvoid eat()
    {
        cout << "猫吃鱼..." << endl;
    }
};

/* 抽象类指针做函数返回值 */
Animal * get()
{
    Animal * animal = new Cat;
    return animal;
}

/* 抽象类引用作函数参数 */voidset(Animal& animal)
{
    animal.eat();
}

int main()
{
    /* 抽象类指针 */
    Animal * animal1 = new Dog();
    animal1->eat();
    delete animal1;

    /* 抽象类引用 */
    Cat cat;
    Animal& animal2 = cat;
    animal2.eat();

    /* 抽象类指针做函数返回值 */
    Animal * animal3 = get();
    animal3->eat();
    delete animal3;

    /* 抽象类引用作函数参数 */
    Dog dog;
    set(dog);

    return0;
}

# include<iostream>
usingnamespace std;

class Interface
{
public:
    virtualvoid print() = 0;
};

class Impl1 :public Interface
{
public:
    void print()
    {
        cout << "Impl1的实现" << endl;
    }
};

class Impl2 :public Interface
{
public:
    void print()
    {
        cout << "Impl2的实现" << endl;
    }
};

int main()
{
    Interface * i1 = new Impl1;
    i1->print();

    Interface * i2 = new Impl2;
    i2->print();

    return0;
}

# include<iostream>
usingnamespace std;

/* 定义加法函数 */int add(int a, int b)
{
    return a + b;
}
/* 定义减法函数 */int sub(int a, int b)
{
    return a - b;
}
/* 定义回调函数 */int execFun(int(*fun)(int a, int b),int p_a,int p_b)
{
    return fun(p_a, p_b);
}

int main()
{
    /* 定义一个函数返回值为int，函数参数有两个int类型的函数指针 */int(*fun)(int a, int b);
    /* 动态使得函数指针指向一个函数 */
    fun = add;
    /* 调用函数指针进行运算 */int r1 = fun(1, 2);
    cout << "r1 = " << r1 << endl;


    /* 回调函数:我们只需要传递要调用的函数和要计算的数值即可，回调函数帮我们自动调用并返回结果 */
    fun = sub;
    int r2 = execFun(fun, 100, 200);

    return0;
}