多态、泛型复习

已于 2022-03-01 13:14:14 修改
阅读量139 收藏
点赞数
文章标签： c++ 泛型
于 2022-03-01 11:58:02 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_53077874/article/details/123202585
版权

1. 浅拷贝和深拷贝

#include<iostream>
using namespace std;

class Person
{
public:
	//无参构造函数
	Person();
	//有参构造函数
	Person(int age, int height)
	{
		m_age = age;
		m_heigt =new int(height) ;
	}
	//拷贝构造函数
	Person(const Person& p)
	{
		m_age = p.m_age;
		//如果不利用深拷贝在堆区创建新内存，会导致浅拷贝带来的重复释放堆区问题
		m_heigt = new int(*p.m_heigt);
	}
	//析构函数
	~Person()
	{
		if (m_heigt != NULL)
		{
			delete	m_heigt;
			m_heigt = NULL;
		}
	}

public:
	int m_age;
	int *m_heigt;

};
void test01()
{	
	Person p1(10, 160);
	Person p2(p1);
	cout << p1.m_age << "   " << *p1.m_heigt << endl;
	cout << p2.m_age << "   " << *p2.m_heigt << endl;
}


int main() {
	test01();
	system("pause");
	return 0;

};

2. 成员函数重载运算符

//重载前置++运算符
	Person& operator++()
	{	
		m_A++;
		return *this;
	}


	//后置递增
	Person operator++(int)
	{
		//先记录当时结果
		Person temp = *this;
		//再做递增
		m_A++;
		//最后将记录返回
		return temp;
	}

//重载赋值=运算符
Person& operator=(Person &p)
	{	
		//判断有无堆区内存
		if (m_A != NULL)
		{
			delete m_A;
			m_A = NULL;
		}
		//提供深拷贝，解决浅拷贝的问题
		m_A = new int(*p.m_A);
		return *this;
	}

3. 菱形继承

对虚基类的继承，产生vbptr虚基表指针，指向虚基表，虚基表记录的是当前位置距离下面虚基类的偏移量。也就是全局只有一个父类的变量，值为最后一次修改的量。

//菱形继承问题
class Animal
{
public:
	int m_Age;

};
//继承前加virtual关键字之后，变为虚继承；
//此时公共的父类Animal成为虚基类
class Sheep : virtual public Animal {};
class Tuo:virtual public Animal{};
class SheepTuo :public Sheep, public Tuo {};

void test01() 
{
	SheepTuo st;
	st.Sheep::m_Age = 100;
	st.Tuo::m_Age = 10;
	cout << st.m_Age << endl;
}

4. 动态多态

多态性满足条件：

  1. 有继承关系
  2. 子类重写父类中的虚函数

多态性的使用：

父类指针或引用指向子类对象

我们希望传入声明对象，那么就调用什么对象的函数：

  1. 如果函数地址在编译阶段就确定，那么是静态联编
  2. 如果函数地址在运行阶段才能确定，那么就是动态联编

