MySQL | 数据库的六种约束、表的关系、三大范式

文章目录

  • 数据库约束
    • NOT NULL（非空约束）
    • UNIQUE（唯一约束）
    • DEFAULT（缺省约束）
    • PRIMARY KEY（主键约束）
    • AUTO_INCREMENT 自增
    • FOREIGN KEY（外键约束）
    • CHECK（检查约束）
  • 表的设计
    • 表的关系
      • 一对一
      • 一对多
      • 多对多
    • 三大范式
      • 第一范式
      • 第二范式
      • 第三范式

数据库约束

数据库中主要有六种约束：

  • NOT NULL（非空约束） - 指示某列不能存储 NULL 值。
  • UNIQUE（唯一约束） - 保证某列的每行必须有唯一的值。
  • DEFAULT（缺省约束） - 规定没有给列赋值时的默认值。
  • PRIMARY KEY（主键约束） - NOT NULL 和 UNIQUE 的结合。确保某列（或两个列多个列的结合）有唯一标识，有助于更容易更快速地找到表中的一个特定的记录。
  • FOREIGN KEY（外键约束） - 保证一个表中的数据匹配另一个表中的值的参照完整性。
  • CHECK（检查约束） - 保证列中的值符合指定的条件。对于 MySQL 数据库，对 CHECK 子句进行分析，但是忽略 CHECK 子句。

NOT NULL（非空约束）

指示某列不能存储 NULL 值。

mysql> create table book(-> id int,-> name varchar(12),-> price double,-> publish date,-> num int NOT NULL-> );
Query OK, 0 rows affected (0.02 sec)// 可以看到 num 的 NULL 属性已经变为 NO（不允许）
mysql> DESC book;
+---------+-------------+------+-----+---------+-------+
| Field   | Type        | Null | Key | Default | Extra |
+---------+-------------+------+-----+---------+-------+
| id      | int         | YES  |     | NULL    |       |
| name    | varchar(12) | YES  |     | NULL    |       |
| price   | double      | YES  |     | NULL    |       |
| publish | date        | YES  |     | NULL    |       |
| num     | int         | NO   |     | NULL    |       |
+---------+-------------+------+-----+---------+-------+
5 rows in set (0.00 sec)// 尝试一下插入一个 num 为 NULL 的数据
mysql> INSERT INTO book VALUES(2, "C++", 13.6, "2000-08-02", NULL);
ERROR 1048 (23000): Column 'num' cannot be null// 可以发现会报错： num 列不可以为 NULL

UNIQUE（唯一约束）

保证某列的每行必须有唯一的值，即对于添加了唯一约束的数据项不能有重复。

mysql> create table book(-> id int UNIQUE,-> name varchar(12),-> price double,-> publish date,-> num int-> );
Query OK, 0 rows affected (0.03 sec)// 可以看到 id 的 key 属性已经被标记为 UNI
mysql> desc book;
+---------+-------------+------+-----+---------+-------+
| Field   | Type        | Null | Key | Default | Extra |
+---------+-------------+------+-----+---------+-------+
| id      | int         | YES  | UNI | NULL    |       |
| name    | varchar(12) | YES  |     | NULL    |       |
| price   | double      | YES  |     | NULL    |       |
| publish | date        | YES  |     | NULL    |       |
| num     | int         | YES  |     | NULL    |       |
+---------+-------------+------+-----+---------+-------+
5 rows in set (0.00 sec)mysql> INSERT INTO book VALUES(1, "C++", 13.5, NULL, 10);
Query OK, 1 row affected (0.00 sec)mysql> INSERT INTO book VALUES(1, "JAVA", 3.5, "2000-08-02", 5);
ERROR 1062 (23000): Duplicate entry '1' for key 'book.id'
// 虽然第二条数据除了 id，其他列的值都不同于第一条数据，然而还是会报错：重复输入“1”作为“book.id”的值

DEFAULT（缺省约束）

规定没有给列赋值时的默认值。

