类与继承

最新推荐文章于 2021-12-23 13:16:28 发布
最新推荐文章于 2021-12-23 13:16:28 发布
阅读量224 收藏 1
点赞数
分类专栏： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/snowyuuu/article/details/100603073
版权 
#ifndef ANIMAL_H
#define ANIMAL_H
#include<iostream>
#include<string>
class Animal
{
public:
	Animal();
	Animal(const std::string type_name1, int leg, std::string action);
	Animal(const Animal& animal);
	//Animal& operator=(const Animal& animal);
	virtual ~Animal();

	//virtual std::string Type_name() const;
	virtual void Type_name(std::string type_name1);
	virtual void Leg(int val);
	virtual void Behaviour(std::string action);

	virtual void animal_type(const Animal*);
	virtual void leg_number(const Animal*);
	virtual void move_type(const Animal*);
	
protected:
	std::string m_type_name;//动物类型
	int m_leg = 0;
	std::string m_behaviour;//行走方式

};

#endif
#ifndef BIRDS_H
#define BIRDS_H
#include "Animal.h"
#include<iostream>
#include<string>
class  Birds :public Animal
{
public:
	Birds();
	Birds(const std::string type_name1, int leg, std::string action, int weigh_val);
	Birds(const Birds& bird);
	Birds& operator=(const Birds& bird);
	virtual ~Birds();
	virtual void Weigh(int val);
	virtual void animal_type(const Animal*);
	virtual void leg_number(const Animal*);
	virtual void move_type(const Animal*);
	virtual void egg_weight(const Birds*);
	
protected:
	int m_weigh = 0;
	
};




#endif
#ifndef _D0G_H
#define _DOG_H
#include"Mammals.h"
#include<iostream>
#include<string>
class Dog :public Mammals
{
public:
	Dog();
	Dog(const std::string type_name1, int leg, std::string action, int pregnant_period);
	Dog(const Dog& dog);
	virtual void move_type(const Animal*);
	virtual void pregnant_month_count(const Mammals*);
};
#endif
#ifndef MAMMALS_H
#define MAMMALS_H
#include "Animal.h"
#include<iostream>
#include<string>
class  Mammals :public Animal
{
public:
	Mammals();
	Mammals(const std::string type_name1, int leg, std::string action, int pregnant_period);
	Mammals(const Mammals& mammals);
	//Mammals& operator=(const Mammals& mammals);
	virtual ~Mammals();
	virtual void animal_type(const Animal*);
	virtual void leg_number(const Animal*);
	virtual void move_type(const Animal*);
	virtual void pregnant_month_count(const Mammals*);
	
	virtual void Pregnant_period(int val);
protected:
	int  m_pregnant_period;
};

#endif
#ifndef _OSTRICH_H
#define _OSTRICH_H
#include "Birds.h"
#include<iostream>
#include<string>
class Ostrich :public Birds
{
public:
	Ostrich();
	Ostrich(const std::string type_name1, int leg, std::string action, int weigh_val);
	Ostrich(const Ostrich& ostrich);
	virtual void move_type(const Animal*);
	virtual void egg_weight(const Birds*);
};


#endif
#ifndef SPARROW_H
#define SPARROW_H
#include "Birds.h"
#include<iostream>
#include<string>
class Sparrow :public Birds
{
public:
	Sparrow();
	Sparrow(const std::string type_name1, int leg, std::string action, int weigh_val);
	Sparrow(const Sparrow& sparrow);
	virtual void move_type(const Animal*);
	virtual void egg_weight(const Birds*);
};

#endif

#ifndef _WHALE_H
#define _WHALE_H
#include"Mammals.h"
#include<iostream>
#include<cstring>
class Whale :public Mammals
{
public:
	Whale();
	Whale(const std::string type_name1, int leg, std::string action, int pregnant_period);
	Whale(const Whale& whale);
	virtual void move_type(const Animal*);
	virtual void pregnant_month_count(const Mammals*);
};


