C++基础语法——数组、函数、指针和结构体

本专栏记录C++学习过程包括C++基础以及数据结构和算法，其中第一部分计划时间一个月，主要跟着黑马视频教程，学习路线如下，不定时更新，欢迎关注。
当前章节处于：
====>第1阶段-C++基础入门
---------第2阶段实战-通讯录管理系统，
---------第3阶段-C++核心编程，
---------第4阶段实战-基于多态的企业职工系统
---------第5阶段-C++提高编程
---------第6阶段实战-基于STL泛化编程的演讲比赛
---------第7阶段-C++实战项目机房预约管理系统

文章目录

1.数组
- 1.1 一维数组
- 1.2 二维数组
2.函数
- 2.1 基本形式
- 2.2值传递
- 2.3函数的声明
- 2.4 函数分文件编写
3.指针
- 3.1 指针的基本使用
- 3.2 空指针
- 3.3 野指针
- 3.4 const修饰指针
- 3.5 指针和数组
- 3.6 指针和函数
4. 结构体
- 4.1 结构体的基本使用
- 4.2 结构体数组
- 4.3 结构体指针
- 4.4 结构体嵌套结构体
- 4.5 结构体做函数参数
- 4.6 结构体const的应用

1.数组

数组即为一个集合，里面存放的是相同类型的数据元素

数组中的每个数据元素都是相同的数据类型
数组是由连续的内存位置组成的,索引从0开始

1.1 一维数组

定义方式:
定义时，必须要指定长度或者给定元素

数据类型数据名[数组长度]
数组类型数组名[数组长度] ={值1，值2，值3}
数据类型数组名[ ] = {值1，值2，值3}
遍历数组方式-for循环遍历，举例代码如下：

#include <iostream>
using namespace std;


int main() {
	int array[5] = { 10,20,30,40 };  // 如果值没给满，则用0补充
	for (int i = 0; i < 5; i++) {
		cout << array[i] << " ";
	}
	system("pause");
	return 0;

}

10 20 30 40 0 请按任意键继续. . .

一维数组名可以统计整个数组在内存中的长度，并且可以获取数组在内存中的首地址

#include <iostream>
using namespace std;


int main() {
	int array[5] = { 10,20,30,40 };  // 如果值没给满，则用0补充
	// 统计元素个数
	cout <<"元素个数为：" << sizeof(array) / sizeof(array[0]) << endl;
	for (int i = 0; i < 5; i++) {
		cout << array[i] << " ";
	}
	cout << endl;
	cout << "首地址为" << (int)array << endl;
	cout << "第二个元素地址为" << (int) & array[1] << endl;
	system("pause");
	return 0;

}

元素个数为：5
10 20 30 40 0
首地址为-571081624
第二个元素地址为-571081620
请按任意键继续. . .

数组首地址在指针学习时将会反复被使用，因此在这里需要理解数组名的含义，用途有两个：获取数组长度和数组首地址。其中，&为取址符号。第二个元素地址为第一个元素地址+4。

案例一小猪称体重：
在一个数组中记录了五只小猪的体重，找到并打印最重的小猪体重。

#include <iostream>
using namespace std;


int main() {
	int array[5] = { 100,200,30,50,300 };
	int length = sizeof(array) / sizeof(array[0]);
	int maxweight = 0;
	for (int i = 0; i < length; i++) {
		if (array[i] > maxweight) {
			maxweight = array[i];
		}
	}
	cout << "最重小猪体重为:" << maxweight << endl;
	system("pause");
	return 0;

}

最重小猪体重为:300
请按任意键继续. . .

用maxweight不断接收最大值，并进行下一步判断。
案例2：数组元素逆置
声明一个5个元素的数组，并且将元素逆置

#include <iostream>
using namespace std;


int main() {
	int array[5] = { 1,2,3,4,5 };
	int length = sizeof(array) / sizeof(array[0]);
	int temp = 0;
	for (int i = 0; i < length/2; i++) {
		// 进行逆置
		temp = array[i];
		array[i] = array[length - i - 1];
		array[length - i - 1] = temp;
	}
	for (int j = 0; j < length; j++) {
		cout << array[j] << " ";
	}
	cout << endl;
	system("pause");
	return 0;

}

5 4 3 2 1
请按任意键继续. . .

案例3 冒泡排序
最常用的排序算法，对数组内元素进行排序