mysql> create table book(-> id int,-> name varchar(12),-> price double,-> publish date DEFAULT "2000-08-02",-> num int-> );
Query OK, 0 rows affected (0.02 sec)// 可以看到 publish 的 Default 属性被设置为 2000-08-02
mysql> desc book;
+---------+-------------+------+-----+------------+-------+
| Field   | Type        | Null | Key | Default    | Extra |
+---------+-------------+------+-----+------------+-------+
| id      | int         | YES  |     | NULL       |       |
| name    | varchar(12) | YES  |     | NULL       |       |
| price   | double      | YES  |     | NULL       |       |
| publish | date        | YES  |     | 2000-08-02 |       |
| num     | int         | YES  |     | NULL       |       |
+---------+-------------+------+-----+------------+-------+
5 rows in set (0.01 sec)// 指定列插入，不包含 publish 列
mysql> INSERT INTO book(id, name, price, num) VALUES(3, "C++", 13.5, 15);
Query OK, 1 row affected (0.00 sec)mysql> SELECT * FROM book;
+------+------+-------+------------+------+
| id   | name | price | publish    | num  |
+------+------+-------+------------+------+
|    3 | C++  |  13.5 | 2000-08-02 |   15 |
+------+------+-------+------------+------+
1 rows in set (0.00 sec)

PRIMARY KEY（主键约束）

NOT NULL 和 UNIQUE 的结合。确保某列（或两个列多个列的结合）有唯一标识，有助于更容易更快速地找到表中的一个特定的记录。

主键（primary key）的特性即 非空且唯一，如果在没有指定主键的时候，如果某一列（或一组列）具有非空且唯一的特性，他就会被暂定为主键，但是主键只能有一个。

表中的任何列都可以作为主键，只要它满足以下条件：

  • 任意两行都不具有相同的主键值；
  • 每个行都必须具有一个主键值（主键列不允许NULL值）。

上面提到多个列也可以作为主键。在使用多列作为主键时，上述条件必须应用到构成主键的所有列，所有列值的 组合 必须是唯一的（但单个列的值可以不唯一）。

除MySQL强制实施的规则外，应该坚持的几个普遍认可的最好习惯为：

  • 不更新主键列中的值；
  • 不重用主键列的值；
  • 不在主键列中使用可能会更改的值。（例如，如果使用一个名字作为主键以标识某个供应商，当该供应商合并和更改其名字时，必须更改这个主键。）
// 使用  NOT NULL UNIQUE
mysql> CREATE TABLE pen(-> id int NOT NULL UNIQUE,-> name varchar(12),-> price double,-> num int-> );
Query OK, 0 rows affected (0.06 sec)// id 的 KEY 属性变为 PRI
mysql> DESC pen;
+-------+-------------+------+-----+---------+-------+
| Field | Type        | Null | Key | Default | Extra |
+-------+-------------+------+-----+---------+-------+
| id    | int         | NO   | PRI | NULL    |       |
| name  | varchar(12) | YES  |     | NULL    |       |
| price | double      | YES  |     | NULL    |       |
| num   | int         | YES  |     | NULL    |       |
+-------+-------------+------+-----+---------+-------+
4 rows in set (0.00 sec)// 使用 PRIMARY KEY 
mysql> CREATE TABLE clothes(-> id int PRIMARY KEY,-> name varchar(12),-> price double,-> num int-> );
Query OK, 0 rows affected (0.02 sec)// id 的 KEY 属性变为 PRI
mysql> DESC clothes;
+-------+-------------+------+-----+---------+-------+
| Field | Type        | Null | Key | Default | Extra |
+-------+-------------+------+-----+---------+-------+
| id    | int         | NO   | PRI | NULL    |       |
| name  | varchar(12) | YES  |     | NULL    |       |
| price | double      | YES  |     | NULL    |       |
| num   | int         | YES  |     | NULL    |       |
+-------+-------------+------+-----+---------+-------+
4 rows in set (0.01 sec)

但是 非空且唯一 并不一定就是主键，如果有多个非空不唯一，则只有第一个是主键。

