(学习总结18)C++多态

news2024/9/21 18:21:39

C++多态

  • 一、多态的概念
  • 二、多态的定义及实现
    • 多态的构成条件
      • 1. 实现多态的两个必须条件：
      • 2. 虚函数
      • 3. 虚函数的重写/覆盖
      • 4. 多态场景的一个选择题
      • 5. 虚函数重写的一些其他问题
        • 协变
        • 析构函数的重写
      • 6. override 和 final 关键字
      • 7. 重载/重写/隐藏的对比
  • 三、纯虚函数和抽象类
  • 四、多态的原理
    • 虚函数表指针
    • 多态的原理
      • 1. 多态是如何实现的
        • ①
        • ②
        • ③
        • ④
      • 2. 动态绑定与静态绑定的确切定义
      • 3. 虚函数表

以下代码环境为 VS2022 C++。

一、多态的概念

多态(polymorphism)的概念：通俗来说，就是多种形态。多态分为编译时多态(静态多态)和运行时多态(动态多态)，这里重点讲运行时多态。

编译时多态(静态多态)主要是函数重载和函数模板，其传不同类型的参数就可以调用不同的函数，通过参数不同达到多种形态，之所以叫编译时多态，是因为实参传给形参的参数匹配是在编译时完成的。

运行时多态(动态多态)，具体点是去完成某个行为(函数)，可以传不同的对象去完成不同的行为，来达到多种形态。比如买票这个行为，当普通人买票时，是全价买票；学生买票时，是优惠买票(5 折或 7.5 折)；军人买票时是优先买票。再比如，同样是动物叫的一个行为(函数)，传猫对象过去，就是” 喵 “，传狗对象过去，就是" 汪 "。因为只能在运行时去分辨不同的对象，所以称为运行时多态。

二、多态的定义及实现

多态的构成条件

多态是一个继承关系下的类对象，去调用同一函数，产生了不同的行为。比如 Student 继承了 Person。Person 对象买票全价，Student 对象优惠买票。

1. 实现多态的两个必须条件：

  1. 必须指针或者引用调用虚函数。

  2. 被调用的函数必须是虚函数。

说明：要实现多态效果，第一必须是基类的指针或引用，因为只有基类的指针或引用才能安全指向派生类对象；第二派生类必须对基类的虚函数重写 / 覆盖，重写或者覆盖了，派生类才能有不同的函数，多态的不同形态效果才能达到。

2. 虚函数

类成员函数前面加 virtual 修饰，那么这个成员函数被称为虚函数。注意非成员函数不能加 virtual 修饰。

class Person
{
public:

	virtual void BuyTicket() 
	{ 
		cout << "买票 - 全价" << endl; 
	}
};

3. 虚函数的重写/覆盖

虚函数的重写 / 覆盖：派生类中有一个跟基类完全相同的虚函数(即派生类虚函数与基类虚函数的返回值、类型、函数名字、参数列表完全相同)，称派生类的虚函数重写了基类的虚函数。

注意：在重写基类虚函数时，派生类的虚函数在不加 virtual 关键字时，虽然也可以构成重写(因为继承后基类的虚函数被继承下来在派生类依旧保持虚函数属性)，但是该种写法不是很规范，不建议这样使用，但在笔试考试选择题中，经常会故意埋这个坑，判断是否构成多态。

#include <iostream>
using namespace std;

class Person 
{
public:

	virtual void BuyTicket() 
	{ 
		cout << "买票 - 全价" << endl; 
	}
};

class Student : public Person 
{
public:

	virtual void BuyTicket() 
	{ 
		cout << "买票 - 打折" << endl; 
	}
};

void Func(Person* ptr)
{
	// 这⾥可以看到虽然都是 Person 指针 Ptr 在调⽤ BuyTicket
	// 但是跟 ptr 没关系，⽽是由 ptr 指向的对象决定的。
	ptr->BuyTicket();
}

