数据库范式能帮忙解决数据冗余问题

1.第一范式（1NF）

关系里的属性不能够拆分。





第一个不符合第一范式，第二个表才符合。

2.第二范式（2NF）

在1NF的基础上，且每一个非主属性完全函数依赖于任何一个候选码

就是说主属性决定不了非主属性，但是非主属性依赖于候选码



候选码：学号+姓名+课名

那么主属性：学号 姓名 课名

非主属性：系名，系主任、分数

首先这个表是第一范式，但是很明显非主属性不完全依赖候选码。比如系名就跟学号和姓名和课名没多大关系。

所以我们拆成



先看第一个表，学号跟课名是候选码。

主属性：学号、课名。非主属性：分数。

分数取决于学号+课名。

但是课名决定不了分数，还得加分数。

第二个表格

候选码：学号

主属性：学号

非主属性：姓名，系名，系主任。

学号可以决定学号，但是学号决定了系名和系主任。

所以也是第二范式。

分数

3.第三范式（3NF）

3NF在2NF的基础之上，消除了非主属性对于码的传递函数依赖。也就是说， 如果存在非主属性对于码的传递函数依赖，则不符合3NF的要求。

传递依赖

在上面拆成的第二个表中是符合2NF，但是系主任取决于系名，系名取决于学号。这种就是传递依赖。所以这个表不符合3NF。



把它拆成以上两个表，就不会存在传递依赖了。
总结一下：

1NF是为了解决属性可再拆分的数据冗余。

2NF是为了解决部分非主属性不依赖所有候选码。

部分非主属性只取决于部分候选码，那么就要拆表。拆成所有非主属性取决于所有候选码

3NF是为了解决 非主属性虽然取决于所有候选码，但是部分非主属性之间有依赖关系  比如说  地名跟邮政编码一般都是会有依赖关系的，就会形成传递依赖。

在使用Win32DiskImager.exe为香橙派或者树莓派烧写镜像的时候，会出现“数据错误，循环冗余检查”

昨天晚上折腾了到半夜，一直以为是自己的编译的出来的镜像有问题或者是sd有问题呢，最终发现都不是。在这里我想对小伙伴们说，可以考虑是usb供电问题和读卡器本身的问题。

我解决的方法是：更换了一个tf的读卡器， 然后烧写镜像的时候，将读卡器插入到了电脑后面的USB接口，成功的烧写成功了。

 

记录一下，以防以后遇见这类问题忘记。小伙伴们也可以参考一下。

菱形继承问题和虚继承是如何解决二义性与数据冗余的

继承是c++的三大特性之一，其中菱形继承问题是一个值得我们学习和掌握的知识点。 

1.什么是菱形继承呢？ 

 菱形继承定义为：两个子类继承同一个父类，而又有子类同时继承这两个父类。 

 可能这样纯粹的文字大家不能直观的理解它，下面画一幅直观图便可一目了然： 


菱形继承的代码描述如下：

#include<iostream>
using namespace std; 

class A
{
public:
    int _a;
};

class B : public A
{
public:
    int _b;
};

class C : public A
{
public:
    int _c;
};

class D :public B, public C
{
public:
    int _d;
};

void Test()
{
    D d;
    d.B::_a = 1;
    d.C::_a = 2;
}

int main()
{
    Test();
    return 0;
}



 可以看到，在对_a赋值时，必须使用域访问限定符，否则无法识别是对BB对象还是对CC对象中的 _a赋值，虽然这样解决了二义性问题，但是又产生了数据冗余的问题. 

2.如果要解决二义性和数据冗余的问题，则又需要引入虚继承的概念。 

虚继承是在class B : public A与class C :public A的public前加上关键字virtual. 

3.那么虚继承是如何解决二义性的呢？ 

要讨论这个问题，首先要来看看，对于菱形继承和虚继承来说， sizeof(b)的值是多大呢，菱形继承很容易看出答案是20个字节，很多人会想，那虚继承就是16字节了，但经过测试，发现应该是24字节，怎么会多出8个字节呢，这就涉及到内存的分配. 

