类的继承

类的继承

#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的有元

已标记关键词 清除标记
©️2020 CSDN 皮肤主题: 编程工作室 设计师:CSDN官方博客 返回首页