int main()
{
	Person ps;
	Student st;
	Func(&ps);
	Func(&st);

	return 0;
}

#include <iostream>
using namespace std;

class Animal
{
public:

	virtual void talk() const
	{
		;
	}
};

class Dog : public Animal
{
public:

	virtual void talk() const
	{
		cout << "汪" << endl;
	}
};

class Cat : public Animal
{
public:

	virtual void talk() const
	{
		cout << "喵" << endl;
	}
};

void letsHear(const Animal& animal)
{
	animal.talk();
}

int main()
{
	Cat cat;
	Dog dog;
	letsHear(cat);
	letsHear(dog);

	return 0;
}

4. 多态场景的一个选择题

以下程序输出结果为：B->1

在#include <iostream>
using namespace std;

class A
{
public:

	virtual void func(int val = 1) 
	{ 
		cout << "A->" << val << endl; 
	}

	virtual void test() 
	{ 
		func(); 
	}
};

class B : public A
{
public:

	void func(int val = 0) 
	{ 
		cout << "B->" << val << endl; 
	}
};

int main(int argc, char* argv[])
{
	// 调用 A 的 test，传的是 A 的 this 指针，
	// 调用 A 的 func 函数(包含 A 函数中的缺省值)，
	// 但对象是 B，执行 B 的 func 函数内容
	B* p = new B;
	p->test();

	return 0;
}

5. 虚函数重写的一些其他问题

协变

派生类重写基类虚函数时，与基类虚函数返回值类型不同。即基类虚函数返回基类对象的指针或者引用，派生类虚函数返回派生类对象的指针或者引用时，称为协变。

#include <iostream>
using namespace std;

class Person 
{
public:
	// 返回基类对象的指针
	virtual Person* BuyTicket()
	{
		cout << "买票 - 全价" << endl;
		return this;
	}
};

class Student : public Person 
{
public:
	//	返回派生类对象的指针
	virtual Student* BuyTicket()
	{
		cout << "买票 - 打折" << endl;
		return this;
	}
};

void Func(Person* ptr)
{
	ptr->BuyTicket();
}

int main()
{
	Person ps;
	Student st;
	Func(&ps);
	Func(&st);

	return 0;
}
析构函数的重写

基类的析构函数为虚函数，此时派生类析构函数只要定义，无论是否加 virtual 关键字，都与基类的析构函数构成重写，虽然基类与派生类析构函数名字不同看起来不符合重写的规则，实际上编译器对析构函数的名称做了特殊处理，编译后析构函数的名称统一处理成 destructor()，所以基类的析构函数加了 virtual 修饰，派生类的析构函数就构成重写。

下面的代码可以看到，如果 ~A()，不加 virtual，那么 delete p2 时只调用的 A 的析构函数，没有调用 B 的析构函数，就会导致内存泄漏问题，因为 ~B() 中在释放资源。

注意：这个问题面试中经常考察，下面的样例展示了为什么基类中的析构函数建议设计为虚函数。

#include <iostream>
using namespace std;

class A
{
public:

	virtual ~A()
	{
		cout << "~A()" << endl;
	}
};

class B : public A 
{
public:

	virtual ~B()
	{
		cout << "~B()->delete:" << _p << endl;
		delete _p;
	}
protected:

	int* _p = new int[10];
};

// 只有派⽣类 Student 的析构函数重写了 Person 的析构函数，
// 下⾯的 delete 对象调⽤析构函数，才能构成多态，
// 这样才能保证 p1 和 p2 指向的对象正确的调⽤析构函数。
int main()
{
	A* p1 = new A;
	A* p2 = new B;
	delete p1;
	delete p2;

	return 0;
}

6. override 和 final 关键字