比较相邻的元素，如果第一个比第二个大，就交换它们
对每一对相邻的元素做相同的工作，执行完毕后，找到第一个最大值。
重复以上的步骤，每次比较次数-1，直到不需要比较

#include <iostream>
using namespace std;


int main() {
	int array[9] = { 4,2,8,0,5,7,1,3,9 };
	int length = sizeof(array) / sizeof(array[0]);
	// 冒泡排序
	int temp = 0;
	for (int i = 0; i < length - 1; i++) {
		for (int j = 0; j < length -i- 1; j++) {
			if (array[j] > array[j + 1]) {
				temp = array[j];
				array[j] = array[j + 1];
				array[j + 1] = temp;
			}
		}
	}

	for (int k = 0; k < length; k++) {
		cout << array[k] << " ";
	}
	cout << endl;
	system("pause");
	return 0;

}

0 1 2 3 4 5 7 8 9
请按任意键继续. . .

先写内层循环再写外层循环。

1.2 二维数组

定义方式：

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

第二种可读性更强，建议使用第二种。访问时同样使用索引进行访问，从结果也可以看出，如果想遍历的话，需要通过嵌套循环进行遍历。
在这里插入图片描述

#include <iostream>
using namespace std;


int main() {
	int array[2][3] = { {1,2,3},{4,5,6} };  // 两行三列
	for (int i = 0; i < 2; i++) {
		for (int j = 0; j < 3; j++) {
			cout << array[i][j] << " ";
		}
		cout << endl;
	}
	system("pause");
	return 0;

}

1 2 3
4 5 6
请按任意键继续. . .

二维数组数组名
类似于一维数组名的作用，主要包括两个方面：

查看二维数组所占空间
获取二维数组首地址
在这里不进行代码举例

2.函数

2.1 基本形式

将一段封装起来，减少重复代码，如果一个程序较大，一般分为若干个模块，每个模块实现特定的功能。
函数定义一般主要有5个步骤

返回值类型
函数名
参数表列
函数体语句
return表达式

返回值类型函数名（参数列表）
{
函数体语句;
return 表达式:
}
参数列表中的为形参，真实传入的值为实参。

#include <iostream>
using namespace std;
int add(int num1, int num2) {
	return num1 + num2;
}

int main() {
	cout<<add(1,3)<<endl;	
	system("pause");
	return 0;

}

2.2值传递

做值传递的时候，函数的形参发生改变，并不会影响实参
常见的函数样式

无参无返
无参有返
有参有返
有参无返

2.3函数的声明

告诉编译器函数名称以及如何调用函数。函数的实际实体可以单独定义。

#include <iostream>
using namespace std;
int max(int num1, int num2); // 申明函数


int main() {
	cout << max(2, 4) << endl;
	system("pause");
	return 0;

}
int max(int num1, int num2) {
	return num1 > num2 ? num1 : num2;
}

代码从上往下一行行执行，防止定义的函数在main之后，所以需要提前申明，让编译器知道有这个函数。

2.4 函数分文件编写

为了让代码结构更加清晰，函数需要分文件编写，编写主要有下面4个步骤

创建后缀为.h的头文件
创建后缀为.cpp的源文件
在头文件中写函数的声明
在源文件中写函数的定义

getMax.h

#include <iostream>
using namespace std;
int getMax(int num1, int num2);

getMax.cpp

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


int getMax(int num1,int num2) {
	return num1 > num2 ? num1 : num2;
}

08 函数分文件编写.cpp(main)

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


int main() {
	cout << getMax(3, 5) << endl;
	system("pause");
	return 0;

}

3.指针

可以通过指针间接访问内存，内存编号从0开始记录，一般是十六进制数字表示，可以利用指针变量保存地址，指针——记录地址编号
数据类型 * 指针变量名

3.1 指针的基本使用

#include <iostream>
using namespace std;


int main() {
	int a = 10;
	int* p = &a; // 创建指针
	cout << p << endl; // a的地址
	cout << *p << endl; // a的值
	cout << sizeof(int*) << endl;
	system("pause");
	return 0;

}

000000CC9173F504
10
8
请按任意键继续. . .

不同类型的指针在32为操作系统都占用4个字节，在64位操作系统都占用8个字节

3.2 空指针

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

#include <iostream>
using namespace std;


int main() {
	int* p = NULL;
	cout << p << endl;
	cout << *p << endl;
	system("pause");
	return 0;

}

