类的继承

类的继承

#include <iostream>

using namespace std;

class A

{

public:

    int x;

    void show()

    {

        cout<<"A"<<endl;

    }

};

class B:public A

{

public:

    int y;

    void show()

    {

        cout<<"B"<<endl;

    }

};

int main(int argc, const char * argv[])

{

    A a,*a1;

    B b,*b1;

    

    b = a;//父类不能复制给子类

    a = b;//子类可以给父类

    a1 = &b;

    b1 = &a;  //不可以

    

    return 0;

}

注意的题目：

//

//  main.cpp

//  C++test

//

//  Created by 丁小未 on 13-7-17.

//  Copyright (c) 2013年 dingxiaowei. All rights reserved.

//

#include <iostream>

using namespace std;

class A

{

public:

    void show()

    {

        cout<<"A"<<endl;

    }

};

class B:public A

{

public:

    void show()

    {

        cout<<"B"<<endl;

    }

};

int main(int argc, const char * argv[])

{

    A *a;

    A aa;

    B b;

    a=&b;

    aa=b;

    aa.show();

    return 0;

}

输出结果：

A

#include <iostream>

using namespace std;

虚函数的应用：

class A

{

public:

    virtual void show();

  virtual void show1()

 {

cout<<"A1"<<endl;

}

};

void A::show()

{

    cout<<"A\n";

}

class B:public A

{

public:

    void show()

    {

        cout<<"B\n";

    }

};

class C:public A

{

public:

    void show()

    {

        cout<<"C\n";

    }

  virtual void show1()

 {

cout<<"C1"<<endl;

}

};

int main()

{

    A *a;

    B b;

    C c;

    a=&b;

    a=&c;

    a->show();     //调用的是C，基类是虚函数，那么子类该同名函数都是虚函数，就调子函数

    a->show1();     //还是调用的a，跟子类是否是虚函数没有关系   //如果基类中函数不是虚函数，那么这样就是访问的是基类中的函数，如果加上了virtual那么访问的就是指针所指向的函数

    return 0;

}

纯虚函数：virtual void show() = 0;//纯虚基类函数不实现具体的行为，实现完全有接口来实现，函数名赋予0，本质上是将指向函数的的指针，纯虚函数必须要实现，成为重载纯虚函数。

成员函数被重载的特征

（1）相同的范围（在同一个类中）；

（2）函数名字相同；

（3）参数不同；

（4）virtual 关键字可有可无。

覆盖是指派生类函数覆盖基类函数，特征是

（1）不同的范围（分别位于派生类与基类）；

（2）函数名字相同；

（3）参数相同；

（4）基类函数必须有virtual 关键字。

“隐藏”是指派生类的函数屏蔽了与其同名的基类函数，规则如下

（1）如果派生类的函数与基类的函数同名，但是参数不同。此时，不论有无virtual关键字，基类的函数将被隐藏（注意别与重载混淆）。

（2）如果派生类的函数与基类的函数同名，并且参数也相同，但是基类函数没有virtual 关键字。此时，基类的函数被隐藏（注意别与覆盖混淆）

#include <iostream>

usingnamespacestd;

class Sample{

public:

Sample(){ cout<<"Constructor"<<endl;}

~Sample(){cout<<"Destructor"<<endl;}

};

void fun(int i)

{staticSample c;

cout<<"i="<<i<<endl;

}

int main(void)

{fun(10);

fun(20);

    return0;  //静态对象只初始化一次

}

运行结果：

Constructor

10

20

Destructor

//注意

#include <iostream>

usingnamespacestd;

class Tc {

private:

    int A;

staticint B;//静态数据成员

public:

    Tc(int a)

    {

        A=a;

        B+=a;

    }

staticvoid display(Tc  c);//Tc的对象为形参

};

void  Tc::display(Tc  c)//不用static修饰

{

    cout<<"A="<<c.A<<",B="<<B<<endl;

}

intTc::B=2;

int main(void)

{Tc  a(2),b(4);

Tc::display (a);

Tc::display (b);

    return0;

}

运行结果：    //解释：创建两个对象的时候，调用了两次构造函数，但static只创建一次

A=2,B=8;

A=4,B=8;

有元的定义：

class A

{

     friend class B;

}

那么B就是A的有元