C++：查漏补缺笔记

数组

一维数组

初始化数组

• 第一种：数组定义空间大小但不手动赋值（默认初始化）

  • 1.1
    不初始化，只定义，后面不赋值（没有意义）
    这种直接开辟空间的是没有意义的，如果这样初始化后，必须记得后面要进行赋值操作，下面的代码打印出来就是一个没有意义的数值。

  	int nums[5]; 
  	int len = sizeof(nums) / sizeof(int);
  	for (int i = 0; i < len; i++) {
  		cout << nums[i];
  	}
  

  • 1.2
    另一种是定义，并 默认初始化，给一个大括号就是默认初始化 ，不同类型会产生不同的默认值。
    数值类型（int,float,double…）：默认值是0。
    字符类型（char）：默认值是空字符。
    长度是根据你给出的数组大小决定的，
    不会因为没有赋值而长度变成0。

  	int nums[5]={}; 
  	int len = sizeof(nums) / sizeof(int);
  	for (int i = 0; i < len; i++) {
  		cout << nums[i];
  	}
  	cout << len << endl; 
  	//长度是5，不会因为没有赋值长度变成0
  

• 第二种：数组定义空间大小并赋值

  • 定义数组并给初始化的空间全部手动赋值
    直接给数组的空间赋值，并且每一个数值的类型必须都是一样。（五个int空间就赋值5个数值）

  	int nums[5]= { 1,2,3,4,5 }; 
  	int len = sizeof(nums) / sizeof(int);
  	for (int i = 0; i < len; i++) {
  		cout << nums[i];
  	}
  

  • 定义数组并给初始化的空间部分手动赋值，后面的默认初始化
    数组是5个空间，但是只初始化了4个数值，那么剩下的就会用0默认赋值。
    数值类型（int,float,double…）：默认值是0。
    字符类型（char）：默认值是空字符。

  	int nums[5]= { 1,2,3,4}; 
  	int len = sizeof(nums) / sizeof(int);
  	for (int i = 0; i < len; i++) {
  		cout << nums[i];
  	}
  

• 第三种：数组不定义空间大小，但需手动赋值。
  中括号内不显示的定义多少个空间，那么就必须在花括号内赋值，赋值后会自动帮你计算出来你赋值了多少个数值，然后你的数组空间大小就是多少。
  不可以即不显示写出空间的大小也不进行花括号赋值初始化，这样一般的代码编辑器不用等你编译后都会显示的告诉你代码错误
  错误示范→：nums[]={}

  	int nums[]= { 1,2,3,4,5}; 
  	int len = sizeof(nums) / sizeof(int);
  	for (int i = 0; i < len; i++) {
  		cout << nums[i];
  	}
  

数组名

• 数组名的含义
  • 直接打印数组名即数组的地址
  • &数组名，即数组地址
  • 数组第一个空间的地址（首地址，&数组名[0]）

	//以下输出的三个都是地址，并且都是同一个地址
	cout << nums << endl; 
	cout << &nums << endl;
	cout << &nums[0] << endl;

• 取出的地址进行sizeof量长度大小的话
  • 在x64(64位编译环境下)
    地址长度为8字节
  • 在x86(32位编译环境下)
    地址长度为4字节

二维数组

二维数组其实本质还是一维数组，只不过可以用二维坐标的方式取出数据而已，其实你还是可以只使用一个行就能取出所有元素。
比如nums[0][0~end]可以只使用第0行就能取出后面所有的元素，因为二维数组的元素还是一串连续的地址空间，因此即使你使用超过该行的列数，那么他二维数组会把你该列模该行的列数的结果就是下一行的元素列下标（当然是不超过下标的情况）。
二维数组定义的四种方式

• 1：数据类型 数组名 [ 行数 ][ 列数 ];
  初始化，同一维数组一样，如果后面不进行赋值的话就没有意义。

• 2：数据类型 数组名 [ 行数 ][ 列数 ] = {{数据1,数据2 }, {数据3,数据4}};
  初始化的空间多少就赋值多少数据。

  	int nums2[2][3] = { {1,2,4},{5,6} };
  

  这种初始化方式照样很随意，只要你不超过一行规定的列数，所有元素加起来不超过总空间即可，因为二维数组本质就是一维数组。
  同理：在本例子中，第二行的5，6中明显不符合三列的规定，但是在数组中会默认赋值为0，同一维数组一样
  （都说了吧，二维本质就是一维）

