C++学习笔记之数组、函数、指针

---

一、数组

1.概述

所谓数组，就是一个集合，里面存放了相同类型的数据元素

特点1：数组中的每个数据元素都是相同的数据类型
特点2：数组是由连续的内存位置组成的

2.一维数组

2.1 一维数组定义的三种方法：

1.数据类型 数组名 [ 数组长度 ]；
2.数据类型 数组名 [ 数组长度] = { 值1，值2，....}；
3.数据类型 数组名 [ ] ={ 值1，值2，....}；

2.2 一维数组数组名

用途：
1.可以统计整个数组在内存中的长度
2.可以获取数组在内存中的首地址
代码如下（示例）：

	int arr[5] = { 0 ,1 ,2 ,3 ,4 };
	
	cout <<"整个数组占用的内存空间:" << sizeof(arr) <<endl;			//20
	cout <<"每个元素占用的内存空间:" << sizeof(arr[0]) << endl;		//4
	cout << "数组的元素个数：" << sizeof(arr) / sizeof(arr[0]) <<endl;		//5
	
	cout <<"数组首地址为:" << arr <<endl;					//0x70fdf0
	cout << "数组中第一个元素地址为:" << &arr[0] <<endl;	//0x70fdf0
	cout << "数组中第二个元素地址为:" << &arr[1] <<endl;	//0x70fdf4

3.二维数组

3.1二维数组定义方式

有四种方式：

1.·数据类型 数组名 [ 行数 ] [ 列数 ]；
2. 数据类型 数组名 [ 行数 ] [ 列数 ] = { {数据1，数据2},{ 数据3，数据4}} ;
3. 数据类型 数组名 [ 行数 ] [ 列数 ] = { 数据1，数据2, 数据3，数据4 } ;
4. 数据类型 数组名 [ ] [ 列数 ] = { 数据1，数据2, 数据3，数据4 } ;
第二种更加直观，提高代码可读性；

3.2 二维数组数组名

• 查看二维数组所占空间
• 获取二维数组首地址

二、函数

1.函数定义

函数的定义一般有5个步骤:

1. 返回值类型
2. 函数名
3. 参数列表
4. 函数体语句
5. return xx

代码如下（示例）：

返回值类型 函数名（int a, int b）
{
	函数体语句；
	return xx;
}

2.函数调用

功能：使用定义好的函数
语法：函数名（参数）

3.常见的样式

1. 无参无返
2. 有参无返
3. 无参有返
4. 有参有返

4.函数的分文件编写

作用:让代码结构更加清晰

函数分文件编写一般有4个步骤:
1.创建后缀名为.h的头文件
2.创建后缀名为.cpp的源文件
3.在头文件中写函数的声明
4.在源文件中写函数的定义

//头文件swap.h
#include<iostream>
using namespace std;

//函数声明
void swap (int a,int b); 

//swap.cpp
#include"swap.h"

//函数的定义 
void swap(int a, int b)
{
	int temp = a;
	a = b;
	b = temp;
	
	cout <<"a=" << a << endl;
	cout <<"b=" << b << endl; 
}

#include<iostream>
#include "swap.h"
using namespace std;


int main()
{
	 
	int a = 10;
	int b = 20;
	swap( a , b); 
	

	return 0;
 } 

5. C++类非静态成员函数后加const的作用

非静态成员函数后面加const，表示成员函数隐含传入的this指针为const指针，在该成员函数中，不能修改所在类中的成员变量
但可以修改有mutable修饰的成员

加到非成员函数或静态成员后面会产生编译错误

三、指针

1.指针的定义和使用

指针变量定义语法：数据类型 * 变量名 ；

代码如下（示例）：

#include<iostream>
using namespace std;

int main()
{
	int a = 10;
	//定义指针
	int* p;
	//给指针赋值
	p = &a;
	cout << p << endl;	//打印数据a的地址(十六进制）
	cout << *p << endl;	//打印数据a的值
	//可以这样定义
	int *p = &a; //等同于 int *p;      p = &a;

	return 0;
}

2.指针所占的内存空间

不管是什么数据类型
32位操作系统下：占用4个字节空间。
64位操作系统下：占用8个字节空间。

	int a = 10;
	//定义指针
	int* p;
	//给指针赋值
	p = &a;
	cout << "sizeof(int *):" << sizeof(p) << endl;  //4

3.空指针和野指针

空指针：指针变量指向内存中编号为0的空间
用途：初始化指针变量
注意：空指针指向的内存是不可以访问的

	//空指针
	int* p = NULL;
	//空指针不能访问，但可以初始化指针变量
	//0~255之间的内存编号是系统占用，因此不可以访问

野指针：指针变量指向非法的内存空间

	//指针变量指向内存地址编号为0x1100的空间
	int* p = (int*)0x1100;
	//访问野指针会报错
	cout << *p << endl;		//: 读取访问权限冲突。
	

总结：空指针和野指针都不是我们申请的空间，因此不能访问。

4.const修饰指针

有三种情况：

1. const修饰指针 —常量指针
2. const修饰常量 —指针常量
3. const既修饰指针，又修饰常量

	int a = 10;
	int b = 20;
	//1.const修饰指针
	//指针指向的值不可以改，指针的指向可以改 
	const int* p1 = &a;
	//则*p1 = 20；是一个错误

	cout << p1 << endl;	//输出的是地址
	cout << *p1 << endl;	//输出的是10

	//2.const修饰常量
	//指针指向的值可以改，指针的指向不可以改
	int* const p2 = &b;
	*p2 = 100;//正确
	p2 = &a;	//错误

	//3.const既修饰指针又修饰常量
	const int* const p3 = &a;
	//指针的指向和指向值都不可以改

5.指针和数组

作用：利用指针访问数组元素

	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
	cout << "数组的第一个元素：" << arr[0] << endl;

	int* p = arr; //arr就是数组的首地址
	cout << "利用指针访问第一个元素：" << *p << endl;

	cout << "利用指针访问第二个元素：" << *(p + 1) << endl;
	// 访问二维数组
	int a[][] = {{1,2,3}, {4,5,6}, {7,8,9} };
	a[0][0] = **a;
	a[0][1] = *(*a + 1);
	a[0][2] = *(*a + 2);
	a[1][0] = **(a+1);
	a[1][1] = *(*(a+1)+1);
	a[1][2] = *(*(a+1)+2);
	a[2][0] = **(a+2);
	a[2][1] = *(*(a+2)+1);
	a[2][2] = *(*(a+2)+2);

6.指针和函数

作用：利用指针做函数参数，可以修改实参的值

#include<iostream>
using namespace std;
 
 //值传递
void swap1(int a, int b)
{
	int temp = a;
	a = b;
	b = temp;
}
//地址传递
void swap2(int* p1, int* p2)
{
	int temp = *p1;
	*p1 = *p2;
	*p2 = temp;
}

int main()
{
	int a = 10;
	int b = 20;
	swap1(a, b);	//值传递不会改变实参
	cout << a << endl;	//10
	cout << b << endl;	//20
	swap2(&a, &b);	//地址传递会改变实参
	cout << a << endl;	//20
	cout << b << endl;	//10
	return 0;
}

总结：如果不想改变实参，就用值传递，如果想改变实参，就用地址传递