C++学习之路 day8

最新推荐文章于 2024-04-22 18:35:39 发布
最新推荐文章于 2024-04-22 18:35:39 发布
阅读量213 收藏
点赞数 1
分类专栏： 【C++学习】 文章标签： C++基础知识学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zay_myxq/article/details/77645431
版权

Day8 知识点:

1.赋值兼容

赋值兼容只能发生在公有派生继承的父子关系中。

a) 子类对象(派生类)赋给父类(基类)的对象

b) 子类对象赋给父类的引用

c) 子类对象的地址赋给父类的指针


实验代码：

#include <iostream>

using namespace std;

class shape
{
public:
    shape(int x = 0, int y = 0)
        :_x(x),_y(y){}

    void draw()
    {
        cout<<"drawfrom"<<"("<<_x<<","<<_y<<")"<<endl;
    }
protected:
    int _x;
    int _y;
};

class circle:public shape
{
public:
    circle(int x = 0, int y = 0, int r = 0)
        :shape(x,y),_radius(r){}

    void draw()
    {
        cout<<"drawfrom"<<"("<<_x<<","<<_y<<")";
        cout<<" radius = "<<_radius<<endl;
    }

    void func()
    {
        cout<<"------------------"<<endl;
    }

private:
    int _radius;

};

int main()
{
    shape s(1,2);
    s.draw();

    circle c(1,2,3);
    c.draw();
    c.func();

    shape s1 = c;       //派生类对象赋给基类对象
    s1.draw();

    shape &rc = c;      //派生类对象赋给基类的引用
    rc.draw();

    shape *pc = &c;     //派生类对象的地址赋给指向基类的指针
    pc->draw();

    return 0;
}




2.多态：由继承产生的相关的不同的类，对同一消息做出的不同响应。

静多态，编译阶段决定的

#include <iostream>

using namespace std;

void func(int a, float b)
{
    cout<<"void func(int a, float b)"<<endl;
}

void func(float a, int b)
{
    cout<<"void func(float a, int b)"<<endl;
}



int main()
{
    func(1,3.0);        //在编译阶段就完成函数的倾轧
    func(3.0,1);

    return 0;
}


动多态，运行阶段决定的

实现条件：

1) 父类中有虚函数(在函数声明前加virtual，定义时不需要)

2) 子类中覆写(override)了父的虚函数，根据需要重新定义函数体

{

a) overload重载 同一作用域中，函数名相同，参数列表不同；

b) shadow 发生在父子类中的同名成员(函数或数据，如果是函数只要同名就会构成shadow)；

c) override  发生在父子类中，父类中函数有virtual声明的函数，子类中同参，同名，同返回。

   }

3) 成员函数被声明为虚函数后，其子类中的完全相同的函数也是虚函数。可以加virtual以示清晰(也可不加)

4) 定义一个父类的指针，将子类对象地址赋给父类的指针，通过该指针调用虚函数，调用的就是所指向子类中的虚函数

5） 子类中覆写的函数可以是任意访问类型，依需求而定。

实验代码：

#include <iostream>


using namespace std;

class shape
{
public:
    shape(int x = 0, int y = 0)
        :_x(x),_y(y){}

    virtual void draw()
    {
        cout<<"drawfrom"<<"("<<_x<<","<<_y<<")"<<endl;
    }
protected:
    int _x;
    int _y;
};

class Circle:public shape
{
public:
    Circle(int x = 0, int y= 0, int r = 0)
        :shape(x,y),_radius(r){}

    virtual void draw()
    {
        cout<<"drawfrom"<<"("<<_x<<","<<_y<<")";
        cout<<" _radius ="<<_radius<<endl;
    }

private:
    int _radius;
};

class Rec:public shape
{
public:
    Rec(int x = 0, int y = 0,int len = 0, int wid = 0 )
        :shape(x,y),_len(len),_wid(wid){}

    virtual void draw()
    {
        cout<<"drawfrom"<<"("<<_x<<","<<_y<<")";
        cout<<" _len ="<<_len<<" _wid= "<<_wid<<endl;
    }
private:
    int _len;
    int _wid;
};


int main()
{
    Circle c(1,2,3);
    c.draw();

    Rec r(1,2,3,4);
    r.draw();

    shape *ps = NULL;

    int choice;


    while(1)
    {
        scanf("%d",&choice);
        switch(choice)
        {
            case 1:
                ps = &c;
                ps->draw();
            break;
            case 2:
                ps = &r;
                ps->draw();
            break;
        }
    }


    return 0;
}