#endif
#include "Animal.h"
#include<iostream>
#include<string>
Animal::Animal()
{

}
Animal::Animal(const std::string type_name1, int leg, std::string action)
{
	m_type_name.assign(type_name1);//将字符串付给m_type_name
	m_leg = leg;
	m_behaviour.assign(action);
	
}
Animal::Animal(const Animal& animal)
{
	/*int len = strlen(animal.m_type_name);
	m_type_name = new std::string[len];
	memset(m_type_name, 0, len);
	strcpy(m_type_name, animal.m_type_name);*/
	m_type_name.assign(animal.m_type_name);
	m_leg = animal.m_leg;
	m_behaviour.assign(animal.m_behaviour);

	/*int action_len = strlen(animal.m_behaviour);
	m_behaviour = new std::string[action_len];
	memset(m_behaviour, 0, action_len);
	strcpy(m_behaviour, animal.m_behaviour);*/
}
Animal::~Animal()
{
	//delete m_type_name;
	//delete m_behaviour;
}


void Animal::Type_name(std::string type_name1)
{
	m_type_name = type_name1;
}
void Animal::Leg(int val)
{
	 m_leg = val; 
}
void Animal::Behaviour(std::string action)
{
	m_behaviour = action;
}

void Animal::animal_type(const Animal*)
{
	std::cout << "the type: " << m_type_name<<std::endl;
}

void Animal::leg_number(const Animal*)
{
	if (-1 == m_leg)
	{
		std::cout << "leg_number is NOTSURE" << std::endl;
	}
	else
	{
		std::cout << "leg_number: " << m_leg << std::endl;
	}
}
void Animal::move_type(const Animal*)
{
	std::cout << "move_type: " <<m_behaviour<< std::endl;
}
#include "Birds.h"
#include "Animal.h"
#include<iostream>
#include<string.h>
using namespace std;
Birds::Birds()
{

}
Birds::Birds(const std::string type_name1, int leg, std::string action,int weigh_val)
	:Animal(type_name1, leg, action)
{
	m_weigh = weigh_val;
}
Birds::Birds(const Birds& bird)
	: Animal(bird)
{
	m_weigh = bird.m_weigh;
}
//Birds::Birds& operator=(const Birds& bird)
Birds:: ~Birds()
{

}


void Birds::Weigh(int val)
{
	m_weigh = val;
}
void Birds:: animal_type(const Animal*)
{
	std::cout << "the type belong to " << m_type_name<< endl;
}
void Birds::leg_number(const Animal*)
{
	std::cout << "leg_number  is " << m_leg << endl;
}
void Birds::move_type(const Animal*)
{
	std::cout << "Birds move_type " << m_behaviour << endl;
}
void Birds::egg_weight(const Birds*)
{
	if (-1 == m_weigh)
	{
		std::cout << "egg_weight is NOTSURE" << endl;
	}
	else
	{
		std::cout << "Birds egg_weight: " << m_weigh << endl;
	}
	
}






#include "Mammals.h"
#include "Dog.h"
#include<iostream>
#include<string.h>

Dog::Dog()
{

}
Dog::Dog(const std::string type_name1, int leg, std::string action, int pregnant_period)
	:Mammals(type_name1, leg, action, pregnant_period)
{

}
Dog::Dog(const Dog& dog)
	:Mammals(dog)
{

}
void Dog::move_type(const Animal*)
{
	std::cout << "Dog move_type is " << m_behaviour<< std::endl;
}
void Dog::pregnant_month_count(const Mammals*)
{
	std::cout << "Dog pregnant_month_count is " << m_pregnant_period <<"days"<<std::endl;
}
#include"Mammals.h"
#include "Animal.h"
#include<iostream>
#include<string.h>

