c++派生类中构造函数和析构函数执行顺序、判断对象类型、抽象类、虚函数

一、

 代码：

#include<stdio.h>
#include<string.h>
#include<algorithm>
#include<iostream>
using namespace std;
class A
{
public:
    int a,b;
    A();
    A(int x,int y);
    ~A();
};
A::A()
{
    printf("调用A类构造函数
");
}
A::A(int x,int y)
{
    a=x;
    b=y;
    printf("调用A类构造函数
");
}
A::~A()
{
    printf("调用A类析构函数
");
}
class B:public A
{
public:
    int aa,bb;
    B()
    {
        printf("调用B类构造函数
");
    }
    B(int x,int y)
    {
        aa=x;
        bb=y;
        printf("调用B类构造函数
");
    }
    ~B()
    {
        printf("调用B类析构函数
");
    }
};
class C:public B
{
public:
    int aaa,bbb;
    B one;
    C(int x,int y)
    {
        aaa=x;
        bbb=y;
        one.aa=x;
        one.bb=y;
        printf("调用C类构造函数
");
    }
    ~C()
    {
        printf("调用C类析构函数
");
    }
};
int main()
{
    C first(0,0);
    printf("%d %d %d %d
",first.aaa,first.bbb,first.one.aa,first.one.bb);
    return 0;
}

二、

#include<stdio.h>
#include<string.h>
#include<algorithm>
#include<iostream>
using namespace std;
class Base
{
public:
    Base(int x,int y)
    {
        a=x;
        b=y;
    }
    virtual void show()  //声明了虚函数，那么指针指向哪个对象就用那个对象的函数
    {     //否则的话，声明指针是什么类型就会用那个类型的函数
        cout<<"基类内容show打印"<<endl;
        cout<<"a:"<<a<<"b:"<<b<<endl;
    }
    void prinf()
    {
        cout<<"基类内容prinf打印"<<endl;
        cout<<"a:"<<a<<"b:"<<b<<endl;
    }
private:
    int a,b;

};
class One:public Base
{
public:

    One(int x,int y):Base(x,y)
    {
        aa=x;
        bb=y;
    }
    void show()
    {
        cout<<"派生类内容show打印"<<endl;
        cout<<"aa:"<<aa<<"bb:"<<bb<<endl;
    }
    void prinf()
    {
        cout<<"派生类内容prinf打印"<<endl;
        cout<<"aa:"<<aa<<"bb:"<<bb<<endl;
    }
private:
    int aa,bb;
};
int main()
{
    Base mb(100,200),*pc;
    One mc(200,300);
    pc=&mc;
    pc->show();
    pc->prinf();
    pc=&mb;
    pc->show();
    pc->prinf();
    return 0;
}

//2、
#include<stdio.h>
#include<string.h>
#include<algorithm>
#include<iostream>
using namespace std;
class Shape   //抽象类定义是只要里面有一个纯虚函数那他就是抽象类，
{   //抽象类不需要什么关键字来定义，且它的派生类必须覆盖重写他的纯虚方法
public :
    double a;
    Shape(double x)
    {
        a=x;
    }
    virtual void area()=0;
    virtual void show()=0;
};
class Circle:public Shape
{
public:
    Circle(double x):Shape(x)
    {

    }
    void area()
    {
        cout<<"the circle area is :"<<endl;
        cout<<3.14*a*a<<endl;
    }
    void show()
    {
        cout<<"a:"<<a<<endl;
    }
};
int main()
{
    Shape *ptr;
    Circle r(6);
    ptr=&r;
    ptr->area();
    ptr->show();
    return 0;
}

//3、
#include<stdio.h>
#include<string.h>
#include<algorithm>
#include<iostream>
#include<typeinfo>
using namespace std;
class Sqare
{
public :
    double a;
    Sqare(double x)
    {
        a=x;
    }
};
class Circle
{
public :
    double a;
    Circle(double x)
    {
        a=x;
    }
};
int main()
{
    Sqare one(1);
    Circle two(2);
    if(typeid(one)==typeid(Sqare))  //判断对象类型
    {
        cout<<"它是Sqare对象"<<endl;
    }
    else
    {
        cout<<"它是Circle对象"<<endl;
    }

    if(typeid(two)==typeid(Sqare))
    {
        cout<<"它是Sqare对象"<<endl;
    }
    else
    {
        cout<<"它是Circle对象"<<endl;
    }
    return 0;
}