3.

virtual void draw() = 0;纯虚函数格式

1.含有纯虚函数的类，称为抽象基类，不可实列化。即不能创建对象，存在的意义就是被
继承，提供族类的公共接口，java 中称为 interface；

2. 纯虚函数只有声明，没有实现，被“初始化”为 0；

3. 如果一个类中声明了纯虚函数，而在派生类中没有对该函数定义，则该虚函数在派生类
中仍然为纯虚函数，派生类仍然为纯虚基类。


实例代码： 

#include <iostream>


using namespace std;





class shape
{
public:
    shape(int x = 0, int y = 0)
        :_x(x),_y(y){}

    virtual void draw() = 0;

protected:
    int _x;
    int _y;
};

class Circle:public shape
{
public:
    Circle(int x = 0, int y= 0, int r = 0)
        :shape(x,y),_radius(r){}

    virtual void draw()
    {
        cout<<"drawfrom"<<"("<<_x<<","<<_y<<")";
        cout<<" _radius ="<<_radius<<endl;
    }

private:
    int _radius;
};

class Rec:public shape
{
public:
    Rec(int x = 0, int y = 0,int len = 0, int wid = 0 )
        :shape(x,y),_len(len),_wid(wid){}

    virtual void draw()
    {
        cout<<"drawfrom"<<"("<<_x<<","<<_y<<")";
        cout<<" _len ="<<_len<<" _wid= "<<_wid<<endl;
    }
private:
    int _len;
    int _wid;
};


int main()
{
    Circle c(1,2,3);
    Rec r(3,4,5,6);

    shape *ps = &c;
    ps->draw();

    ps = &r;
    ps->draw();


    return 0;
}



4.虚析构(在析构器前加virtual)

目的：为了析构完全，在delete父类指针的时候，会调用子类的析构函数，实现完整析构。

 使用方法：当一个类中有虚函数的时候，将其析构函数一并加上virtual

实验代码：

//animal.h
#ifndef ANIMAL_H
#define ANIMAL_H


class Animal
{
public:
    Animal();
    virtual ~Animal();          //如果不加virtual，在释放堆内存的时候只会对Animai进行析构,
    virtual void voice() = 0;   //Animal指针指向的内存不会自动完成析构
};

#endif // ANIMAL_H
//cat.h
#ifndef CAT_H
#define CAT_H
#include "animal.h"

class Cat:public Animal
{
public:
    Cat();
    ~Cat();
    virtual void voice();
};

#endif // CAT_H
//dog.h
#ifndef DOG_H
#define DOG_H
#include "animal.h"

class Dog:public Animal
{
public:
    Dog();
    ~Dog();
    void voice();
};

#endif // DOG_H
//animal.cpp
#include "animal.h"
#include <iostream>

using namespace std;


Animal::Animal()
{
    cout<<"Animal()"<<endl;
}

Animal::~Animal()
{
    cout<<"~Animal()"<<endl;
}
//cat.cpp
#include "cat.h"
#include <iostream>

using namespace std;

Cat::Cat()
{
    cout<<"Cat()"<<endl;
}

Cat::~Cat()
{
    cout<<"~Cat()"<<endl;
}

void Cat::voice()
{
    cout<<"I am a cat,miao miao miao"<<endl;
}

//dog.cpp
#include "dog.h"
#include <iostream>

using namespace std;

Dog::Dog()
{
    cout<<"Dog()"<<endl;
}

Dog::~Dog()
{
    cout<<"~Dog()"<<endl;
}

void Dog::voice()
{
    cout<<"I am a dog,wang wang wang"<<endl;
}

//main.cpp
#include <iostream>
#include "animal.h"
#include "cat.h"
#include "dog.h"

using namespace std;

int main()
{
    Dog d;
    Cat c;
    Animal *a1 = &d;
    Animal *a2 = &c;

    a1->voice();
    a2->voice();
    
    
    Animal *a = new Dog;
    delete a;

    return 0;
}

5.基于多态的依赖倒置设计原则


依赖倒置定义：高层模块不应该依赖低层模块，二者都应该依赖其抽象；抽象不应该依赖细节；细节应该依赖抽象

下面以两种不同的程序设计方法来表达设计思想


场景是这样的，母亲给孩子讲故事，只要给她一本书，她就可以照着书给孩子讲故事了。


传统过程设计：

实验代码： 

#include <iostream>

using namespace std;