Mammals::Mammals()
{

}
Mammals::Mammals(const std::string type_name1, int leg, std::string action, int pregnant_period)
	:Animal(type_name1, leg, action)
{
	m_pregnant_period = pregnant_period;
}
Mammals::Mammals(const Mammals& mammals)
	: Animal(mammals)
{
	m_pregnant_period = mammals.m_pregnant_period;
}
//Mammals::Mammals& operator=(const Mammals& mammals);
Mammals:: ~Mammals()
{

}

void Mammals::Pregnant_period(int val)
{
	m_pregnant_period = val;
}
void Mammals::animal_type(const Animal*)
{
	std::cout << "the type belong to "<<m_type_name << std::endl;
}
void Mammals::leg_number(const Animal*)
{
	std::cout << "leg_number  is " << m_leg << std::endl;
}
void Mammals::move_type(const Animal*)
{
	std::cout << "Mammals move_type " << m_behaviour << std::endl;
}
void Mammals::pregnant_month_count(const Mammals*)
{
	if (-1 == m_pregnant_period)
	{
		std::cout << "pregnant_month_count is NOTSURE" << std::endl;
	}
	else
	{
		std::cout << "Mammals pregnant_month_count:" << m_pregnant_period << std::endl;
	}
	
}




#include "Birds.h"
#include"Ostrich.h"
#include<iostream>
#include<string.h>

Ostrich::Ostrich()
{

}
Ostrich::Ostrich(const std::string type_name1, int leg, std::string action, int weigh_val)
	:Birds(type_name1, leg, action, weigh_val)
{

}
Ostrich::Ostrich(const Ostrich& ostrich)
	: Birds(ostrich)
{

}
void Ostrich::move_type(const Animal*)
{
	std::cout << "Ostrich move_type " << m_behaviour << std::endl;
}
void Ostrich::egg_weight(const Birds*)
{
	std::cout << "Ostrich egg_weight: " << m_weigh <<"g"<< std::endl;
}
#include "Birds.h"
#include"Sparrow.h"
#include<iostream>
#include<string.h>

Sparrow::Sparrow()
{

}
Sparrow::Sparrow(const std::string type_name1, int leg, std::string action, int weigh_val)
	:Birds(type_name1, leg, action, weigh_val)
{

}
Sparrow::Sparrow(const Sparrow& sparrow)
	: Birds(sparrow)
{

}

void Sparrow::move_type(const Animal*)
{
	std::cout << "Sparrow move_type " << m_behaviour;
	std::cout<< std::endl;
}
void Sparrow::egg_weight(const Birds*)
{
	std::cout << "Sparrow egg_weight: " << m_weigh <<"g" << std::endl;
}

#include "Mammals.h"
#include"Whale.h"
#include<iostream>
#include<cstring>

Whale::Whale()
{

}
Whale::Whale(const std::string type_name1, int leg, std::string action, int pregnant_period)
	:Mammals(type_name1, leg, action, pregnant_period)
{

}
Whale::Whale(const Whale& whale)
	:Mammals(whale)
{

}