发生报错，引发了异常: 读取访问权限冲突。p 是 nullptr。0-255之间的内存编号是系统占用的，因此不能进行访问。

3.3 野指针

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

#include <iostream>
using namespace std;


int main() {
	int* p = (int*)0x1100;
	//cout << *p << endl;
	system("pause");
	return 0;

}

报错：原因就是内存空间还没申请就直接操作，没有权限。

引发了异常: 读取访问权限冲突。
p 是 0x1100。

3.4 const修饰指针

const修饰指针有三种情况：

const修饰指针：常量指针
const修饰常量：指针常量
const即修饰指针又修饰常量

常量指针：指针的指向可以修改，但是指针指向的值不可以修改
const int * p =&a
指针常量:指针的指向不可以修改，但是指针指向的值可以改
int * const p = &a
既修饰指针又修饰常量：都不可以改
const int * const p = &a

#include <iostream>
using namespace std;


int main() {
	int a = 10;
	int b = 20;
	/*
	const int* p = &a;
	p = b; // 报错
	p = &b; // 不报错
	*/
	int* const p = &a;
	//p = &b; // 报错
	*p = b;  // 不报错
	system("pause");
	return 0;

}

3.5 指针和数组

利用p++不断修改指针所指内容，即可达到利用指针访问数组中的元素目的

#include <iostream>
using namespace std;


