C++小白慕课网4

最新推荐文章于 2024-08-15 05:02:54 发布
最新推荐文章于 2024-08-15 05:02:54 发布
阅读量229 收藏
点赞数
分类专栏： c++学习 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_40188644/article/details/78299685
版权

继承篇
这里写图片描述

work.h

#include"person.h"

class Worker :public Person
{
public:
    Worker();
    ~Worker();
    void work();
    int m_iSalary;
};

worker.cpp

#include<iostream>
#include"worker.h"
using namespace std;

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

person.h

#include<string>
using namespace std;

class Person
{
public:
    Person();
    ~Person();
    void eat();
    string m_strName;
    int m_iAge;
};

person.cpp

#include"person.h"
#include<iostream>
using namespace std;

Person::Person()
{
    cout << "Person()" << endl;
}
Person::~Person()
{
    cout << "~Person()" << endl;
}
void Person::eat()
{
    cout << "eat()" << endl;
}

demo.cpp

#include<iostream>
#include<stdlib.h>
#include"worker.h"
using namespace std;

int main(void)
{
    Worker *p = new Worker();
    p->m_strName = "Jim";
    p->m_iAge = 10;
    p->eat();
    p->m_iSalary = 1000;
    p->work();
    delete p;
    p = NULL;


    system("pause");
    return 0;
}

在继承中，先实例化父类再实例化子类；
对象销毁时，先销毁子类再销毁父类。

公有继承
在说明这四个关键字之前，我想就class之间的关系做一个简单的定义，对于继承自己的class，base class可以认为他们都是自己的子女，而对于和自己一个目录下的classes，认为都是自己的朋友。

 1、public：public表明该数据成员、成员函数是对所有用户开放的，所有用户都可以直接进行调用

 2、private：private表示私有，私有的意思就是除了class自己之外，任何人都不可以直接使用，私有财产神圣不可侵犯嘛，即便是子女，朋友，都不可以使用。

 3、protected：protected对于子女、朋友来说，就是public的，可以自由使用，没有任何限制，而对于其他的外部class，protected就变成private。

保护继承和私有继承
这里写图片描述

person.h

#pragma once
#include<string>
using namespace std;

class Person
{
public:
    Person();
    void play();
protected:
    string m_strName;
};

person.cpp

#include"person.h"
#include<iostream>
using namespace std;

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

void Person::play()
{
    cout << "Person -- play()" << endl;
    cout << m_strName << endl;
}

Soldier.h

#pragma once
#include"person.h"

