C++初学篇3（黑马程序员教程）

5. 数组

5.1 概述

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

特点1：数组中的每个数据元素都是相同的数据类型

特点2：数组是由连续的内存位置组成的

5.2 一维数组

5.2.1 以为数组定义的三种方式

一维数组定义的三种方式：

1.数据类型 数组名 [数组长度];

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

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

示例：

int main()
{

	int a[6];
	for (int i = 0; i < size(a); i++) {
		a[i] = i;
		
	}
	for (int i = 0; i < size(a); i++) {
		cout << "a[" << i << "]= " << a[i] <<"\t" ;
	}
	cout << endl;
	int b[5] = {1,2,3,4,5};
	for (int i = 0; i < size(b); i++) {
		cout << "b[" << i << "]=" << b[i] << "\t";
	}
	cout << "\n";

	int c[] = { 1,2,3,4,5,6 };
	for (int i = 0; i < size(c); i++) {
		cout << "c[" << i << "]=" <<c[i]<< "\t";
	}
	cout << "\n";

	system("pause");

	return 0;
}

注意：索引是从0开始的，没有初始化的值是0。

5.2.2 一维数组数组名

一维数组名称的作用：

1. 可以统计数组在内存中的长度

2.可以回去数组在内存中的首地址

示例：

int arr[10]={1,2,3,4,5,6,7,8,9,10};

cout<<"整个数组占用内存空间为："<<sizeof(arr)<<endl;

cout<<"内存地址为："<<arr<<endl;

5.3 二维数组

二维数组就是在一维数组上，多加一个维度。

5.3.1 二维数组定义方式

二维数组定义的四种方式：

        1. 数据类型 数组名 [ 行数 ] [ 列数 ]；

        2. 数据类型 数组名 [ 行数 ] [ 列数 ] = { {数据1，数据2}，{数据3，数据4} }；

        3. 数据类型 数组名 [ 行数 ] [ 列数 ] = { 数据1，数据2，数据3，数据4 }；

        4. 数据类型 数组名 [ ] [ 列数 ] = { 数据1，数据2，数据3，数据4 }；

示例：

int main()
{
//定义方式1：
	int arr[2][3];
	arr[0][0] = 0;
	arr[0][1] = 1;
	arr[0][2] = 2;
	arr[1][0] = 3;
	arr[1][1] = 4;
	arr[1][2] = 5;
	//定义方式2：
	int arr[2][3] =
	{
		{0,2,3},
		{4,5,6}
	};

	//定义方式3：
	int arr[2][3] = {0,1,2,3,4,5};

	//定义方式4：必须给定列数
	int arr [][3] = {0,1,2,3,4,5};
	

	system("pause");

	return 0;
}

6.函数

6.1 概述

作用：将一段经常使用的代码封装起来，减少代码重复使用

一个较大的程序，一般分为若干个程序块，每个模块实现特定的功能。

6.2 函数的定义

函数的定义一般主要有5个步骤：

1. 返回值类型

2.函数名

3.参数列表

4.函数体语句

5.return 表达式

语法：

返回值类型 函数名 （参数列表）

{

        函数体语句；

        return 表达式；

}

#include <iostream>
using namespace std;

//常量的定义方式
//1. #define 宏常量
//2. const修饰的变量

//1. #define 宏常量
#define Day 7

int add(int num1,int num2)
{
	int sum = num1 + num2;
	return sum;
}

int main()
{

	
	int a=add(3, 4);
	system("pause");

	return 0;
}

6.3 值传递

所谓值传递，就是函数调用时实参将数值传入给形参

值传递时，如果形参发生，并不会影响实参

int swap(int num1,int num2)
{
	cout << "交换前" << endl;
	cout << "num1 ="<<num1 << endl;
	cout << "num2 =" << num2 << endl;

	int temp = num1;
	num1 = num2;
	num2 = temp;

	cout << "交换后：" << endl;
	cout << "num1 =" << num1 << endl;
	cout << "num2 =" << num2 << endl;
}

int main()
{

	int a = 3;
	int b = 4;
	int a=swap(a, b);
	cout << "a =" << a << endl;
	cout << "b =" << b << endl;
	//a=3,b=4 形参发生变化，实参不会发生变化
	system("pause");

	return 0;
}

6.4 函数的声明

如果函数写在main函数之前是可以正常运行，但如果函数写在main函数之后，就需要在main函数之前对该函数进行声明

格式：