// 将 id 和 num 都设置为非空且唯一
mysql> CREATE TABLE pen(-> id int NOT NULL UNIQUE,-> name varchar(12),-> price double,-> num int UNIQUE NOT NULL-> );
Query OK, 0 rows affected (0.02 sec)// 只有 id 是 PRI
mysql> DESC pen;
+-------+-------------+------+-----+---------+-------+
| Field | Type        | Null | Key | Default | Extra |
+-------+-------------+------+-----+---------+-------+
| id    | int         | NO   | PRI | NULL    |       |
| name  | varchar(12) | YES  |     | NULL    |       |
| price | double      | YES  |     | NULL    |       |
| num   | int         | NO   | UNI | NULL    |       |
+-------+-------------+------+-----+---------+-------+
4 rows in set (0.00 sec)

但我们之前也提到过，是允许 多个列 组成主键的，那么怎么实现呢？

mysql> CREATE TABLE pen(-> id int PRIMARY KEY,-> name varchar(12) PRIMARY KEY,-> price double,-> num int-> );
ERROR 1068 (42000): Multiple primary key defined

通过报错我们发现，如果在两个列后分别声明主键的话会被认为 定义了多个主键。

// 正确做法是在声明完所有列之后，再声明主键是由哪些列构成的
mysql> CREATE TABLE pen(-> id int,-> name varchar(12),-> price double,-> num int,-> PRIMARY KEY(id, name)-> );
Query OK, 0 rows affected (0.03 sec)mysql> DESC pen;
+-------+-------------+------+-----+---------+-------+
| Field | Type        | Null | Key | Default | Extra |
+-------+-------------+------+-----+---------+-------+
| id    | int         | NO   | PRI | NULL    |       |
| name  | varchar(12) | NO   | PRI | NULL    |       |
| price | double      | YES  |     | NULL    |       |
| num   | int         | YES  |     | NULL    |       |
+-------+-------------+------+-----+---------+-------+
4 rows in set (0.01 sec)

AUTO_INCREMENT 自增

添加自增属性的项必须为数字，并且必须为主键，并且只有缺省的时候才会使用自增。

  • 如果插入的 AUTO_INCREMENT 属性的列值为缺省，则赋值为上一条记录的值 +1 ，没有上一条记录，则赋值为 1 。
  • 如果删除了表中数据，序号并不会重置，而是继续从删除的位置自增。
mysql> CREATE TABLE pen(-> id int PRIMARY KEY AUTO_INCREMENT,-> name varchar(12),-> price double,-> num int-> );
Query OK, 0 rows affected (0.02 sec)// 可以看到 id 的 Extra 属性变成了 auto_increment
mysql> DESC pen;
+-------+-------------+------+-----+---------+----------------+
| Field | Type        | Null | Key | Default | Extra          |
+-------+-------------+------+-----+---------+----------------+
| id    | int         | NO   | PRI | NULL    | auto_increment |
| name  | varchar(12) | YES  |     | NULL    |                |
| price | double      | YES  |     | NULL    |                |
| num   | int         | YES  |     | NULL    |                |
+-------+-------------+------+-----+---------+----------------+
4 rows in set (0.00 sec)// 加入一条未设 id 的数据
mysql> INSERT INTO pen(name, price, num) VALUES("A", 2.34, 5);
Query OK, 1 row affected (0.01 sec)// id 被自动设置为 1
mysql> SELECT * FROM pen;
+----+------+-------+------+
| id | name | price | num  |
+----+------+-------+------+
|  1 | A    |  2.34 |    5 |
+----+------+-------+------+
1 row in set (0.00 sec)// 增加两条数据，一条设置 id
mysql> INSERT INTO pen VALUES(3, "B", 3.45, 7);
Query OK, 1 row affected (0.00 sec)
// 一条不设 id
mysql> INSERT INTO pen(name, price, num) VALUES("C", 6.34, 10);
Query OK, 1 row affected (0.00 sec)// 未设 id 的数据其 id 会变成上一条记录的 id+1
mysql> SELECT * FROM pen;
+----+------+-------+------+
| id | name | price | num  |
+----+------+-------+------+
|  1 | A    |  2.34 |    5 |
|  3 | B    |  3.45 |    7 |
|  4 | C    |  6.34 |   10 |
+----+------+-------+------+
3 rows in set (0.00 sec)// 删掉所有 id<=4 的数据
mysql> DELETE FROM pen WHERE id <= 4;
Query OK, 3 rows affected (0.00 sec)// 增加两条数据，都没有设置 id 值
mysql> INSERT INTO pen(name, price, num) VALUES("D", 7.34, 1);
Query OK, 1 row affected (0.00 sec)
mysql> INSERT INTO pen(name, price, num) VALUES("E", 12.34, 13);
Query OK, 1 row affected (0.00 sec)// 新增的两条数据的 id 并不是从 1 开始，而是根据上一条记录（虽然它已经不存在了）的 id 自增
mysql> SELECT * FROM pen;
+----+------+-------+------+
| id | name | price | num  |
+----+------+-------+------+
|  5 | D    |  7.34 |    1 |
|  6 | E    | 12.34 |   13 |
+----+------+-------+------+
2 rows in set (0.00 sec)