• 3： 数据类型 数组名[行数][列数]={数据1,数据2,数据3,数据4};
  这里是需要你赋值的数据不要超过二维数组的总空间即可
  比如：2行3列，你用这种赋值方式只需要你所有数据个数在2×3=6个内即可。

  int nums2[2][3] = { 1,4,5,6 };
  

  这种和给每行单独赋值的区别就是：在该方法中，我们不能让计算机给我们的某一行默认赋值0，比如本方法中，他会自动的给145分在同一行，然后6作为第二行，然后后面两列没有赋值的就会自动的填充0。但是我们在用花括号给每一行进行赋值的时候可以手动的控制我们应该赋值的元素，不赋值的就自动让他默认值即可。（各个有各个的好处，看具体情况具体分析）

• sizeof(nums[0])：这是一行的数据大小

• sizeof(nums[0][0])：这是一个元素的大小

• nums[0]这是一行中的首地址，相当于一维数组中的首地址

• nums这是第一行第一列的地址，也是整个二维数组的地址

总结：二维数组和一维数组一样，二维只是多了一个行的定义，在二维中可以表现的跟一维数组一样，只用一行就可以表示二维内所有的元素（只不过是在改行内作为主位置，相对于其他元素的位置作为列下标）
好比下面的例子：甚至可以用 负号 作为列下标
int nums2[2][3] = { 1,2,5,6,1 };
cout << nums2[1][-1] << endl;

函数

函数声明

• 函数声明可以有多次，但是函数定义只能有一次（可以选择重载函数）
  函数声明可以单出一个头文件，前提是必须在main函数之前声明，在函数定义之前声明。

函数的分文件

• 头文件
  用来存放函数的声明和其他。
• 函数定义文件，也就是CPP文件
  用来存放对于头文件中的函数声明的函数定义。
• 主文件CPP
  这个就是主要程序的文件了。
• 注意：不同文件之间相互引用才能使用彼此的代码，比如函数定义里面要使用头文件里面的东西，直接使用include即可引进来（自己编写的文件要用双引号引，不能用尖括号）
• 主程序中一般引用的是头文件，然后定义函数文件里面也必须要引用头文件。
  解释：我们主程序引用头文件就行是因为我们在一个项目中，因此编译的时候可以通过函数声明找到函数定义的文件然后我们引用函数声明的文件即可。

函数重载

• 函数重载的条件
  • 函数名必须相同
  • 函数的参数个数或者参数类型不同
    首先这个参数个数必须是没有默认参数的才算一个参数
    下面这两个出现二义性了，就不能构成函数重载了。

    void a(int a,int b = 10);
    void a(int a);
    

  • 函数使用引用类型进行函数重载也是可以的。
    需要注意的就是我们的引用类型本质是：int* const，因此传参的时候只需要正常传参就行，传入一个普通变量，该函数就会将你的变量转为引用类型到函数内部进行操作。
    因为函数参数就是一个赋值的过程，函数参数 = 调用函数的实参，那么在引用作为参数的时候就直接变成了：int& a = 实参，所以函数调用的过程就是一个参数赋值的过程，然后将你参数的类型转到函数内部进行使用。
    • 还有一个注意事项：const int& a，双重const的时候该变量类型本质就是：const int * const a，所以我们在调用的时候必须要传递一个常量作为参数，所以我们可以直接传define过的常量变量或者直接传递一个数字，数字就是一个常量，变量才不是常量。数值10，。。。这些都是常量，变量则是有变量名和显示指出变量类型才为变量。
• 返回值不同不能完成重载，因为我们的重载条件仅仅是函数名相同，参数类型和个数不同即可。函数返回值不同不会影响你的函数重载，换句话说不能使用函数返回值不同来完成函数重载。

指针

指针占的内存

• 在x86，即32位操作系统编译下，一个指针变量占：4位
• 在x64，即64位操作系统编译下，一个指针变量占：8位
  无论是什么类型的指针都一样，因为存的指针都是进制数。

空指针

空指针是用于防止野指针的出现

• 空指针不是野指针，空指针用NULL赋值之后是指向0的，就是防止野指针出现。
  • 控制指针不能访问，除非你给他赋值地址了，当然你赋值了就不叫空指针了都。（因此：当他还是一个空指针的时候，空指针是不能进行访问赋值的）