从上面可以看出，C++ 对函数重写的要求比较严格，但是有些情况下由于疏忽，比如函数名写错参数写错等导致无法构成重载，而这种错误在编译期间是不会报出的，只有在程序运行时没有得到预期结果才来 debug 会得不偿失，因此 C++11 提供了 override，可以帮助用户检测派生类的虚函数是否构成重写。如果不想让派生类重写基类的这个虚函数，那么可以用 final 去修饰基类的虚函数。

#include <iostream>
using namespace std;

class Car 
{
public:

	virtual void Dirve()
	{
		;
	}
};

class Benz :public Car 
{
public:

	virtual void Drive() override // 不能重写基类虚函数就报错
	{ 
		cout << "Benz - 舒适" << endl; 
	}
};

int main()
{

	return 0;
}

#include <iostream>
using namespace std;

class Car
{
public:

	virtual void Drive() final		// 在基类虚函数后加 final 就不能重写它
	{
		;
	}
};

class Benz :public Car
{
public:

	virtual void Drive() 
	{ 
		cout << "Benz - 舒适" << endl; 
	}
};

int main()
{

	return 0;
}

7. 重载/重写/隐藏的对比

在这里插入图片描述

三、纯虚函数和抽象类

在虚函数的后面写上 = 0 ，则这个函数为纯虚函数，纯虚函数不需要定义实现(实现没啥意义因为要被派生类重写，但是语法上可以实现)，只要声明即可。包含纯虚函数的类叫做抽象类，抽象类不能实例化出对象，如果派生类继承后不重写纯虚函数，那么派生类也是抽象类。纯虚函数某种程度上强制了派生类重写虚函数，因为不重写就不能实例化对象。

#include <iostream>
using namespace std;

class Car
{
public:

	virtual void Drive() = 0;
};

class Benz : public Car
{
public:

	virtual void Drive() override
	{
		cout << "Benz - 舒适" << endl;
	}
};

class BMW : public Car
{
public:

	virtual void Drive() override
	{
		cout << "BMW - 操控" << endl;
	}
};

int main()
{
	// 编译报错，⽆法实例化抽象类
	// Car car;

	Car* pBenz = new Benz;
	pBenz->Drive();
	delete pBenz;

	Car* pBMW = new BMW;
	pBMW->Drive();
	delete pBMW;

	return 0;
}

四、多态的原理

虚函数表指针

下面编译的 32 位下程序的运行结果是 12 ：

#include <iostream>
using namespace std;

class Base
{
public:

	virtual void Func1()
	{
		cout << "Func1()" << endl;
	}

protected:

	int _b = 1;
	char _ch = 'x';
};

int main()
{
	Base b;
	cout << sizeof(b) << endl;

	return 0;
}

除了 _b 和 _ch 成员，还多一个 __vfptr 放在对象的前面(注意有些平台可能会放到对象的最后面，这个跟平台有关)，对象中的这个指针叫做虚函数表指针( v 代表 virtual，f 代表 function， ptr 代表 pointer)，也就是 函数 2 级指针。一个含有虚函数的类中都至少都有一个虚函数表指针，用来整合这个类里面所有虚函数的地址。虚函数表也简称虚表。

多态的原理

1. 多态是如何实现的

从底层的角度 Func 函数中 ptr->BuyTicket()，是如何调用的呢？通过下面测试可以看到，满足多态条件后，底层不再是编译时通过调用对象确定函数的地址，而是运行时到指向的对象的虚表中确定对应的虚函数的地址，这样实现了指针或引用指向基类就调用基类的虚函数，指向派生类就调用派生类对应的虚函数。

#include <iostream>
using namespace std;

class Person 
{
public:

	virtual void BuyTicket() 
	{ 
		cout << "买票 - 全价" << endl; 
	}
};

class Student : public Person 
{
public:

	virtual void BuyTicket() 
	{ 
		cout << "买票 - 打折" << endl; 
	}

private:

	int _id;
};

class Soldier : public Person 
{
public:

	virtual void BuyTicket() 
	{ 
		cout << "买票 - 优先" << endl; 
	}

private:

	string _codename;
};

class Test : public Person
{
	;
};

void Func(Person* ptr)
{
	ptr->BuyTicket();
}

int main()
{
	// 多态不仅发⽣在一个派⽣类对象，
	// 多个派⽣类继承基类，重写虚函数后
	// 多态也会发⽣在多个派⽣类之间。
	Person psr;
	Test tes;
	Student stu;
	Soldier sol;

	Func(&psr);
	Func(&tes);
	Func(&stu);
	Func(&sol);

	return 0;
}

Test、Student、Soldier 分别继承 Person。Test 没有自己实现 BuyTicket 函数，Student 和 Soldier 实现了各自的 BuyTicket 。则调用 ptr->BuyTicket() 时，Test 和 Person 执行的是 Person::BuyTicket() 函数，Student 执行的是 Student::BuyTicket()，Soldier 执行的是 Soldier::BuyTicket()。
在这里插入图片描述
在 VS2022 调试中可以清楚看到这一过程：

①

在这里插入图片描述
psr 类型为 Person，虚表中存储的第一个元素就是 Person::BuyTicket 函数的地址。

②

在这里插入图片描述
tes 类型为 Test，但自己没有重写 BuyTicket 函数，它的虚表中存储的第一个元素是 Person::BuyTicket 函数的地址。

③

在这里插入图片描述
stu 类型为 Student，自己重写了 BuyTicket 函数，它的虚表中存储的第一个元素是 Student::BuyTicket 函数的地址。

④

在这里插入图片描述
sol 类型为 Soldier，自己重写了 BuyTicket 函数，它的虚表中存储的第一个元素是 Soldier::BuyTicket 函数的地址。

最后执行 ptr->BuyTicket() 函数时，调用的是对象的成员虚表中对应的虚函数，则运行结果显然为：
在这里插入图片描述

2. 动态绑定与静态绑定的确切定义

对不满足多态条件(指针或者引用 + 调用虚函数)的函数调用是在编译时绑定，也就是编译时确定调用函数的地址，叫做静态绑定。

满足多态条件的函数调用是在运行时绑定，也就是在运行时到指向对象的虚函数表中找到调用函数的地址，也就叫做动态绑定。

3. 虚函数表

基类对象的虚函数表中存放基类所有虚函数的地址。

派生类由两部分构成，继承下来的基类和自己的成员，一般情况下，继承下来的基类中有虚函数表指针，自己就不会再生成虚函数表指针。但是要注意派生类继承下来的基类部分虚函数表指针和基类对象的虚函数表指针不是同一个，就像基类对象的成员和派生类对象中的基类对象成员也是独立的。

派生类中重写的基类的虚函数，派生类的虚函数表中对应的虚函数就会被覆盖成派生类重写的虚函数地址。

派生类的虚函数表中包含：

  1. 基类的虚函数地址；

  2. 派生类重写基类虚函数的函数地址；

  3. 派生类自己的虚函数地址。

虚函数表本质是一个存储虚函数指针的指针数组（但是 VS2022 实现时是用 void** 强转而成），一般情况这个数组最后面放了一个 0x00000000(这是32位的地址长度) 标记。(这个 C++ 并没有进行规定，各个编译器自行定义的，VS2022 会在大部分情况后面放个 0x00000000 标记)
在这里插入图片描述
虚函数存放在哪的？虚函数和普通函数一样的，编译好后是一段指令，都是存在代码段的，只是虚函数的地址又存到了虚表中。

虚函数表存放在哪的？这个问题严格说并没有标准答案， C++ 标准并没有规定，我们在不同环境运行下面的代码可以对比验证一下。

#include <iostream>
using namespace std;

class Base 
{
public:

	virtual void func1() 
	{ 
		cout << "Base::func1" << endl; 
	}

	virtual void func2() 
	{ 
		cout << "Base::func2" << endl; 
	}