int main() {
	int array[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int length = sizeof(array) / sizeof(array[0]);
	int* p = array;
	for (int i = 0; i < length; i++) {
		cout << *p << " ";
		p++;
	}
	cout << endl;
	system("pause");
	return 0;

}

3.6 指针和函数

地址传递会改变实参的数据：

#include <iostream>
using namespace std;
void swap(int* p1, int* p2) {
	int temp = *p1;
	*p1 = *p2;
	*p2 = temp;
}

int main() {
	int a = 10;
	int b = 20;
	int* pa = &a;
	int* pb = &b;
	swap(pa, pb);
	cout << "a= " << a<<endl;
	cout << "b= " << b<<endl;
	system("pause");
	return 0;

}

a= 20
b= 10
请按任意键继续. . .

案例一：封装一个函数，利用冒泡排序，实现对整型数组的升序排序

#include <iostream>
using namespace std;

void bu(int * arr,int length) {
	for (int i = 0; i < length - 1; i++) {
		for (int j = 0; j < length - i - 1; j++) {
			if(arr[j] > arr[j+1]) {
				int temp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = temp;
			}
		}
	}
}

int main() {
	int array[10] = { 1,3,4,5,6,2,9,8,7,0 };
	int length = sizeof(array) / sizeof(array[0]);
	for (int i=0;i<length;i++){
		cout << array[i] << " ";
	}
	cout << endl;
	int* p = array;
	bu(p,length);
	for (int i = 0; i < length; i++) {
		cout << array[i] << " ";
	}
	system("pause");
	return 0;

}

1 3 4 5 6 2 9 8 7 0
0 1 2 3 4 5 6 7 8 9 请按任意键继续. . .

4. 结构体

结构体属于用户自定义的数据类型，允许用户存储不同的数据类型
语法： struct 结构体名{结构体成员列表}
代码实例：

4.1 结构体的基本使用

#include <iostream>
using namespace std;

struct Student
{
	string name;
	int age;
	long long phone;
}s3;


int main() {
	// 创建方式一
	struct Student s1;// struct可以省略
	s1.name = "张三";
	s1.age = 12;
	s1.phone = 12345;
	cout << s1.name<<" " << s1.age<<" " << s1.phone << endl;
	// 创建方式二
	struct Student s2 = {"李四",13,145678};
	cout << s2.name << " " << s2.age << " " << s2.phone << endl;
	// 创建方式三
	// 在创建结构体时就创建一个结构体变量
	s3.name = "李华";
	system("pause");
	return 0;

}

张三 12 12345
李四 13 145678
请按任意键继续. . .

4.2 结构体数组

类似于整数数组的定义，具体看定义和更改的代码：

#include <iostream>
using namespace std;
struct Student
{
	string name;
	int age;
	long long phone;
};

int main() {
	// 定义
	Student studentArr[3] = {
		{"张三",34,122334,},
		{"李四",24,122334,},
		{"王五",14,122334,}
	};
	// 更改
	cout <<"更改前：" << studentArr[0].age << endl;
	studentArr[0].age = 12;
	cout <<"更改后：" <<studentArr[0].age << endl;
	// 遍历
	int length = sizeof(studentArr) / sizeof(studentArr[0]);
	for (int i = 0; i < length; i++) {
		cout << "name: " << studentArr[i].name << "  age:  " << studentArr[i].age << "  phone:  " << studentArr[i].phone << endl;
	}
	system("pause");
	return 0;

}

更改前：34
更改后：12
name: 张三  age:  12  phone:  122334
name: 李四  age:  24  phone:  122334
name: 王五  age:  14  phone:  122334
请按任意键继续. . .

4.3 结构体指针

利用操作符->可以通过结构体指针访问结构体属性

#include <iostream>
using namespace std;
struct Student
{
	string name;
	int age;
	long long phone;
};


int main() {
	struct Student s1 = { "张三",12,123344 };
	struct Student* p = &s1;
	cout << "name: " << p->name << "  age:  " << p->age << "  phone:  " << p->phone << endl;
	system("pause");
	return 0;

}

name: 张三  age:  12  phone:  123344
请按任意键继续. . .

4.4 结构体嵌套结构体

在一个结构体中引用另一个结构体作为子结构体，在调用时只需.即可

#include <iostream>
using namespace std;
struct Student
{
	string name;
	int age;
};

struct Teacher
{
	string name;
	int age;
	struct Student stu; // 嵌套另一个结构体
};

int main() {
	struct Teacher tea1;
	tea1.name = "li";
	tea1.age = 33;
	tea1.stu.name = "zhang";
	tea1.stu.age = 21;
	cout << tea1.name << "  " << tea1.age << "  " << tea1.stu.name << "  " << tea1.stu.age << endl;
	system("pause");
	return 0;

}

li  33  zhang  21
请按任意键继续. . .

4.5 结构体做函数参数

一共有两种方式，为值传递和地址传递，值传递不会改变实参，而地址传递会改变实参，接下来用一段代码进行辨析：

#include <iostream>
using namespace std;
struct Student
{
	string name;
	int age;
};
// 值传递
void printStruct(struct Student stu) {
	cout << "姓名为:" << stu.name <<"   年龄为:" << stu.age << endl;
	stu.name = "李四"; // 不会影响实参
}
// 地址传递
void printStructp(struct Student* p) {
	cout << "姓名为:" << p->name << "   年龄为:" << p->age << endl;
	p->name = "李四"; // 不会影响实参
}
int main() {
	// 创建一个结构体
	struct Student stu = { "张三",13 };

	// 1.值传递
	cout << "值传递更改前姓名为:" << stu.name << endl;
	printStruct(stu);
	cout << "值传递更改后姓名为:" << stu.name << endl;
	//2.地址传递
	struct Student* p = &stu;
	cout << "地址传递更改前姓名为:" << p->name<< endl;
	printStructp(p);
	cout << "地址传递更改后姓名为:" << p->name << endl;
	system("pause");
	return 0;

}

值传递更改前姓名为:张三
姓名为:张三   年龄为:13
值传递更改后姓名为:张三
地址传递更改前姓名为:张三
姓名为:张三   年龄为:13
地址传递更改后姓名为:李四
请按任意键继续. . .

可以看到值传递不会更改实参的值，而地址传递会更改实参的值。

4.6 结构体const的应用

防止误操作，针对于地址传递的时候，防止出现误操作导致结构体原来的值改变。

#include <iostream>
using namespace std;

struct Student
{
	string name;
	int age;
};
void printStructp(const struct Student* p) {
	cout << "姓名为:" << p->name << "   年龄为:" << p->age << endl;
	//p->name = "李四"; // 会报错 因为const限制不能更改原属性
}
int main() {
	struct Student stu = { "张三",13 };
	struct Student* p = &stu;
	printStructp(p);
	system("pause");
	return 0;

}

姓名为:张三   年龄为:13
请按任意键继续. . .

案例一
学校正在做毕设项目，每名老师带领5个学生，总共有3名老师,-需求如下：
设计学生和老师的结构体，其中在老师的结构体中，有老师姓名和一个存放5名学生的数组作为成员学生的成员有姓名、考试分数，创建数组存放3名老师，通过函数给每个老师及所带的学生赋值最终打印出老师数据以及老师所带的学生数据。

#include <iostream>
using namespace std;
struct Student
{
	string name;
	int score;
};
struct Teacher
{
	string name;
	struct Student stu[5];
};
void addVaule(struct Teacher *p) {
	p[0].name = "王";
	p[0].stu[0] = { "李" ,65 };
	p[0].stu[1] = { "赵" ,95 };
	p[0].stu[2] = { "康" ,85 };
	p[0].stu[3] = { "康" ,85 };
	p[0].stu[4] = { "康" ,85 };
	p[1].name = "王";
	p[1].stu[0] = { "李" ,65 };
	p[1].stu[1] = { "赵" ,95 };
	p[1].stu[2] = { "康" ,85 };
	p[1].stu[3] = { "康" ,85 };
	p[1].stu[4] = { "康" ,85 };
	p[2].name = "王";
	p[2].stu[0] = { "李" ,65 };
	p[2].stu[1] = { "赵" ,95 };
	p[2].stu[2] = { "康" ,85 };
	p[2].stu[3] = { "康" ,85 };
	p[2].stu[4] = { "康" ,85 };

}
void printStru(const struct Teacher* p) {
	for (int i = 0; i < 3; i++) {
		cout<<"老师姓名："<<p[i].name<<endl;
		for (int j = 0; j < 5; j++) {
			cout << "  所带学生姓名:" << p[i].stu[j].name<<"   分数"<< p[i].stu[j].score <<endl;
		}
	}
}
int main() {
	struct Teacher teacher[3];
	struct Teacher* p = teacher;
	addVaule(p);
	printStru(p);
	system("pause");
	return 0;

}

老师姓名：王
  所带学生姓名:李   分数65
  所带学生姓名:赵   分数95
  所带学生姓名:康   分数85
  所带学生姓名:康   分数85
  所带学生姓名:康   分数85
老师姓名：王
  所带学生姓名:李   分数65
  所带学生姓名:赵   分数95
  所带学生姓名:康   分数85
  所带学生姓名:康   分数85
  所带学生姓名:康   分数85
老师姓名：王
  所带学生姓名:李   分数65
  所带学生姓名:赵   分数95
  所带学生姓名:康   分数85
  所带学生姓名:康   分数85
  所带学生姓名:康   分数85
请按任意键继续. . .

案例二
设计一个英雄的结构体，包括成员姓名，年龄。性别;创建结构体数组，数组中存放5名英雄。通过冒泡排序的算法，将数组中的英雄按照年龄进行升序排序，最终打印排序后的结果。

#include <iostream>
using namespace std;
struct hero
{
	string name;
	int age;
	string sex;
};
void printArr(const struct hero heroarr[],int len) {
	for (int i = 0; i < len; i++) {
		cout << "姓名：" << heroarr[i].name << "  年龄:" << heroarr[i].age << "  性别:" << heroarr[i].sex <<" "<< endl;
	}
}
void bu(struct hero heroarr[], int len) {
	for (int i = 0; i < len-1; i++) {
		for (int j = 0; j < len - i - 1; j++) {
			// 比较和交换
			if (heroarr[j].age > heroarr[j + 1].age) {
				struct hero temp= heroarr[j];
				heroarr[j] = heroarr[j + 1];
				heroarr[j + 1] = temp;
			}

		}
	}
}
int main() {
	struct hero heroarr[5] = {
		{"刘备", 23,"男"},
		{"关羽" ,22,"男"},
		{"张飞",20,"男"},
		{"赵云" ,21,"男"},
		{"貂蝉",19,"女"}
	};
	cout << "冒泡排序前：" << endl;
	int len = sizeof(heroarr) / sizeof(heroarr[0]);
	printArr(heroarr,len);
	cout << "冒泡排序后：" << endl;
	bu(heroarr, len);
	printArr(heroarr, len);
	system("pause");
	return 0;

}

冒泡排序前：
姓名：刘备  年龄:23  性别:男
姓名：关羽  年龄:22  性别:男
姓名：张飞  年龄:20  性别:男
姓名：赵云  年龄:21  性别:男
姓名：貂蝉  年龄:19  性别:女
冒泡排序后：
姓名：貂蝉  年龄:19  性别:女
姓名：张飞  年龄:20  性别:男
姓名：赵云  年龄:21  性别:男
姓名：关羽  年龄:22  性别:男
姓名：刘备  年龄:23  性别:男
请按任意键继续. . .