class Book
{
public:
    string getContents()
    {
        return "A little bear are crying";
    }
};

class News
{
public:
    string getContents()
    {
        return "Mr.Zhou were awarded with the Noble Prize";
    }
};

class Mother
{
public:
    void tellContents(Book *b)
    {
        cout<<b->getContents()<<endl;
    }

    void tellContents(News *n)
    {
        cout<<n->getContents()<<endl;
    }
};

int main()
{
    Mother m;
    Book b;
    News n;
    m.tellContents(&b);
    m.tellContents(&n);
    return 0;
}


依赖倒置设计原则： 


#include <iostream>

using namespace std;

class Ireader
{
public:
    virtual string getContents() = 0;

};

class Book:public Ireader
{
public:
    virtual string getContents()
    {
        return "A little bear are crying";
    }
};

class News:public Ireader
{
public:
    virtual string getContents()
    {
        return "Mr.Zhou were awarded with the Noble Prize";
    }
};

class Mother
{
public:
    void tellContents(Ireader *i)
    {
        cout<<i->getContents()<<endl;
    }
};

int main()
{
    Mother m;
    Book b;
    News n;
    m.tellContents(&b);
    m.tellContents(&n);
    return 0;
}

电脑组装实验代码： 

#include <iostream>

using namespace std;

class CPU
{
public:
    virtual void run() = 0;
};

class Mem
{
public:
    virtual void run() = 0;

};

class Disk
{
public:
    virtual void run() = 0;
};

class Intel:public CPU
{
public:
    virtual void run()
    {
        cout<<"Intel CPU"<<endl;
    }
};

class Kingston:public Mem
{
public:
    virtual void run()
    {
        cout<<"Kingston Mem"<<endl;
    }
};

class Wddisk:public Disk
{
public:
    virtual void run()
    {
        cout<<"Wddisk"<<endl;
    }
};

class Computer
{
public:
    Computer(CPU *pc,Mem *pm,Disk *pd)
        :_pc(pc),_pm(pm),_pd(pd){}
    void work()
    {
        _pc->run();
        _pm->run();
        _pd->run();
    }
    ~Computer()
    {
        delete _pc;
        delete _pm;
        delete _pd;

    }
private:
    CPU *_pc;
    Mem *_pm;
    Disk *_pd;
};

int main()
{
    Computer c(new Intel,new Kingston,new Wddisk);
    c.work();

    return 0;
}