	void func5() 
	{ 
		cout << "Base::func5" << endl; 
	}

protected:

	int _a = 1;
};

class Derive : public Base
{
public:

	// 重写基类的func1
	virtual void func1() override
	{ 
		cout << "Derive::func1" << endl; 
	}

	virtual void func2() override
	{ 
		cout << "Derive::func1" << endl; 
	}

	void func4() 
	{ 
		cout << "Derive::func4" << endl; 
	}

protected:

	int _b = 2;
};

void test1()
{
	int i = 0;
	static int j = 1;
	int* p1 = new int;
	const char* p2 = "xxxxxxxx";

	Base b;
	Derive d;
	Base* p3 = &b;
	Derive* p4 = &d;

	printf("栈：                 %p\n", &i);
	printf("静态区：             %p\n", &j);
	printf("堆：                 %p\n", p1);
	printf("常量区：             %p\n", p2);
	printf("Person 虚表地址：    %p\n", *(unsigned long long*)p3);
	printf("Student 虚表地址：   %p\n", *(unsigned long long*)p4);
	printf("虚函数地址：         %p\n", &Base::func1);
	printf("普通函数地址：       %p\n", &Base::func5);
}

int main()
{
	test1();

	return 0;
}

在 VS2022 下是存储在代码段(常量区)
在这里插入图片描述
在 Dev C++ 5.9.2 中似乎是存储在常量区
在这里插入图片描述

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/2152997.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

【堆栈操作基本规则】假设SS的初值为2000H,SP初值为0200H,在执行了5次入栈操作和2次出栈操作后SP的内容为多少?写出计算过程。

【堆栈操作基本规则】假设SS的初值为2000H,SP初值为0200H,在执行了5次入栈操作和2次出栈操作后SP的内容为多少?写出计算过程。

欢迎来到我的技术博客&#xff01; &#x1f389; 这里不仅有满满的编程干货和学习资源&#xff0c;我的某站账号也为你准备了更多实用的技术视频和知识分享。 &#x1f449; 点击关注我的小破站账号&#xff0c;获取更多编程技巧和学习资源&#xff01; 小破站主页 我们来逐…
阅读更多...
新手入门：小程序架构快速上手

新手入门：小程序架构快速上手

目录 新建项目和配置 项目基本结构 新建小程序页面 修改项目首页 全局配置 窗口 tabBar 页面配置 小程序基本语法 wxml 数据绑定 条件渲染 列表渲染 wxss wxss 对比 css rpx import 全局样式和局部样式 js wxs 数据请求 get和post请求 小程序和跨域 小程…
阅读更多...
C++进阶 set和map讲解

C++进阶 set和map讲解

set 和 map set 和 multiset set set 类的介绍 set 是基于红黑树实现的有序容器。它的插入、删除、查找操作的时间复杂度均为 O(log n)。遍历时&#xff0c;set 的迭代器按照中序遍历&#xff0c;因此它总是以升序排列元素。 set 的声明如下&#xff0c;T 表示 set 的关键字类…
阅读更多...
The First项目报告:变革全链身份，Layer3的未来价值解读

The First项目报告:变革全链身份，Layer3的未来价值解读

2024年7月5日&#xff0c;代币分发协议 Layer3 基金会公布代币 L3 经济模型&#xff0c;以任务平台为市场切入点的 Layer3 聚合了市场上花样繁多的项目&#xff0c;帮助用户实现通过一个平台交互全链项目的操作。乘着牛市的浪潮&#xff0c;各链生态重新火热&#xff0c;Layer3…
阅读更多...
微服务_入门1

微服务_入门1

文章目录 一、 认识微服务二、 微服务演变2.1、 单体架构2.2、 分布式架构2.3、 微服务2.4、 微服务方案对比 三、 注册中心3.1、 Eureka3.2、 Nacos3.2.1、服务分级存储模型3.2.2、权重配置3.2.3、环境隔离 一、 认识微服务 二、 微服务演变 随着互联网行业的发展&#xff0c;…
阅读更多...
Java项目实战II基于Java+Spring Boot+MySQL的洗衣店订单管理系统（开发文档+源码+数据库）