FOREIGN KEY（外键约束）

外键：外键为表中的某一列，包含了另一个表的主键，定义了两个表之间的关系。例如学生表中存储了班级的信息，但是在班级表中并没有这个班级存在，就会导致数据出现冲突，所以必须将两个表关联起来。

语法

FOREIGN KEY (外键项) REFERENCES 关联表名(关联表中的对应项)

示例

// 创建班级表
mysql> CREATE TABLE class(-> id int PRIMARY KEY AUTO_INCREMENT-> );
Query OK, 0 rows affected (0.03 sec)
// 创建学生表
mysql> CREATE TABLE student(-> id int PRIMARY KEY AUTO_INCREMENT,-> num int,-> name varchar(10),-> classid int,-> FOREIGN KEY (classid) REFERENCES class(id)-> );
Query OK, 0 rows affected (0.03 sec)
// 创建两个班级
mysql> INSERT INTO class VALUES(181);
Query OK, 1 row affected (0.01 sec)
mysql> INSERT INTO class VALUES(182);
Query OK, 1 row affected (0.00 sec)
// 插入三条学生数据
mysql> INSERT INTO student(name, classid) VALUES("李四", 182);
Query OK, 1 row affected (0.03 sec)
mysql> INSERT INTO student(name, classid) VALUES("陈六", 181);
Query OK, 1 row affected (0.00 sec)
// 第三条失败，原因在于没有186班
mysql> INSERT INTO student(name, classid) VALUES("张三", 186);
ERROR 1452 (23000): Cannot add or update a child row: a foreign key constraint fails (`test`.`student`, CONSTRAINT `student_ibfk_1` FOREIGN KEY (`classid`) REFERENCES `class` (`id`))

CHECK（检查约束）

保证列中的值符合指定的条件。对于MySQL数据库，对CHECK子句进行分析，但是忽略CHECK子句。

mysql> CREATE TABLE stu(-> id int,-> age int,-> name varchar(10),-> CHECK(id < 5)-> );
Query OK, 0 rows affected (0.03 sec)mysql> INSERT INTO stu(id) VALUES(3);
Query OK, 1 row affected (0.01 sec)mysql> INSERT INTO stu(id) VALUES(8);
ERROR 3819 (HY000): Check constraint 'stu_chk_1' is violated.
mysql> SELECT * FROM stu;
+------+------+------+
| id   | age  | name |
+------+------+------+
|    3 | NULL | NULL |
+------+------+------+
1 row in set (0.00 sec)

值得一提的是，在 MySQL 8.0.16 版本之前的 CHECK 约束，能被解析但是被忽略掉了，就是 不符合CHECK的数据依然可以被加入到表中。 而在之后的版本上，支持 CHECK约束，但仍有缺陷！想要 INSER INTO 一个不满足 CHECK 的数据时确实不能通过（详见上面的示例中），但是如果 INSERT INTO 时，未设置被 CHECK 约束的 列，那么 即使这个列的默认值不符合 CHECK约束 ，也还是可以创建成功。
在这里插入图片描述
可以看到 主动赋值 不满足 CHECK 的语句会报错，而 默认值 不满足 CHECK 的语句却可以成功插入。

表的设计

表的关系

一对一

例如人和身份证的关系，每个人都对应有着只属于自己的身份证：
在这里插入图片描述

一对多

例如学生和班级的关系，一个班级拥有多个学生，但是一个学生只能属于一个班级：
在这里插入图片描述

多对多