class Soldier :protected Person
{
public:
    Soldier();
    void work();
protected:
    int m_iAge;

soldier.cpp

#include<iostream>
#include"soldier.h"
using namespace std;

Soldier::Soldier()
{

}

void Soldier::work()
{
    m_strName = "Jim";
    m_iAge = 20;
    cout << m_strName << endl;
    cout << m_iAge << endl;
    cout << "Soldier -- work()" << endl;
}

Infantry.h

#pragma once
#include"Soldier.h"

class Infantry :public Soldier
{
public:
    void attack();
};

Infantry.cpp

#include<iostream>
#include"Infantry.h"
using namespace std;

void Infantry::attack()
{
    cout << "Infantry -- attack()" << endl;
}

demo.cpp

#include<iostream>
#include<stdlib.h>
#include"soldier.h"

int main(void)
{
    Soldier soldier;
    soldier.work();
    soldier.play();
    system("pause");
    return 0;
}

隐藏
这里写图片描述
person.h

#pragma once
#include<string>
using namespace std;

class Person
{
public:
    Person();
    void play();
protected:
    string m_strName;
};

person.cpp

#include"person.h"
#include<iostream>
#include<stdlib.h>
using namespace std;

Person::Person() 
{
    m_strName = "Merry";
}

void Person::play()
{
    cout << "Person -- play()" << endl;
    cout << m_strName << endl;
}

soldier.h

#pragma once
#include"person.h"

class Soldier :public Person
{
public:
    Soldier();
    void work();
    void play(int x);
protected:
    string m_strName;
};

soldier.cpp

#include<iostream>
#include"soldier.h"
using namespace std;

Soldier::Soldier()
{

}

void Soldier::play(int x)
{
    cout << m_strName << endl;
    cout << Person::m_strName << endl;
    cout << "Soldier -- play()" << endl;
}
void Soldier::work()
{
    m_strName = "Jim";
    Person::m_strName = "James";
    cout <<"Soldier -- work()" << endl;
}

demo.cpp

#include<iostream>
#include<stdlib.h>
#include"soldier.h"

int main(void)
{
    Soldier soldier;
    soldier.work();
    soldier.play(7);
    soldier.Person::play();
    system("pause");
    return 0;
}

这里写图片描述
person.h

#pragma once
#include<string>
using namespace std;

class Person
{
public:
    Person(string name="Jim");
    virtual ~Person(); //虚析构函数
    void play();
protected:
    string m_strName;
};

person.cpp

#include"person.h"
#include<iostream>
using namespace std;

Person::Person(string name) 
{
    m_strName = name;
    cout << "Person()" << endl;
}
Person::~Person()
{
    cout << "~Person" << endl;
}
void Person::play()
{
    cout << "Person -- play()" << endl;
    cout << m_strName << endl;
}

soldier.h

#pragma once
#include"person.h"

class Soldier :public Person
{
public:
    Soldier(string name="James",int age=20);
    virtual ~Soldier();
    void work();
protected:
    int m_iAge;
};

soldier.cpp

#include<iostream>
#include"soldier.h"
using namespace std;

Soldier::Soldier(string name,int age)
{
    m_strName = name;
    m_iAge = age;
    cout << "Soldier()" << endl;
}
Soldier::~Soldier()
{
    cout << "~Soldier()" << endl;
}

void Soldier::work()
{
    cout<<m_strName<<endl;
    cout<<m_iAge<<endl;
    cout <<"Soldier -- work()" << endl;
}

demo.cpp

#include<iostream>
#include<stdlib.h>
#include"soldier.h"


void test1(Person p)
{
    p.play();
}
void test2(Person & p)
{
    p.play();
}
void test3(Person  *p)
{
    p->play();
}

int main(void)
{
    //Person *p=new Soldier;//Person p=soldier;//把soldier的m_strName赋值给了person的m_strName 
    //p->play(); 
    //delete p;
    //p = NULL;
    Person p;
    Soldier s;

    test1(p);
    test1(s);

    test2(p);
    test2(s);

    test3(&p);
    test3(&s);//test3要求的是指针，所以取地址；与test2调用的结果相同

    system("pause");
    return 0;
}

运行结果：
这里写图片描述
多继承，多重继承
这里写图片描述

person.h

#pragma once
#include<string>
using namespace std;

class Person
{
public:
    Person(string name="Jim");
    virtual ~Person(); //虚析构函数
    void play();
protected:
    string m_strName;
};

person.cpp

#include"person.h"
#include<iostream>
using namespace std;

Person::Person(string name) 
{
    m_strName = name;
    cout << "Person()" << endl;
}
Person::~Person()
{
    cout << "~Person" << endl;
}
void Person::play()
{
    cout << "Person -- play()" << endl;
    cout << m_strName << endl;
}

soldier.h

#pragma once
#include"person.h"

class Soldier :public Person
{
public:
    Soldier(string name="James",int age=20);
    virtual ~Soldier();
    void work();
protected:
    int m_iAge;
};

soldier.cpp

#include<iostream>
#include"soldier.h"
using namespace std;

Soldier::Soldier(string name,int age)
{
    m_strName = name;
    m_iAge = age;
    cout << "Soldier()" << endl;
}
Soldier::~Soldier()
{
    cout << "~Soldier()" << endl;
}

void Soldier::work()
{
    cout<<m_strName<<endl;
    cout<<m_iAge<<endl;
    cout <<"Soldier -- work()" << endl;
}

Infantry.h

#pragma once
#include"soldier.h"

class Infantry :public Soldier
{
public:
    Infantry(string name = "Jack", int age = 30);
    ~Infantry();
    void attack();
};

Infantry.cpp

#include<iostream>
#include"Infantry.h"
using namespace std;

Infantry::Infantry(string name, int age)
{
    m_strName = name;
    m_iAge = age;
    cout << "Infantry()" << endl;
}
Infantry::~Infantry()
{
    cout << "Infantry()" << endl;
}
void Infantry::attack()
{
    cout << m_strName << endl;
    cout << m_iAge << endl;
    cout << "Infantry -- attack()" << endl;
}

demo.cpp

#include<iostream>
#include<stdlib.h>
#include"Infantry.h"


void test1(Person p)
{
    p.play();
}
void test2(Person & p)
{
    p.play();
}
void test3(Person  *p)
{
    p->play();
}

int main(void)
{
    Infantry infantry;
    test1(infantry);
    test2(infantry);
    test3(&infantry);//无论继承的层级有几层，他们只要保持着直接或间接的继承关系，子类都可以和他的直接父类或间接父类形成is a的关系
     //并且能够通过父类的指针对直接子类或者是间接子类的对象进行操作


    system("pause");
    return 0;
}

在最底层的类，要实例化对象，就必须执行继承量当中的每一个类
在销毁的时候，逆序执行
无论继承有多少级，只要保持间接或者直接的关系，子类都可与自己的直接父类，或者是间接父类，称之为is a 的关系，并且能够通过父类的指针对直接子类或者是间接子类的对象进行操作

虚继承
这里写图片描述
person.h

#pragma once
#ifndef PERSON_H
#define PERSON_H//宏定义用来解决重定义，在菱形定义当中重定义必然会出现
//（菱形继承的时候，普通继承后会出现重定义，Person被继承了两次。）
#include<string>
using namespace std;

class Person
{
public:
    Person(string color = "blue");
    virtual ~Person();
    void printColor();
protected:
    string m_strColor;
};

#endif

person.cpp

#include<iostream>
#include"person.h"
using namespace std;

Person::Person(string color)
{
    m_strColor = color;
    cout << "Person()" << endl;
}
Person::~Person()
{
    cout << "~Person()" << endl;
}
void Person::printColor()
{
    cout << m_strColor << endl;
    cout << "Person -- printColor()" << endl;
}

worker.h

#pragma once
#include<string>
#include"person.h"
using namespace std;
class Worker:virtual public Person
{
public:
    Worker(string code = "001",string color="blue");
    virtual  ~Worker();
    void carry();
protected:
    string m_strCode;
};

worker.cpp

#include<iostream>
#include"worker.h"
using namespace std;

Worker::Worker(string code,string color):Person("Worker"+color)
{
    m_strCode = code;
    cout << "Worker()" << endl;
}
Worker::~Worker()
{
    cout << "~Worker()" << endl;
}
void Worker::carry()
{
    cout << m_strCode << endl;
    cout << "Worker -- carry()" << endl;
}

farmer.h

#pragma once
#include<string>
#include"person.h"
using namespace std;

class Farmer:virtual public Person//虚基类
{
public:
    Farmer(string name = "Jack",string color="blue");
    virtual~Farmer();
    void sow();
protected:
    string m_strName;
};

farmer.cpp

#include<iostream>
#include"farmer.h"
using namespace std;

Farmer::Farmer(string name,string color):Person("Farmer"+color)
{
    m_strName = name;
    cout << "Farmer()" << endl;
}
Farmer::~Farmer()
{
    cout << "~Farmer()" << endl;
}
void Farmer::sow()
{
    cout << m_strName << endl;
    cout << "Farmer -- sow()" << endl;
}

migrantworker.h

#pragma once
#include"worker.h"
#include"farmer.h"

class MigrantWorker:public Farmer,public Worker
{
public:
    MigrantWorker(string name, string code,string color);
    ~MigrantWorker();
};

migrantworker.cpp

#include"migrantworker.h"
#include<iostream>
using namespace std;

MigrantWorker::MigrantWorker(string name, string code,string color) :Farmer(name,color), Worker(code,color)//初始化列表
{
    cout << "MigrantWorker()" << endl;
}
MigrantWorker::~MigrantWorker()
{
    cout << "MigrantWorker()" << endl;
}

demo.cpp

#include<iostream>
#include<stdlib.h>
#include"migrantworker.h"

int main(void)
{
    MigrantWorker *p = new MigrantWorker("merry", "200","yellow");
    p->Farmer::printColor();
    p->Worker::printColor();
    delete p;
    p = NULL;


    system("pause");
    return 0;
}

运行结果：
这里写图片描述

结果分析：为啥没把yellow传进去？
首先virtual词典里解释为本质上存在但是没有表现形式，而C++中 注意 //virtual 写在了共有继承前面，意思就是在继承时是真实存在但是不能被访问；换句话说，你在实例化对象MigrantWorker时需要实例化Farmar和Worker，而实例化这两个对象需要先实例化一个Person，那么传入值你选谁的？所以系统此时设置为禁止访问，在对象生成后你可以随便访问，因为你不可能通过两种方式同时访问一个对象内的成员。采用初始化列表的方式来赋值，Per实例化时是不能被访问的因此值传不进去，如果你Far和Wor的构造函数体内用 m_strColor=color是可以改的。因为执行有先后顺序，不冲突。//

白崽啦啦啦
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
正确使用#include和前置声明(forward declaration)
SpriteLW的专栏
07-23 3万+
差不多一年时间没用过C++写过程序了,由于工作的需要,我又回到了C++的阵形。在工作的过程中遇到了很多麻烦，当我往工程里加一个类，而且那个类又与工程里的类相关，如有那个类型的成员变量。情况如下//////A.h///////////class A{.......};////////B.h//////////class B:A{....A member;}
C++链表类模板
zilisen的博客
06-05 2468
记录自己写的一个链表类模板，两个头文件：一个是节点头文件Node.h，一个是链表头文件LinkList.h。
c++小白慕课网程序6
白崽啦啦啦的博客
10-29 305
c++模板篇 使用友元函数，使得传入进来的对象去访问他的私有数据成员和成员函数 time.h#pragma once #ifndef TIME_H #define TIME_H#include"match.h"//match是从哪里来的 #include<iostream> using namespace std;class Time { friend void Match:: prin
c++小白慕课网教程的一些程序
白崽啦啦啦的博客
10-17 636
#include #include #include using namespace std; int main(void) { string name; cout  "please input your name:"  endl; getline(cin, name); if (name.empty()) { cout  "input is null.."; system
c++小白慕课网程序5
白崽啦啦啦的博客
10-22 171
c++远征之多态篇 shape.h#pragma once #ifndef SHAPE_H #define SHAPE_H//避免重复包含#include<iostream> using namespace std;class Shape { public : Shape(); ~Shape(); virtual double calcArea(); }; #endif /
C++小白慕课网的一些程序2
白崽啦啦啦的博客
10-17 361
Teacher.h#include<iostream> #include<string> using namespace std; class Teacher { public: Teacher(string name="Jim",int age=1,int m=100);//自定义有参数默认构造函数 void setName(string name); string get
C++小白自制游戏《GO世界》
04-05
本游戏由小白制作，不喜勿喷。 本游戏借鉴了@JH_duangduang的代码，已经过作者同意使用！ 游戏还有彩蛋哦！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！ ...
中国大学慕课c++实验
01-15
### 中国大学慕课C++实验知识点解析 #### 鞍点问题 在数学和计算机科学领域中，鞍点（Saddle Point）是指一个矩阵中的某个元素，在其所在行中最大，在其所在列中最小。鞍点的存在可以揭示出矩阵中的某些特性。 **...
小白对c++的入门学习
06-07
作为初学者，尤其是“小白”级别的学习者，理解并掌握C++的基本概念和语法是入门的关键。 首先，C++的基础知识包括以下几个核心部分： 1. **基本语法**：C++的语法与C语言很相似，但更为严谨。它包含变量声明、...
C++小白如何入门？
01-03
——致C++入门小白的一封信 三月的春风，伴着轻快的键盘敲击声，我们终于与C++这高大上的名词见面了！ 大家都说：上了战场，不仅拼自身的身体素质，还得拼你的枪械，那在C++里面的枪械则是：编译器那，其他的大佬们...
卷积神经网 CNN C++ 实现
05-15
4. **批量归一化**（Batch Normalization）：批量归一化能够加速训练过程，提高模型的稳定性和泛化能力。它通过对每个mini-batch的数据进行标准化处理，使输入保持恒定的分布。 5. **损失函数**：对于分类问题，...
c++ 从新手小白到得心应手
weixin_42362399的博客
09-28 58
c++ 从入门到上路
一个基类Person的多个派生类
梧秋的博客
05-07 5405
题目内容： 已知基类Person的定义如下： class Person { protected: char Name[10]; char Sex; int Age; public: void Register(char *name,int age,char sex); void ShowMe(); }; 请通过继承的方法建立两个派生类，其中 派生类Teache...
C++学习笔记7——继承篇
等等waiting
02-09 162
继承 举例： 上例优化： 关系： 对应使用，不能交叉 编码示例： Person.h #include <string> using namespace std; class Person { public: Person(); ~Person(); void eat(); public: string m_strName; int m_iAge; }; Pe...
C语言 | Leetcode C语言题解之第337题打家劫舍III
最新发布
m0_59237910的博客
08-15 344
C语言 | Leetcode C语言题解之第337题打家劫舍III
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值