void Whale::move_type(const Animal*)
{
	std::cout << "Whale move_type is " << m_behaviour;
	std::cout<<std::endl;
}
void Whale::pregnant_month_count(const Mammals*)
{
	std::cout << "Whale pregnant_month_count is " << m_pregnant_period <<"days" << std::endl;
}
//C++类方式实现动物(Animal)、飞禽(Birds)、哺乳动物(Mammals)、麻雀(Sparrow)、鸵鸟(Ostrich)、狗(Dog)、鲸鱼（Whale）
//提供接口：
//（1）animal_type(const Animal*)动物类型， 例如：接口中打印飞禽或哺乳类
//（2）leg_number(const Animal*)几只脚，打印出脚的个数
//（3）move_type(const Animal*)行走的方式，打印出飞、走
//（4）egg_weight(const Birds*)蛋的重量
//（5）pregnant_month_count(const Mammals*)
//要求：
//（1）成员变量不能为public
#include<iostream>
#include<windows.h>
#include "Animal.h"
#include "Birds.h"
#include"Mammals.h"
#include "Dog.h"
#include"Whale.h"
#include "Ostrich.h"
#include"Sparrow.h"
using namespace std;//C++标准库中的函数或者对象都是在命名空间std中定义的,所以要调用C++标准库时，要写上std
int main()
{
	
	animals
	//cout << "animals" << endl;
	//Animal* animal = new Animal;//构造
	//animal->animal_type(animal);
	//animal->leg_number(animal);
	//animal->move_type(animal);
	飞禽类
	//cout << "Birds" << endl;
	//Animal* birds = new Birds;
	//birds->animal_type(birds);
	//birds->leg_number(birds);
	//birds->move_type(birds);
	//Birds* bird=new Birds;
	//bird->egg_weight(bird);
	//cout << "sparrow" << endl;
	//Birds* sparrow = new Sparrow("Birds",2,"fly", 200);
	//sparrow->animal_type(sparrow);
	//cout << "ostrich" << endl;
	//Birds* ostrich = new Ostrich("Birds",2, "walk", 500);
	//ostrich->animal_type(ostrich);
	//cout << "dog" << endl;
	//Mammals* dog = new Dog;
	//dog->animal_type(dog);//mammals;
	//dog->leg_number(dog);
	//dog->move_type(dog);//dog
	//dog->pregnant_month_count(dog);
	//cout << "whale" << endl;
	//Mammals* whale = new Whale;
	//whale->animal_type(whale);
	//whale->leg_number(whale);
	//whale->move_type(whale);
	//whale->pregnant_month_count(whale);
	//delete animal;
	//delete bird;
	//delete sparrow;
	//delete ostrich;
	//delete dog;
	//delete whale;

	//动物类
	cout << "animals" << endl;
	Animal animal;
	animal.Type_name("animal");
	animal.Leg(-1);
	animal.Behaviour("NOTSURE");
	Animal* _animal = new Animal;
	animal.animal_type(_animal);
	animal.leg_number(_animal);
	animal.move_type(_animal);

	//飞禽
	cout << "Birds" << endl;
	Birds bird;
	bird.Type_name("Birds");
	bird.Leg(2);
	bird.Behaviour("NOTSURE");
	bird.Weigh(-1);
	Animal* birds = new Birds;
	bird.animal_type(birds);
	bird.leg_number(birds);
	bird.move_type(birds);
	Birds* _bird = new Birds;
	bird.egg_weight(_bird);
	//哺乳
	cout << "mammals" << endl;
	Mammals mammal;
	mammal.Type_name("Mammals");
	mammal.Leg(4);
	mammal.Behaviour("NOTSURE");
	mammal.Pregnant_period(-1);
	Animal* mammals = new Mammals;
	mammal.animal_type(mammals);
	mammal.leg_number(mammals);
	mammal.move_type(mammals);
	Mammals* _mammal = new Mammals;
	mammal.pregnant_month_count(_mammal);

	//麻雀
	cout << "sparrow" << endl;
	Animal* sparrow=new Sparrow("Birds",2,"fly",200);
	sparrow->animal_type(sparrow);
	sparrow->leg_number(sparrow);
	sparrow->move_type(sparrow);
	Birds* _sparrow = new Sparrow("Birds", 2, "fly", 200);
	_sparrow->egg_weight(_sparrow);
	//鸵鸟
	cout << "ostrich" << endl;
	Animal* ostrich = new Ostrich("Birds", 2, "walk", 500);
	ostrich->animal_type(ostrich);
	ostrich->leg_number(ostrich);
	ostrich->move_type(ostrich);
	Birds* _ostrich = new Ostrich("Birds", 2, "walk", 500);
	_ostrich->egg_weight(_ostrich);
	//狗
	cout << "dog" << endl;
	Animal* dog = new Dog("Mammals", 4, "walk", 60);
	dog->animal_type(dog);
	dog->leg_number(dog);
	dog->move_type(dog);
	Mammals* _dog = new Dog("Mammals", 4, "walk", 60);
	_dog->pregnant_month_count(_dog);
	//鲸鱼
	cout << "whale" << endl;
	Animal* whale = new Whale("Whale", 4, "swim", 365);
	whale->animal_type(whale);
	whale->leg_number(whale);
	whale->move_type(whale);
	Mammals* _whale = new Whale("Whale", 4, "walk", 365);
	_whale->pregnant_month_count(_whale);

	
	delete _animal;
	delete birds;
	delete _bird;
	delete mammals;
	delete _mammal;
	delete sparrow;
	delete _sparrow;
	delete ostrich;
	delete _ostrich;
	delete dog;
	delete _dog;
	delete whale;
	delete _whale;

	system("pause");
	return 0;
}

 