将Test()做修改：

void Test()
{
    D d;
    d.B::_a = 0;
    d.C::_a = 1;
    d._b=2;
    d._c=3;
    d._d=4;
}

菱形继承中对象d求sizeof(d)=20 


可以看到内存分配正好符合菱形继承对象模型中变量的顺序  


给class B : public A与class C :public A的public前加上关键字virtual后，变成菱形虚继承，现在来看虚继承的情况. 

此时对象d的sizeof(d)=24 


那么地址0X00BBF8CC和0X00BBF9D4中存储的是什么呢？ 

在去查看内存可以看到0X00BBF8CC和0X00BBF9D4分别存储了一个指针，该指针指向的内存偏移四个字节处存储的分别是十进制值20和12，通过观察0X00BBF8CC和0X00BBF9D4与0X00BBF8E0相差的字节数，刚好是20和12，因此，该值代表了偏移量。

1.首先我们来解释一下二义性和数据冗余是如何产生的。
         我们知道在C++中继承分单继承和多继承，单继承就是一个子类只有一个直接父类，而多继承是一个子类有两个或       两个以上直接父类。
                                    
                             
          如上图所示多继承，构成菱形继承。B类和C类都继承了A类，为A的子类。D类同时继承了B类和C类。所以D类    中有从B支路继承下来的A类，也有从C类中继承下来的A类，因此产生了二义性和数据冗余。
2.C++是如何解决这个问题的
          C++语法中是这样解决的：在定义继承关系时，在菱形继承中被多次继承的那个父类前加virtual关键字，形成虚     继承。
下面举实例说明：

class A
{
public:
	int _a;
};

class B:virtual public A
{
public:
	int _b;
};

class C :virtual public A
{
public:
	int _c;
};

class D :public B,public C
{
public:
	int _d;
};

3.接下来具体分析底层是如何实现的

     首先来看不加virtual关键字时的对象模型（内存中的分布）。
     运行代码如下：

#include <iostream>
using namespace std;

class A
{
public:
	int _a;
};

class B:public A
{
public:
	int _b;
};

class C :public A
{
public:
	int _c;
};

class D :public B,public C
{
public:
	int _d;
};

int main()
{
	D d;
	d.B::_a = 1;
	d.C::_a = 2;
	d._b = 3;
	d._c = 4;
	d._d = 5;
}
打开内存窗口观察，结果如下：



接下来看加virtual关键字时的对象模型
运行代码如下：

#include <iostream>
using namespace std;

class A
{
public:
	int _a;
};

class B:virtual public A
{
public:
	int _b;
};

class C :virtual public A
{
public:
	int _c;
};

class D :public B,public C
{
public:
	int _d;
};

int main()
{
	D d;
	d.B::_a = 1;
	d.C::_a = 2;
	d._b = 3;
	d._c = 4;
	d._d = 5;
}
同样打开内存窗口来观察，结果如下：


观察该对象模型，发现D对象中确实只有一个_a了，说明解决了二义性和数据冗余。
但是B对象和C对象都继承了A对象，这个关系是如何体现的呢？
观察发现B和C中分别存了一个地址，应该是指向某处的一个指针。若通过这两个指针都能找到A对象，就能表示A,B,C的继承关系了。
下来看一下这两个指针指向何处：


发现该指针指向的空间向下一个位置存了一个16进制的数！
B内的指针指向的下一个位置存的是十进制的20，C内的指针指向的下一个位置存的是十进制的12。
而B地址（&B）+20字节=A的地址（&A）；&C+12=&A；


所以通过这两个指针可以间接的找的A，表达了B继承A，C继承A的关系；
称这个指针为虚基表指针，指向的表称虚基表。






---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
本菜鸟也在学习中，表述如有错误或不准确的地方，请您见谅，欢迎各位大神批评指正。