全帝
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++学习之C基础（day1）
10-02
根据给定的学习笔记内容，以下是对C语言基础知识的详细总结及解释： ### 第四章：语句 #### 4.1 空语句 - **定义**：空语句实际上仅由一个分号 `;` 构成，没有任何实际的操作。 - **示例**：`;` 或者 `int x; ;` ...
C++学习小结之语句
09-03
在C++编程语言中，语句是构成程序的基本单元，它们指示计算机执行特定的操作。本文主要探讨了C++中的三种基本语句类型：顺序语句、条件分支语句和循环语句。 一、顺序语句 顺序语句是指按照代码出现的顺序依次执行...
C++学习之路
moremagic的专栏
04-01 598
前言 Accelerated C++中文版  2015.4.1 编写一个小程序 #include int main() { std::cout<<"你好，欢迎来到C++世界。"<<std::endl; return 0; }
我的C++学习之路
爱丽丝和她的猫的博客
06-30 458
2017年3月份写完我的小论文后，心里暗暗决定以后想做软件。我是学仪器仪表专业的，大学里只学过C语言，没有做过什么编程的项目。一提到编程，就觉得是很难的东西，不可逾越的障碍。以前每次学习都是从入门到放弃，但是这次最终还是鼓起勇气开始真正地深入地学习编程，从基础开始。 三月份于是在网上买了java学习视频开始学习编程。用了差不多一个月的时间，学习了基本语法、面向对象、JavaAPI、多线程、集合类、I
C++学习之路（一）
lizhelongsjtu的博客
10-27 205
c++学习
【C++学习之路】一、初识C++及环境配置和中文乱码处理
Jerrychd的博客
04-05 642
对C++这门语言进行了介绍，对其环境的配置进行了简要说明，最后解决了中文乱码的情况
c++学习之路
bucan804228552的博客
03-20 1172
【3.19】内存分区模型 内存四区意义: 不同区域存放的数据，赋予不同的生命周期,给我们更大的灵活编程 程序exe 运行前分为 代码区和全局区；运行后分为 栈区和堆区 1.代码区:存放CPU执行的机器指令,存放函数体的二进制代码，由操作系统进行管理的 代码区是共享的，共享的目的是对于频繁被执行的程序，只需要在内存中有一份代码即可 代码区是只读的，使其只读的原因是防止程序意外地修改了它的指令 2.全局区:存放全局变量和静态变量以及常量 全局变量和静态变量（static）存放在此. 全局区还包含了常量区,字符
C++学习之C++11标准
m0_74316391的博客
04-22 1011
在2003年C++标准委员会曾经提交了一份技术勘误表(简称TC1)，使得C++03这个名字已经取代了C++98称为C++11之前的最新C++标准名称。不过由于C++03(TC1)主要是对C++98标准中的漏洞进行修复，语言的核心部分则没有改动，因此人们习惯性的把两个标准合并称为C++98/03标准。从C++0x到C++11，C++标准10年磨一剑，第二个真正意义上的标准珊珊来迟。接下来我将会以通俗易懂和亲切的话讲解C++11里面处理线程库之外其他重要部分
c++学习笔记 Day1
qq_52057773的博客
03-20 959
os：记录c++学习过程和踩坑，方便以后回顾。
C++学习笔记day3
qq_61100395的博客
03-31 1064
继承： 好处：减少重复代码 语法：class 子类：继承方式 父类 子类也称为派生类，父类也称为基类。 继承中的对象模型： 父类中所有的非静态成员都会被子类继承。 利用开发人员命令提示工具查看对象模型： 跳转盘符 C： 跳转文件路径 cd 具体路径下 查看命名 cl /d1 reportSingleClassLayout类名 文件名 继承中的构造和析构顺序： 先构造父类再构造子类 先析构子类再析构父类 继承中同名成员处理方式： 访问子类同名成员：直接访问即可 访问父类同名成员：需要加作用域 如果...
零基础C++ Day 2 代码
08-13
与 https://mp.csdn.net/mp_blog/creation/editor/141157430 配套使用
零基础C++ Day 1 Hello World
08-13
输出Hello World! 代码
C++提高编程 学习笔记
05-11
通过对 C++ 中泛型编程和函数模板的学习，我们可以看到模板的强大之处在于它们允许我们编写高度灵活和可重用的代码。通过模板，我们不仅能够减少代码冗余，还能提高代码的可读性和可维护性。在实际开发中，合理利用...
VB机动车租赁管理系统设计(源代码+系统+开题报告+答辩PPT).zip
08-18
计算机毕业设计资源包含（项目部署视频+源码+LW+开题报告等等），所有项目经过助教老师跑通，有问题可以私信博主解决，可以免费帮部署。
计算机毕业设计jsp篮球NBA周边商城vue论文
08-18
计算机毕业设计jsp篮球NBA周边商城vue论文
分享几款开源的后台框架
08-18
X-admin v2.0
计算机毕业设计jsp古玩玉器交易系统vue论文
08-18
计算机毕业设计jsp古玩玉器交易系统vue论文
数据库技术：Redis.zip
08-18
后端技术系列教程，包括： API开发全套教程 后端安全全套教程 后端微服务架构全套教程 后端性能优化全套教程 后端框架全套教程 后端缓存技术全套教程 后端编程语言全套教程 数据库技术全套教程
DzzOffice kkFileView插件 V1.20.1
最新发布
08-18
基于DzzOffice开发。一个基于Spring Boot的文件文档在线预览解决方案应用，支持多种文件格式和预览模式，易于部署和使用。基本支持主流办公文档的在线预览，如doc,docx,xls,xlsx,ppt,pptx,pdf,txt,zip,rar,图片,视频,音频等等。 更多详细说明请访问 DzzOffice 小胡团队 查看。 DzzOffice 小胡版安装和升级插件说明（详细教程请在DzzOffice 笔记中查看）： 下载并解压插件后，请将解压后的插件文件夹以"kkFileView"命名的方式放置在网站的"dzz"目录下（若该目录下已存在同名文件夹，请先删除原文件夹后再放置新文件夹）。 升级的用户在系统工具中清理缓存即可; 对于首次安装的用户，请在应用市场右下角选择“导入”功能，然后选择要导入的文件，即文件夹下的“dzz_app_kkFileView.xml”。选择文件后点击“提交”按钮完成安装。 请严格按照上述步骤操作，以确保插件能够正确安装和升级。如在操作过程中遇到任何问题，请访问团队主页或查阅DzzOffice 笔记以获取更多帮助。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值