Java项目实战II基于Java+Spring Boot+MySQL的洗衣店订单管理系统（开发文档+源码+数据库）

目录 一、前言 二、技术介绍 三、系统实现 四、论文参考 五、核心代码 六、源码获取 全栈码农以及毕业设计实战开发&#xff0c;CSDN平台Java领域新星创作者 一、前言 随着生活节奏的加快&#xff0c;现代人对便捷、高效服务的需求日益增长&#xff0c;洗衣店作为日常生…
阅读更多...
[Linux] Linux操作系统 进程的状态

[Linux] Linux操作系统 进程的状态

标题&#xff1a;[Linux] Linux操作系统 进程的状态 个人主页&#xff1a;水墨不写bug &#xff08;图片来源于网络&#xff09; 目录 一、前置概念的理解 1.并行和并发 2.时间片 3.进程间具有独立性 4.等待的本质 正文开始&#xff1a; 在校的时候&#xff0c;你一定学过《…
阅读更多...
【自然语言处理】补充：词项权重计算及向量空间模型

【自然语言处理】补充：词项权重计算及向量空间模型

【自然语言处理】补充：词项权重计算及向量空间模型 文章目录 【自然语言处理】补充：词项权重计算及向量空间模型1. 排序式检索2. 词项频率3. tf-idf权重计算4. 向量空间模型1. 排序式检索 布尔检索的不足：结果过少或者过多 布尔查询常常会是过少（=0）或者过多（>1000）在…
阅读更多...
Python “函数” ——Python面试100道实战题目练习，巩固知识、检查技术、成功就业

Python “函数” ——Python面试100道实战题目练习，巩固知识、检查技术、成功就业

本文主要是作为Python中函数的一些题目&#xff0c;方便学习完Python的函数之后进行一些知识检验&#xff0c;感兴趣的小伙伴可以试一试&#xff0c;含选择题、判断题、实战题、填空题&#xff0c;答案在第五章。 在做题之前可以先学习或者温习一下Python的函数&#xff0c;推荐…
阅读更多...
[Python数据可视化]探讨数据可视化的实际应用：三个案例分析

[Python数据可视化]探讨数据可视化的实际应用：三个案例分析

数据可视化是理解复杂数据集的重要工具&#xff0c;通过图形化的方法&#xff0c;可以直观地展示信息、趋势和模式。本文将深入探讨三个实际案例&#xff0c;包括健康数据分析、销售趋势分析、城市交通流量分析。每个案例将提供假设数据、详细注释的代码及分析结果。 案例 1: …
阅读更多...
【PyTorch】Tensor（张量）介绍

【PyTorch】Tensor（张量）介绍

Tensor 的概念 Tensor 中文为张量。张量的意思是一个多维数组&#xff0c;它是标量、向量、矩阵的高维扩展。 标量可以称为 0 维张量&#xff0c;向量可以称为 1 维张量&#xff0c;矩阵可以称为 2 维张量&#xff0c;RGB 图像可以表示 3 维张量。你可以把张量看作多维数组。 …
阅读更多...
Redis作为单线程模型，为什么效率高、速度快呢？

Redis作为单线程模型，为什么效率高、速度快呢？

前言&#xff1a; 效率高、速度快是相较于数据库来说的&#xff08;MySQL、Orcale、SQL server&#xff09; 文章目录 一、单线程模式的工作流程二、为什么快&#xff1f; 一、单线程模式的工作流程 这里我们所说的单线程是指&#xff1a;Redis只使用一个线程&#xff0c;来处…
阅读更多...
PPP的配置

PPP的配置