例如学生、课程、选课表的关系。一个学生可以选择多门课程，一个课程也可以被多个学生选择：
在这里插入图片描述

三大范式

表的关系只是设计的最基础的一项，考虑好关系，确认好数据项，将数据填进去即可。
但是那样的设计并不合理，可能会存在 数据冗余、传输性能、查询性能 等问题，所以需要用到三大范式来规范数据库表的设计，减少数据库的冗余性。

范式是针对数据库表设计的几种方案，目前关系数据库有六种范式：第一范式（1NF）、第二范式（2NF）、第三范式（3NF）、巴斯-科德范式（BCNF）、第四范式(4NF）和第五范式（5NF，又称完美范式）。

通常我们使用的都是第一范式（1NF）、第二范式（2NF）、第三范式（3NF），所以又将他们称为三大范式。

第一范式

要求数据库表的每一列都是不可分割的原子数据项。

在这里插入图片描述
在这个表中，家庭信息和学校信息并不是原子的，例如家庭信息中包含了家庭组成和所在地，学校信息包含了年级和学位。

对于第一范式，需要确保每一项数据都是不可分割的原子性数据，不能是一个集合。因此要做出如下调整：

在这里插入图片描述

第二范式

在第一范式的基础上，非主键数据必须完全依赖主键，不能部分依赖（针对组合主键）。

拿下面这个表来说，相同 订单号 的 订单时间和订单金额 是 一样 的，但是相同 产品号 的 订单时间和订单金额 却 不一样 。这说明订单时间和订单金额 部分依赖主键 —— 只依赖了组合主键中的订单号而没有依赖产品号 。
在这里插入图片描述
所以需要将其分割出去单独建立一个表：
在这里插入图片描述

第三范式

在第二范式的基础上，每一个非主键数据都必须要和主键直接依赖而非间接依赖，即不能依赖非主键数据。旨在体现依赖关系不可传递性。

如下图，班主任性别 与 班主任年龄 直接依赖于班主任姓名（非主键数据），而与 主键——学号 并没有直接的依赖关系，而是间接，这就是依赖传递：
在这里插入图片描述

所以需要将这两项分割出去单独建表：
在这里插入图片描述

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

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

相关文章

哈希 ：哈希冲突、负载因子、哈希函数、哈希表、哈希桶

哈希 ：哈希冲突、负载因子、哈希函数、哈希表、哈希桶

文章目录哈希哈希&#xff08;散列&#xff09;函数常见的哈希函数字符串哈希函数哈希冲突闭散列&#xff08;开放地址法&#xff09;开散列&#xff08;链地址法/拉链法&#xff09;负载因子以及增容对于闭散列对于开散列结构具体实现哈希表&#xff08;闭散列&#xff09;创建…
阅读更多...
C++ 泛型编程（一）：模板基础：函数模板、类模板、模板推演成函数的机制、模板实例化、模板匹配规则

C++ 泛型编程（一）：模板基础：函数模板、类模板、模板推演成函数的机制、模板实例化、模板匹配规则

文章目录泛型编程函数模板函数模板实例化隐式实例化显式实例化函数模板的匹配规则类模板类模板的实例化泛型编程 泛型编程旨在削减重复工作&#xff0c;如&#xff1a; 将一个函数多次重载不如将他写成泛型。 void Swap(int& left, int& right) {int temp left;lef…
阅读更多...
你真的了解静态变量、常量的存储位置吗？

你真的了解静态变量、常量的存储位置吗？

文章目录引言C对内存的划分如何落实在Linux上自由存储区和堆之间的问题栈常量区静态存储区静态局部变量静态局部变量、静态全局变量、全局变量的异同macOS系统的测试结果总结引言 在动态内存的博客中&#xff0c;我提到&#xff1a; 在Linux 内存管理的博客中&#xff0c;我提…
阅读更多...
C++ 泛型编程（二）：非类型模板参数，模板特化，模板的分离编译

C++ 泛型编程（二）：非类型模板参数，模板特化，模板的分离编译

文章目录非类型模板参数函数模板的特化类模板的特化全特化偏特化部分参数特化参数修饰特化模板分离编译解决方法非类型模板参数 模板的参数分为两种&#xff1a; 类型参数&#xff1a; 则是我们通常使用的方式&#xff0c;就是在模板的参数列表中在 class 后面加上参数的类型…
阅读更多...
数据结构 | B树、B+树、B*树

数据结构 | B树、B+树、B*树

文章目录搜索结构B树B树的插入B树的遍历B树的性能B树B树的插入B树的遍历B*树B*树的插入总结搜索结构 如果我们有大量的数据需要永久存储&#xff0c;就需要存储到硬盘之中。但是硬盘的访问速度远远小于内存&#xff0c;并且由于数据量过大&#xff0c;无法一次性加载到内存中。…
阅读更多...
MySQL 索引 ：哈希索引、B+树索引、全文索引

MySQL 索引 ：哈希索引、B+树索引、全文索引

文章目录索引引言常见的索引哈希索引自适应哈希索引B树索引聚集索引非聚集索引使用方法联合索引最左前缀匹配规则覆盖索引全文索引使用方法索引 引言 为什么需要索引&#xff1f; 倘若不使用索引&#xff0c;查找数据时&#xff0c;MySQL必须遍历整个表。而表越大&#xff0c;…
阅读更多...
服装店怎么引流和吸引顾客 服装店铺收银系统来配合

服装店怎么引流和吸引顾客 服装店铺收银系统来配合

实体店的同城引流和经营是实体经济的一个重要的一环&#xff0c;今天我们来分享服装行业的实体店铺怎么引流和吸引、留住顾客&#xff0c;并实现复购。大家点个收藏&#xff0c;不然划走就再也找不到了&#xff0c;另外可以点个关注&#xff0c;下次有新的更好的招&#xff0c;…
阅读更多...
MySQL 锁的相关知识 | lock与latch、锁的类型、简谈MVCC、锁算法、死锁、锁升级

MySQL 锁的相关知识 | lock与latch、锁的类型、简谈MVCC、锁算法、死锁、锁升级

文章目录lock与latch锁的类型MVCC一致性非锁定读&#xff08;快照读&#xff09;一致性锁定读&#xff08;当前读&#xff09;锁算法死锁锁升级lock与latch 在了解数据库锁之前&#xff0c;首先就要区分开 lock 和 latch。在数据库中&#xff0c;lock 和 latch 虽然都是锁&…
阅读更多...
MySQL 存储引擎 | MyISAM 与 InnoDB

MySQL 存储引擎 | MyISAM 与 InnoDB

文章目录概念innodb引擎的4大特性索引结构InnoDBMyISAM区别表级锁和行级锁概念 MyISAM 是 MySQL 的默认数据库引擎&#xff08;5.5版之前&#xff09;&#xff0c;但因为不支持事务处理而被 InnoDB 替代。 然而事物都是有两面性的&#xff0c;InnoDB 支持事务处理也会带来一些…
阅读更多...
MySQL 事务 | ACID、四种隔离级别、并发带来的隔离问题、事务的使用与实现

MySQL 事务 | ACID、四种隔离级别、并发带来的隔离问题、事务的使用与实现

文章目录事务ACID并发带来的隔离问题幻读&#xff08;虚读&#xff09;不可重复读脏读丢失更新隔离级别Read Uncommitted (读未提交)Read Committed (读已提交)Repeatable Read (可重复读)Serializable (可串行化)事务的使用事务的实现Redoundo事务 事务指逻辑上的一组操作。 …
阅读更多...
MySQL 备份与主从复制

MySQL 备份与主从复制

文章目录备份主从复制主从复制的作用备份 根据备份方法的不同&#xff0c;备份可划分为以下几种类型&#xff1a; 热备(Hot Backup) &#xff1a; 热备指的是在数据库运行的时候直接备份&#xff0c;并且对正在运行的数据库毫无影响&#xff0c;这种方法在 MySQL 官方手册中又…
阅读更多...
C++ 流的操作 | 初识IO类、文件流、string流的使用

C++ 流的操作 | 初识IO类、文件流、string流的使用

文章目录前言IO头文件iostreamfstreamsstream流的使用不能拷贝或对 IO对象 赋值条件状态与 iostate 类型输出缓冲区文件流fstream类型文件模式文件光标函数tellg() / tellp()seekg() / seekp()向文件存储内容/读取文件内容string流istringstreamostringstream前言 我们在使用 …
阅读更多...
C++ 右值引用 | 左值、右值、move、移动语义、引用限定符

C++ 右值引用 | 左值、右值、move、移动语义、引用限定符

文章目录C11为什么引入右值&#xff1f;区分左值引用、右值引用move移动语义移动构造函数移动赋值运算符合成的移动操作小结引用限定符规定this是左值or右值引用限定符与重载C11为什么引入右值&#xff1f; C11引入了一个扩展内存的方法——移动而非拷贝&#xff0c;移动较之拷…
阅读更多...
且谈关于最近软件测试的面试

且谈关于最近软件测试的面试

前段时间有新的产品需要招人&#xff0c;安排和参加了好几次面试&#xff0c;下面就谈谈具体的面试问题&#xff0c;在面试他人的同时也面试自己。 面试问题是参与面试同事各自设计的&#xff0c;我也不清楚其他同事的题目&#xff0c;就谈谈自己设计的其中2道题。 过去面试总是…
阅读更多...
C++ 多态 | 虚函数、抽象类、虚函数表

C++ 多态 | 虚函数、抽象类、虚函数表

文章目录多态虚函数重写重定义&#xff08;参数不同&#xff09;协变&#xff08;返回值不同&#xff09;析构函数重写&#xff08;函数名不同&#xff09;final和override重载、重写、重定义抽象类多态的原理虚函数常见问题解析虚函数表多态 一种事物&#xff0c;多种形态。换…
阅读更多...
C++ 运算符重载（一） | 输入/输出，相等/不等，复合赋值，下标，自增/自减，成员访问运算符

C++ 运算符重载（一） | 输入/输出，相等/不等，复合赋值，下标，自增/自减，成员访问运算符

文章目录输出运算符<<输入运算符>>相等/不等运算符复合赋值运算符下标运算符自增/自减运算符成员访问运算符输出运算符<< 通常情况下&#xff0c;输出运算符的第一个形参是一个 非常量ostream对象的引用 。之所以 ostream 是非常量是因为向流写入内容会改变…
阅读更多...
C++ 重载函数调用运算符 | 再探lambda，函数对象，可调用对象

C++ 重载函数调用运算符 | 再探lambda，函数对象，可调用对象

文章目录重载函数调用运算符lambdalambda等价于函数对象lambda等价于类标准库函数对象可调用对象与function可调用对象function函数重载与function重载函数调用运算符 函数调用运算符必须是成员函数。 一个类可以定义多个不同版本的调用运算符&#xff0c;互相之间应该在参数数…
阅读更多...
C++ 运算符重载（二） | 类型转换运算符，二义性问题

C++ 运算符重载（二） | 类型转换运算符，二义性问题

文章目录类型转换运算符概念避免过度使用类型转换函数解决上述问题的方法转换为 bool显式的类型转换运算符类型转换二义性重载函数与类型转换结合导致的二义性重载运算符与类型转换结合导致的二义性类型转换运算符 概念 类型转换运算符&#xff08;conversion operator&#…
阅读更多...
分布式理论：CAP、BASE | 分布式存储与一致性哈希

分布式理论：CAP、BASE | 分布式存储与一致性哈希

文章目录分布式理论CAP定理BASE理论分布式存储与一致性哈希简单哈希一致性哈希虚拟节点分布式理论 CAP定理 一致性&#xff08;Consistency&#xff09;&#xff1a; 在分布式系统中的所有数据副本&#xff0c;在同一时刻是否一致&#xff08;所有节点访问同一份最新的数据副…
阅读更多...
分布式系统概念 | 分布式事务：2PC、3PC、本地消息表

分布式系统概念 | 分布式事务：2PC、3PC、本地消息表

文章目录分布式事务2PC&#xff08;二阶段提交协议&#xff09;执行流程优缺点3PC&#xff08;三阶段提交协议&#xff09;执行流程优缺点本地消息表&#xff08;异步确保&#xff09;分布式事务 分布式事务就是指事务的参与者、支持事务的服务器、资源服务器以及事务管理器分…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023