返回值 函数名（参数类型 参数）；

示例：

#include <iostream>
using namespace std;

#define Day 7

void swap(int num1,int num2);

int main()
{

	int a = 3;
	int b = 4;
	swap(a, b);
	cout << "a =" << a << endl;
	cout << "b =" << b << endl;
	//a=3,b=4 形参发生变化，实参不会发生变化
	system("pause");

	return 0;
}
void swap(int num1, int num2)
{
	cout << "交换前" << endl;
	cout << "num1 =" << num1 << endl;
	cout << "num2 =" << num2 << endl;

	int temp = num1;
	num1 = num2;
	num2 = temp;

	cout << "交换后：" << endl;
	cout << "num1 =" << num1 << endl;
	cout << "num2 =" << num2 << endl;
}

注意：声明可以有多次，但是定义只有一次

6.5 函数的分文件编写

作用：让代码结构更清晰

函数分文件编写一般分为4个步骤：

1. 创建后缀名为.h的头文件，头文件里要加#include <iostream>  using namespace std;

2. 创建后缀名为.cpp的文件，写函数方法，并且开头要写  #include ”头文件.h“

3. 在头文件中写函数的声明

4.在源文件中写函数的定义

5. 在需要用到该头文件的源文件上方加上 #include ”头文件名.h“

示例：

头文件：

#include <iostream>
#pragma once
using namespace std;

void swap(int a,int b);

源文件（定义函数方法）：

#include "swap.h"

void swap(int a,int b)
{
	int temp;
	temp = a;
	a = b;
	b = temp;
	cout<<"交换后：a="<<a << endl;
	cout << "交换后：b=" << b << endl;
}

用到该头文件函数方法的源文件：

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



int main()
{

	int a = 3;
	int b = 4;
	swap(a, b);
	cout << "a =" << a << endl;
	cout << "b =" << b << endl;
	//a=3,b=4 形参发生变化，实参不会发生变化
	system("pause");

	return 0;
}

7.指针

7.1 指针的基本概念

指针的作用：可以通过指针间接访问内存

内存编号是从0开始记录的，一般用十六进制数字表示

可以利用指针变量保存地址

7.2 指针变量的定义和使用

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

示例：

int a = 3;
	//定义指针
	int* p;
	//让指针记录变量a的地址
	p = &a;
	cout<<"a的地址为："<< &a << endl;
	cout << "p为：" << p << endl;
	cout << "a=：" << a << endl;
	cout << "a=：" << *p << endl;
	//* 指针为解引用，通过指针可以访问到变量所指向的值

7.3 空指针和野指针

空指针：指针变量指向内存中编号为0的空间

用途：初始化指针变量

注意：空指针指向的内存是不可以访问的

示例：

//1.空指针用于给指针变量进行初始化

int *p =NULL;

//2.空指针是不可以进行访问的，否则会报错

*p=100;      //此程序会报错

野指针：指针变量指向非法变量

示例2：野指针

int main()
{

	//指针变量P指向内存编号为0x1100的空间
	int* p = (int*)0x1100;
	//访问野指针报错
	cout << *p << endl;

	system("pause");

	return 0;
}

7.4 const修饰指针

三种情况：

1.const修饰指针————常量指针

2.const修饰常量————指针常量

3. const即修饰指针，又修饰常量

int a = 10;
	int b = 10;
	//const修饰的是指针，指针指向可以改，指针指向的值不可以改
	const int* p = &a;
	p = &b;//正确
	//*p = 100;   //报错

	//const修饰的是变量名，指针指向不可更改，指针指向的值可以更改
	int* const p2 = &a;
	//p2=&a;//错误

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

7.5 指针和数组

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

示例：

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

	int* p=arr;
	cout<<"利用指针访问第一个元素：" <<*p<< endl;
	p++;
	cout << "利用指针访问第二个元素：" << *p << endl;
	p++;
	cout << "利用指针访问第三个元素：" << *p << endl;
	p++;
	cout << "利用指针访问第四个元素：" << *p << endl;
	int* p2 = arr;
	for (int i = 0; i < 10; i++) {
		cout<<*p2<<endl;
		p2++;
	}

7.6 指针和函数

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

示例：

//值传递
void swap3(int a, int b) {
	int temp = a;
	a = b;
	b = temp;
}
//地址传递
void swap4(int* p1,int* p2) {
	int temp = *p1;
	*p1 = *p2;
	*p2 = temp;
}