产生vfptr（虚函数指针）指向vftab`（虚函数表）；
父类的指针或者引用指向子类对象时候，发生多态性；
子类的虚函数表 内部 会替换子类的虚函数地址；

#include<iostream>
using namespace std;

class Animal
{
public:
	//函数前面加上virtual，变成虚函数，那么编译器在编译的时候就不能确定该函数调用了
	virtual void speak()
	{
		cout << "动物在说话" << endl;
	}
};
class Cat:public Animal
{
public:
	void speak()
	{
		cout << "小猫在说话" << endl;
	}
};
class Dog :public Animal
{
	void speak()
	{
		cout << "小狗在说话" << endl;
	}
};

void DoSpeak(Animal &animal)
{
	animal.speak();
}
void test01() 
{
	Cat cat;
	Dog dog;
	DoSpeak(cat);
	DoSpeak(dog);
}

int main() {
	test01();
	system("pause");
	return 0;

};

5. 纯虚函数和抽象类

class Base
{
public:
	//纯虚函数
	//只要有一个纯虚函数，这个类为抽象类
	//抽象类特点：
	//1. 无法实例化对象
	//2. 抽象类的子类 必须要重写父类的纯虚函数 ，不然也是抽象类
	virtual void func() = 0;
};
class Son:public Base
{
	 void func() {};

};

void test01() 
{
	Base *b=new Son;
	b->func();

}

6. 虚析构和纯虚析构

如果子类中有属性开辟到堆区，解决父类指针释放子类对象不干净的问题

#include<iostream>
using namespace std;
#include<string>
//纯虚函数和抽象类
class Animal
{
public:

	Animal()
	{
		cout << "Animal构造函数" << endl;
	}
	virtual void speak()=0;
	//利用虚析构解决父类指针释放子类对象不干净的问题
	//virtual ~Animal()
	//{
	//	cout << "Animal析构函数" << endl;
	//}
	virtual  ~Animal() = 0;
};
Animal::~Animal()
{
	cout << "Animal纯析构函数" << endl;
}


class Cat :public Animal
{
public:
	Cat(string name)
	{
		cout << "猫构造函数" << endl;
		m_Name =new string(name);
	}
	void speak()
	{
		cout <<*m_Name<< "小猫在说话" << endl;
	}
	~Cat()
	{
		if (m_Name != NULL)
		{	
			cout << "猫析构函数被调用" << endl;
			delete m_Name;
			m_Name = NULL;
		}
	}
	
	string *m_Name;

};

void test01() 
{
	Animal *animal = new Cat("Tom");
	animal->speak();
	//父类指针在析构时候，不调用子类的析构，导致内存泄漏
	delete animal;

}

int main() {
	test01();
	system("pause");
	return 0;

};

7. 函数模板

调用规则 ：
  1. 如果函数模板和普通函数都可以实现，优先调用普通函数；
  2. 可以通过空模板参数列表来强制调用函数模板；
  3. 函数模板可以发生重载；
  4. 如果函数模板可以产生更好的类型匹配，有限调用函数模板
隐式类型转换：
  1. 普通函数可以实现；
  2. 函数模板：自动类型推导 不能；显示指定类型 可以发生隐式类型转换；
对于特点的数据类型，用具体化方式特殊实现

利用具体化Person的版本实现代码，具体化优先调用？？？

#include<iostream>
using namespace std;
#include<string>
//函数模板 用于选择排序

template <typename T> //声明模板
void sawp(T& a, T& b)
{
	T temp = a;
	a = b;
	b = temp;
}
template<typename T>
void mySort(T arr[],int len)
{
	for (int i = 0; i < len; i++)
	{
		int max = i;//认定最大值的下标
		for (int j = i + 1; j < len; j++)
		{
			if (arr[max] < arr[j])
			{
				max = j;
			}
		}
		if (max != i)
		{
			//交换max和i元素
			swap(arr[max], arr[i]);
		}
	}
	
}
template<typename T>
void PrintArr(T arr[],int len)
{
	for (int i = 0; i < len; i++)
	{
		cout << arr[i] << ""; 
	}
		cout<< endl;
}
void test01()
{
	//char charArr[] = "fabcv";
	int charArr[] = { 1,2,3,4 };

	int len = sizeof(charArr) / sizeof(int);
	mySort(charArr, len);
	PrintArr(charArr, len);

}
int main() {
	test01();
	system("pause");
	return 0;

};

8. 类模板

  1. 类模板没有自动类型推导的使用方式
  2. 类模板在模板的参数列表中可以有默认参数
  3. 类模板中成员函数不是一开始创建，是在调用的时候才去创建
#include<iostream>
using namespace std;
#include<string>
//类模板

template <class NameType ,class AgeType> //声明模板
	//template <class NameType ,class AgeType=int> //指定默认参数
class Person
{
public:
	Person(NameType name, AgeType age) :m_Name(name), m_Age(age) {};
	void showPerson()
	{
		cout << m_Name << " " << m_Age << endl;
	}

	NameType m_Name;
	AgeType  m_Age;
};

void test01()
{
	Person<string, int> p1("站站" ,999);//类模板没有自动类型推导的使用方式
	p1.showPerson();

}
int main() {
	test01();
	system("pause");
	return 0;
};

8.2. 类模板对象做函数参数

  1. 指定传入类型 (建议使用)
  2. 参数模板化
  3. 整个类模板化
#include<iostream>
using namespace std;
#include<string>
//类模板

template <class NameType ,class AgeType> //声明模板
class Person
{
public:
	Person(NameType name, AgeType age) :m_Name(name), m_Age(age) {};
	void showPerson()
	{
		cout << m_Name << " " << m_Age << endl;
	}

	NameType m_Name;
	AgeType  m_Age;
};

//1.指定传入类型
void PrintPerson1(Person<string, int> &p)
{
	p.showPerson();
}

//2.参数模板化
template <class T1, class T2> 
void PrintPerson2(Person<T1, T2>& p)
{
	p.showPerson();
	cout << "T1的类型是：  " << typeid(T1).name() << endl;
	cout << "T2的类型是：  " << typeid(T2).name << endl;

}
//3.整个类模板化
template <class T> 
void PrintPerson3(T& p)
{
	p.showPerson();
	cout << "T的类型是：  " << typeid(T).name() << endl;

}

void test01()
{
	Person<string , int> p1("站站" ,999);
	//PrintPerson1(p1);
	//PrintPerson2(p1);
	PrintPerson3(p1);
}
int main() {
	test01();
	system("pause");
	return 0;
};

8.3. 类模板继承

  1. 子类继承的父类是一个类模板时，子类在声明的时候，需要指定出父类中T的类型.如果不指定，编译器无法给子类分配内存。
class Son1:pubulic Base<int>
{};
  1. 如果想灵活支出父类中T的类型，子类也需变为类模板
template<class T1,class T2>
class Son2:pubulic Base<T2>
{
	T1 obj;
};

8.4. 类模板成员函数类外实现

需要加上模板参数列表

//构造函数
template<class T1,class T2>
Person<T1,T2>::Person(T1 name,T2 age){}
//成员函数
template<class T1,class T2>
void Person<T1,T2>::showPerson(){}

8.5. 类模板分文件编写

问题：模板总成员函数创建时机实在调用阶段，导致分文件编写时链接不到

解决：将声明和实现写到同一个文件中，并更改后缀为.hpp，hpp是约定的名称，并不是强制

//person.hpp文件中书写
#pragma once
#include<iostream>
using namespace std;
#include<string>

template <class NameType, class AgeType> //声明模板
class Person
{
public:
	Person(NameType name, AgeType age);
	void showPerson();

	NameType m_Name;
	AgeType  m_Age;
};

template<class NameType, class AgeType>
Person<NameType, AgeType>::Person(NameType name, AgeType age)
{
	this->m_Name = name;
	this->m_Age = age;
}

template<class NameType, class AgeType>
void Person<NameType, AgeType>::showPerson()
{
	cout << this->m_Name << " " << this->m_Age << endl;
}

8.6 类模板友元函数的实现

  1. 全局函数配合友元 类内定义
  2. 类外定义：提前声明类模板；声明函数模板；类内用类外实现方式的友元声明（加空模板参数列表）；类外定义；
#include<iostream>
using namespace std;
#include<string>

//2.全局函数配合友元 类外实现 - >1.先做函数模板声明，下方再做函数模板定义，再做友元
template<class T1, class T2>
class Person;

template<class T1, class T2>
 void printPerson2 (Person<T1, T2> & p);


template<class T1, class T2>
class Person
{
	//1.全局函数配合友元  类内实现
	friend void printPerson(Person<T1, T2>& p)
	{
		cout << "姓名：" << p.m_Name << "\n年龄  " << p.m_Age << endl;
	}

	//2.全局函数配合友元  类外实现 ->2.内类友元声明,加空模板的参数列表
	friend void printPerson2<>(Person<T1, T2>& p);

public:
	Person(T1 name, T2 age)
	{
		this->m_Name = name;
		this->m_Age = age;
	}

private:
	T1 m_Name;
	T2 m_Age;
};
//2.全局函数配合友元  类外实现 3.类外定义
template<class T1, class T2>
void printPerson2(Person<T1, T2>& p)
{
	cout << "姓名：" << p.m_Name << "\n年龄  " << p.m_Age << endl;
}


void test01()
{
	Person<string , int> p1("站站" ,999);
	printPerson(p1);
	printPerson2(p1);

}
int main() {
	test01();
	system("pause");
	return 0;
};
白火良V
关注
C++期末复习题
03-05
模板是C++的泛型编程工具，可以创建不依赖特定数据类型的函数和类。异常处理用于处理运行时错误，通过try、catch和throw关键字，你可以优雅地捕获和处理程序中的异常情况。STL提供了容器（如vector、list、set）、...
java 多态 泛型_Java基础之多态和泛型浅析
weixin_27006759的博客
02-13 672
Java基础之多态和泛型浅析一、前言：楼主看了许多资料后，算是对多态和泛型有了一些浅显的理解，这里做一简单总结二、什么是多态？多态(Polymorphism)按字面的意思就是“多种状态”。在面向对象语言中，接口(这里所谓的接口是楼主自己发明的，这里不是局限于Java的interface，可以把它看作为广义定义的对象源)的多种不同的实现方式即为多态。引用Charlie Calverts对多态的描述—...
多态与泛型
Jintao_Ma的博客
04-01 3720
1.多态的理解和使用： 多态自我理解就是同种调用的不同结果表现 1) 方法的多态性：包括重载和重写(其实重写就是为了下面类之间继承的多态) 2)类之间继承的多态 重载和重写已经在之前的文章中学习过了，下面是类的多态： class animal{ public void eat(){ System.out.println("animal.eat()"); } } class cat
泛型与多态瞎想
Zhongxiucheng的专栏
09-18 3078
"抽象"即是一种"限定",将一类事物从万事万物剥离出来.比如人,是对我们自身的抽象,是对我们自身的定义与限定 1.泛型:     先说说泛型,我认为无论类泛型还是方法泛型,都是对java类型及其行为的一种"抽象",或者说是"限定".具体的"限定"主要     体现在泛型的类的定义中.比如在java中集合是比较典型的泛型代表,其中又以ArrayList为代表,那么在ArrayList
多态 & java泛型
qq_33934427的博客
12-10 1240
多态 & java泛型 文章目录多态 & java泛型1、回顾java的多态性1）什么是多态（“多”对1 + 不同“态” => 统一与差异）2）接口和抽象类的比较（同: 抽象方法、继承，异: 多态实现）2、泛型的本质 & 作用1）泛型的本质 - 类型参数化2）泛型的作用3、泛型的使用1）jdk中常见的泛型2）自定义泛型方法（利用反射调用共有方法） 1、回顾java的多态性 参考 Java中的多态有哪些具体表现形式 Java接口与多态 1）什么是多态（“多”对1 + 不同“态
泛型和多态：探索面向对象编程的根源
最新发布
AI天才研究院
12-26 576
1.背景介绍 面向对象编程(Object-Oriented Programming, OOP)是一种编程范式，它将计算机程序的实体(entity)表示为“对象”(object)。这种编程范式的核心概念有类(class)、对象、方法(method)、属性(attribute)、继承(inheritance)、多态(polymorphism)和封装(encapsulation)。在这篇文章中，我们将...
java期末复习 (1)
12-18
根据给定的信息，我们可以从...面向对象语言至少应具备封装、继承和多态这三个特性。 #### Switch语句 9. **输出结果**：这段代码会输出`Error,`。因为`score`的值为1，没有匹配到任何`case`，因此执行`default`分支。
c++概念复习总结
07-09
总结而言，C++概念复习总结涉及到的范围很广，不仅包括语言基础，如数据类型、表达式、控制结构和函数，还包括了面向对象编程的核心要素如类、对象、继承、多态等。学习C++不仅需要掌握语法，更要理解面向对象编程的...
java考试复习
11-18
- 掌握泛型的概念，如何使用泛型来提高代码的类型安全性。 7. **文件与IO流**： - 文件操作，包括读写文件、文件的创建、删除和重命名。 - 输入/输出流的概念，如字节流和字符流，以及缓冲流、对象序列化和反...
C++快速复习笔记.rar
05-07
C++中的模板允许我们编写泛型代码，可以用于处理不同数据类型。有函数模板和类模板两种，它们能提高代码的灵活性和可复用性。 四、STL（标准模板库） STL是C++的重要组成部分，提供了容器（如vector、list、set、...
java 多态的泛型实现
10-30
RTRTRTRTRT 多态的泛型实现 急需积分...
对泛型和多态的粗浅理解
qq_34324677的博客
02-18 2468
泛型和多态，Java面向对象的两个重要概念，下面以一个现实中的简单例子描述一下这两个概念： 在舞台上，魔术师在变魔术时，有几个箱子，每个箱子里面放一个动物， 1.刚开始，魔术师处于入门阶段，箱子里面只能放狗，然后魔术师将其变没。现在魔术师就处于面向对象的初级阶段，魔术师只能创建一个对象Dog，这个类有一个方法disappear()，当魔术师调用Dog对象的这个方法时，箱子里的狗变瞬
Java多态与泛型
zyd196504的博客
09-27 868
一、多态理解 1、判断是否是同一个函数，通过唯一性标识（方法名+参数（顺序、数量、类型一致）） 2、重载：参数 与 父类 不同 重写（覆盖）：方法名+参数 与 父类 相同 3、多态分为编译时多态（重载）和运行时多态（重写、覆盖）。因为重载是不同的方法，编译器能编译的时候就确定是否调用该方法；而对于重写，只有在创建出由父类引用指向子类实例时候，才会知道调用的是哪个方法。 4、多态只是针对方法的多态，...
Java泛型遇到多态与Java泛型边界
yx19861211的博客
04-20 1684
说明: 今天,继续学姐java编程思想-泛型这一章的时候,对于通配符的理解不够明白,于是又网上查了些资料,发现一篇写的很好的文章,在此记录学习一下
Java多态遇到泛型类型
chenkaibsw的专栏
12-05 662
1.数组参数的多态化 class Animal { void eat() { System.out.println("animal is sleeping"); } } class Dog extends Animal { void bark() { System.out.println("dog is barking"); } } class Cat extends A
泛型结合多态
gongst的专栏
01-31 1169
http://www.cnblogs.com/zhengzengyuan/archive/2009/12/18/1626746.html 一个关于泛型结合多态设计方面的文章。 先看段代码： class IMaterialCoeff { public: virtual void ReadCoeff()=0; }; class DenModelCoeff : public IMateri
C++复习关键点：泛型、内存管理与多态
"C++编程语言复习笔记" 这篇复习记录涵盖了C++编程中的多个核心概念，主要包括函数原型、内存管理、初始化、内联函数、构造函数、常量成员函数、多态性、虚函数机制、友元、抽象类与纯虚函数、继承权限以及模板的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值