hello_shaonian
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JavaScript OOP类与继承
10-29
JavaScript OOP类与继承实现代码，需要的朋友可以参考下。
java基础类与继承.ppt
04-23
Java中的类与继承是面向对象编程（Object-Oriented Programming, OOP）的核心概念，它们在构建复杂的软件系统中起到至关重要的作用。面向对象编程是一种编程范式，它基于对象和类的概念，通过继承、封装和多态等特性...
类和继承
One piece
04-06 364
继承(inheritance)机制是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加功能。这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程。
类与类的继承
peachzy的博客
03-05 441
一、类的继承例子 #include<iostream> using namespace std; class DataType { private: int year, month, day; public: DataType(int year_ = 1997, int month_=10, int day_ = 6) { year = year_; month = month_; day = day_; cout << "DataType的构造函数" <&
类与类的继承关系
weixin_30307921的博客
07-09 1454
1.单继承 1.从类名执行父类的属性 2.从对象执行父类的一切 注意: 子类以及子类对象只能调用父类的属性以及方法,不能操作(增删改) # 既要执行父类方法又要执行子类方法,两种解决方式: class Animal: live = '有生命的' def __init__(self, name, age, sex): self.name = name ...
类和继承重点知识详述
@另维
11-14 348
1、继承 1、概述：将多个类中存在相同的属性和行为时，将这些内容抽取到单独一个类中，再写其他类的时候无需再定义这些属性和行为，只要继承那个类就好。 语法 : class 子类名 extends 父类名 单独这个类称为父类、基类、超类，这多个继承自父类的类称为子类、派生类 有了继承之后，我们可以在一个已经存在的类继承上还可以定义自己的新成员。 2、好处：提高了代码的复用性、可维护性、让类与类之...
about the extend.rar_A7W_java类与继承
09-21
1. 理解类继承的概念； 2. 掌握从现有类中继承类； 3. 掌握声明和使用继承类对象的方法。 二、实验任务与要求 （一）实验要求 1. 编写继承类； 2. 编写超类、继承类的属性和方法； （二）实验任务 1. 根据下面程序...
c++课件 派生类与继承
05-08
c++课件 派生类与继承
第9章 派生类与继承.ppt
01-24
在上面的例子中，employee 类继承了 person 类的全部特性，并添加了新的成员变量 department 和 salary。 继承的应用 继承可以应用于许多领域，例如： * 在游戏开发中，游戏角色可以继承基础类的属性和行为，例如...
类与类的关系---继承
m0_65300193的博客
12-23 2009
类与类的关系有以下几种： A is-a B 继承、实现===>统称泛化 A has-a B 组合、聚合、关联===>统称包含 A use-a B 依赖（need） 继承： 子类、父类 1.子类继承父类，通过关键字“extends”； 2.子类的对象可以调用父类的（public、protected）属性和方法，当作自己的去使用，增强了复用性； 3.子类可以添加自己独有的方法和属性； 4.子类从父类继承来的方法不能满足子类的要求，可以在子类中重写（覆盖）父类的...
类的继承——继承的概念和意义
食梦者
05-30 7329
本文参照于狄泰软件学院，唐佐林老师的——《C++深度剖析教程》
新建一个鲜花类Flower，其中有一个私有成员属性name，字符串类型，方法有构造方法，setName(String name)和String getName()。在测试类中输入具体鲜花构建实
qq_41365496的博客
04-25 3322
题目描述 新建一个鲜花类Flower，其中有一个私有成员属性name，字符串类型，方法有构造方法，setName(String name)和String getName()。在测试类中输入具体鲜花的名字，构建实例，打印输出“I am …”。 输入描述 输入鲜花的名字（见样例） 输出描述 输出 I am 鲜花的名字（见样例） 说明：符号为英文符号 输入样例 rose 输出样例 I am rose. ...
类与类之间的关系-继承
zhouhe_的博客
05-20 2021
类与类之间的关系 A is-a B 泛化 （继承 实现） A has-a B 包含 （组合 聚合 关联） A use-a B 依赖 （依赖） 类关系设计：高内聚 低耦合 ：继承（实现）>组合>聚合>关联 > 依赖 继承 1.子类继承父类，通过一个关键字 extends 2.子类对象可以调用父类中的（public protected）属性和方法 当作自己的来使用 3.子类可以添加自己独有的属性和方法 4.子类从父类中继承过来的方法不能满足子类需要，可以在子类中
C++ API设计笔记
网络资源是无限的
03-29 7083
《C++ API设计》原英文版由Martin Reddy著，中文版出版于2013年，这里是中文版的笔记。 1. API简介 1.1 什么是API：API(Application Programming Interface)提供了对某个问题的抽象，以及客户与解决该问题的软件组件之间进行交互的方式。组件本身通常以软件类库形式分发，它们可以在多个应用程序中使用。概况地说，API定义了一些可复用的模块...
C++中继承的概念和意义
年少轻狂，幸福时光
08-08 9958
    在C++中，类与类之间的关系有组合与继承两种，以生活中的例子来举例，组合就好比电脑这个类由主板、CPU、内存、硬盘等这些类组成的，属于整体与部分的关系，如下图: 而继承则好比电脑与苹果电脑、戴尔电脑之间的关系，也叫父子关系，电脑为父类，苹果电脑与戴尔电脑为子类，如下: 先来讨论类的组合关系：     - 将其他类的对象作为当前类的成员使用     - 成员对象与当前类的对象生命周期相同 ...