概述&#xff1a;PPP模式&#xff0c;即公私合作模式&#xff08;Public-Private Partnership&#xff09;&#xff0c;是一种公共部门与私营部门合作的模式。 一、实验拓扑 实验一&#xff1a;PPP基本功能 实验步骤&#xff1a; &#xff08;1&#xff09;配置AR1的接口IP地…
阅读更多...
xilinx hbm ip运用

xilinx hbm ip运用

AXI-HBM是一个集成的IP核&#xff0c;该核提供高达16个AXI3从PORT的HBM接口&#xff0c;每个使用他自己的独立的时钟。HBM2 GEN存储器也支持&#xff0c;HBM相对传统DDR的方案&#xff0c;带宽得到极大的提高 特征 AXI3从端口存储器接口 -16个独立的256bit存储器接口 -可选的…
阅读更多...
国标视频流媒体服务GB28181和Ehome等多协议接入的Liveweb方案详解

国标视频流媒体服务GB28181和Ehome等多协议接入的Liveweb方案详解

Liveweb视频融合/汇聚云平台基于“云-边-端”一体化架构&#xff0c;部署轻量简单、功能灵活多样&#xff0c;平台可支持多协议&#xff08;GB28181/RTSP/Onvif/海康SDK/Ehome/大华SDK/RTMP推流等&#xff09;、多类型设备接入(IPC/NVR/监控平台)&#xff0c;在视频能力上&…
阅读更多...
企业文档管理系统哪个好？2024年热门的10款文档管理系统软件推荐

企业文档管理系统哪个好？2024年热门的10款文档管理系统软件推荐

在信息化时代&#xff0c;企业每天都会生成海量的文档、数据和资料。 如何有效管理这些文档&#xff0c;确保信息安全、版本控制和协同办公顺畅&#xff0c;是每个企业都必须面对的挑战。 2024年&#xff0c;随着技术的不断进步&#xff0c;市场上涌现出了众多优秀的文档管理…
阅读更多...
STM32如何修改外部晶振频率和主频

STM32如何修改外部晶振频率和主频

对于STM32F10x系列的单片机&#xff0c;除了STM32F10x_CL单片机&#xff0c;其它的单片机一般外部晶振HSE的时钟频率都默认是8MHz。如果我们使用的外部晶振为12Mhz&#xff0c;那么可以把上图绿色标记改为:12000000 72MHz的主频8MHz的外部晶振HSE*倍频系数9。当然如果像上面把外…
阅读更多...
ChatGPT 在国内使用的方法

ChatGPT 在国内使用的方法

AI如今很强大&#xff0c;聊聊天、写论文、搞翻译、写代码、写文案、审合同等等&#xff0c;ChatGPT 真是无所不能~ 作为一款出色的大语言模型&#xff0c;ChatGPT 实现了人类般的对话交流&#xff0c;最主要是能根据上下文进行互动。 接下来&#xff0c;我将介绍 ChatGPT 在国…
阅读更多...
Android-UI设计

Android-UI设计

控件 控件是用户与应用交互的元素。常见的控件包括&#xff1a; 按钮 (Button)&#xff1a;用于执行动作。文本框 (EditText)&#xff1a;让用户输入文本。复选框 (CheckBox)&#xff1a;允许用户选择或取消选择某个选项。单选按钮 (RadioButton)&#xff1a;用于在多个选项中…
阅读更多...
『功能项目』QFrameWorkBug关联Slot(插槽)【67】

『功能项目』QFrameWorkBug关联Slot(插槽)【67】

我们打开上一篇66QFrameWorkBug拖拽功能的项目&#xff0c; 本章要做的事情是关联插槽Slot 修改脚本&#xff1a;UISlot.cs 修改脚本&#xff1a;UGUICanvas.cs 此时关联Slot已经完成 接下来的文章内容&#xff1a; 1.QFrameWork扔到地上UGUI 2.位置存储功能 3.点击名称寻…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023