野指针

• 野指针就是你的指针用完之后没有将置为空指针，那么这个指针的指向是不明确的，或者说你这个地址用完了已经释放了，但是你的指针还在指向这个地址位置，这就是没有权限的访问，越界访问就是野指针。在编写代码中不要出现空指针现象。

const

常量的意思是，被修饰的那个东西不能修改。

• 常量指针

const int * p

常量指针，直接音译过代码就是const int *，常量const，指针int *，
然后的话常量指针修饰的是指针类型，所以指针指向的值不能修改，但是我们的指针的指向的值是可以修改的。
解释：常量的指针嘛，都说了常量了，那你指针指向我的常量不就是指针指向的值不能修改嘛。

• 指针常量

int* const p

指针常量，直接音译过代码就是int *指针，const常量，
然后指针常量说的就是指针的常量，那很明显了我们的指针变量不能修改，也就是说我们指针指向不能修改但是值是可以修改的。
解释：指针的常量，中文意思已经很明白了，就是指针常量，那么就是指针指向的地址是常量，常量就是不能修改的意思。

• 双重const修饰
  意思就是既修饰指针变量又修饰指针指向的值，就是上了双重锁，一旦指定一个值，地址不能变，值也不能变。

const int * const p

总结：其实字面意思和代码的书写顺序一样
常量+指针 = const int* : 常量指针
指针+常量 = int* const : 指针常量
如何区别：其实只要记住中文意思即可
常量指针：常量的指针，那就是说我的这个指针指向的值是一个常量，那就是指针指向的值是不能修改的，但是这个地址的值可以随便修改。
指针常量：指针的常量，那就说我们的这个指针变量不能随意修改，那么我们指针变量存的东西就是地址值，那么换句话说就是我们的指针常量就是不允许修改指针地址，但是地址指向的值可以随意修改。
双重const：很明显了 ，就是哪边都不能进行修改操作，直接上了两把锁。

结构体指针

在结构体中使用指针访问内部变量的时候使用->箭头。

指针++

指针++这个就是说对于一个数组指针来说，可以使用指针++的形式进行移位访问。相当于用自增下标访问所有元素。

int nums[5] = {1,2,3,4,5};
int* p = nums;
for(int i = 0; i < 5; i++){
	cout << *p++ << endl;
}

指针与函数

地址传递

经典的通过指针地址交换值函数

void swap(int* num1, int* num2){
	int temp;
	temp = *num1;
	*num1 = *num2;
	num2* = temp;
}
//调用
int a = 1;
int b = 2;
swap(&a,&b);

C++引用

基本语法

int a = 10;
int& b = a; //这个就是引用类型

• 引用类型的本质其实就是： int * const p
  就是指针常量，指针指向的地址不等你修改，值可以修改就是引用的本质。
  • 引用必须初始化
  • 引用不可以改变（值可以改变）
    验证：

int a = 10;
int& b = a; 
int c = 1;
int& d = c;
//开始验证
//int &e;这样写是错误的
d = b;//记住这个不是改变引用，而是把b的值给了引用d

在尝试改变引用中发现是行不通的，就是说我们完成不了这件事，也就验证了这件事是不可行的，C++开发者已经把引用封装好了，所以刚刚也说引用就是指针常量。
因此记住引用就是封装好的指针常量。

• 引用也是一个类型，因此我们可以用它作为函数参数传递一个实参
  调用参数的时候可以很方便，在函数中使用引用过来的参数也很方便。
  引用就是给变量起别名，因此调用的时候是直接使用变量的名字，然后函数中直接用&变量名的形式把调用函数的变量名接过来（当真是妙哉妙哉！！）

void swap(int& a,int& b){
	int temp;
	temp = a;
	a = b;
	b = a;
}
//函数调用
int a = 10;
int b = 20;
swap(a,b);
//我们可以很方便的在传参过程中就像传递形参一样传递实参进函数里面。

• 常量引用
  说白了就是双重buff的const，因为引用就是指针常量，
  所以常量引用就是：const int& 变量名别名 = 变量名
  const int&本质就是：const int* const

面向对象

• this是指针要使用->箭头访问成员（学过Java的千万别记混了）

---

日后继续补充细节…

---