面向对象理论概述
weixin_33966365的博客
06-25 96
2019独角兽企业重金招聘Python工程师标准>>> ...
C++复习（虚函数）
weixin_43912806的博客
05-09 104
定义他为虚函数是为了允许用基类的指针来调用子类的这个函数。 定义一个函数为纯虚函数，才代表函数没有被实现。 定义纯虚函数是为了实现一个接口，起到一个规范的作用，规范继承这个类的程序员必须实现这个函数。 一个类函数的调用并不是在编译时刻被确定的，而是在运行时刻被确定的。由于编写代码的时候并不能确定被调用的是基类的函数还是哪个派生类的函数，所以被成为“虚”函数。 虚函数只能借助于指针或者引用来达到多态...
Java学习笔记(一)--面向对象
热门推荐
至尊宝
03-03 2万+
强烈推荐一个大神的人工智能的教程：http://www.captainbed.net/zhanghan 前言 Java语言是纯粹的面向对象的程序设计语言,这主要表现在java完全支持面向对象的三种基本特征:继承,封装和多态。java语言完全以对象为中心,java程序的最小程序单位是类,整个Java程序由一个一个的类组成。 虽然抽象是面向对象的重要部分,但他不是面向对象的特征...
java类与继承-抽象类
最新发布
09-06
Cat类继承自Animal类，并且重写了run方法。在CatTest类的main方法中，创建了一个Cat对象并调用了run方法。 更多关于Java类与继承-抽象类的知识，可以参考Java基础教程之接口的继承与抽象类。<span class="em">1...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值