【C++基础篇】—— 基本语法（数组、函数、指针、结构体等使用语法和注意事项详解）

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

---

前言

在本篇文章中，主要是对C++的基础语法进行回顾学习，回顾学习C++的基本语法规则、数据类型、控制结构以及面向对象编程的基本思想。

一、数组

1.数组基本语法

一维数组基本语法，定义方式：
1.数据类型数组名[数组长度];
2.数据类型数组名[数组长度]={值1，值2…};
3. 数据类型数组名[]={值1，值2…};
示例：

int score[4];    //方式1
int score[4] = {100,90,80,10};   //方式2
int score[] = {100,90,80}     //方式3

注意事项：
1.数组名的命名规范与变量名命名规范一致，不要和变量重名
2.数组中下标是从0开始索引

二维数组基本语法，定义方式：
1.数据类型数组名[行数][列数];
2.数据类型数组名[行数][列数]={{数据1，数据2}，{数据3，数据4}};
3.数据类型数组名[行数][列数]={数据1，数据2，数据3，数据4};
4.数据类型数组名[][列数]={数据1，数据2，数据3，数据4};
示例：

int arr [2][3] = {{1,2,3},{4,5,6}}；   // 方式2
int arr [2][3] = {1,2,3,4,5,6};          //方式3
int arr [][3] = {1,2,3,4,5,6};            //方式4

数组的数组名

2.数组名含义

数组名就是这个数组的首地址；
对数组名进行sizeof时，可以获取整个数组占用的内存空间大小
示例：

int arr [2][3] = {{1,2,3},{4,5,6}}；
// 地址
cout << "二维数组第一个元素地址：" << &arr[0][0] << endl;
cout << "二维数组首地址：" << arr << endl;
cout << "二维数组第一行地址："<< arr[0] << endl;
cout << "二维数组第二行地址：" << arr[1] << endl;
//内存空间大小
cout << "二维数组大小："<< sizeof(arr) << endl;
cout << "二维数组一行大小："<< sizeof(arr[0]) << endl;
cout << "二维数组元素大小："<< sizeof(arr[0][0]) << endl;

二、函数

1.函数定义

作用：
将一段经常使用的代码封装起来，减少重复代码一个较大的程序，一般分为若干个程序块，每个模块实现特定的功能。
定义，函数的定义一般主要有5个步骤：
1、返回值类型：一个函数可以返回一个值。在函数定义中
2、函数名：给函数起个名称
3、参数表列：使用该函数时，传入的数据
4、函数体语句：花括号内的代码，函数内需要执行的语句
5、return 表达式：和返回值类型挂钩，函数执行完后，返回相应的数据
示例：

// 定义一个加法函数，实现两个数相加
int add(int a,int b)
{
	int sum = a + b;
	return sum;
}

2.函数的使用

(1) 函数的声明：
作用：告诉编译器函数名称及如何调用函数。函数的实际主体可以单独定义，函数的声明可以多次，但是函数的定义只能有一次
示例：

//声明可以多次，定义只能一次//声明
int add(int a,int b);
int add(int a,int b);
//定义
int add(int a,int b)
{
	int sum = a + b;
	return sum;
}

函数的分文件编写:
作用：让代码结构更加清晰，函数分文件编写一般有4个步骤：
1.创建后缀名为.h的头文件
2.创建后缀名为.cpp的源文件
3.在头文件中写函数的声明
4.在源文件中写函数的定义
(2) 函数的调用：
定义好函数之后，在主函数或者其他函数调用即可
示例：

int main()
{
	int a = 10;
	int b = 10;
	//调用add函数
	int sum = add(a,b);//调用时的a，b称为实际参数，简称实参
	cou t<< "sum = "<< sum << endl;
	return 0;
}

(3) 参数传递：
值传递：
所谓值传递，就是函数调用时实参将数值传入给形参,值传递时，如果形参发生改变，并不会影响实参

地址传递：
传入实参的地址，当对形参数据进行修改时，实参也会发生改变（后面结构体和指针会详细介绍）

三、指针

1. 指针基本概念与使用

作用：可以通过指针间接访问内存，可以利用指针变量保存地址；内存编号是从0开始记录的，一般用十六进制数字表示

(1) 指针基本用法：
指针变量定义语法：数据类型*变量名；
示例：

int main() 
{
	//1、指针的定义
	int a = 10;//定义整型变量a
	//指针定义语法：数据类型*变量名;
	int * p;
	//指针变量赋值
	p = &a;     //指针指向变量a的地址
	cout << p << endl;  //打印指针变量p
	//通过*操作指针变量指向的内存
	cout << " *p= " << *p << endl;
	return 0;
}

指针变量和普通变量的区别:
a. 普通变量存放的是数据,指针变量存放的是地址
b. 指针变量可以通过" * "操作符，操作指针变量指向的内存空间，这个过程称为解引用

指针所占内存空间:
提问：指针也是种数据类型，那么这种数据类型占用多少内存空间？
所有指针类型在32位操作系统下是4个字节（可以使用 sizeof 打印验证一下）

(2) const修饰指针：

const修饰指针有三种情况：
1.常量指针：const修饰指针，指针指向可以改，指针指向的值不可以更改。
示例：

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

2.指针常量：const修饰常量，指针指向不可以改，指针指向的值可以更改
示例：

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

3.const即修饰指针，又修饰常量：指针的指向和指向的值不可以修改
示例：

const int * const p3 = &a;
//p3 = &b;//错误
//*p3 = 100;//错误

(3) 指针与数组：
用途：利用指针访问数组中元素
示例：

int main() 
{
	int arr[] = {1,2,3,4,5,6,7,8,9,10};
	int * p = arr; //指向数组的指针
	cout << "第一个元素：" << arr[0] << endl;
	cout << "指针访问第一个元素：" << *p << endl;
	for(int i = 0; i < 10; i++)
	{
		//利用指针遍历数组
		cout << *p << endl;
		p++;
	}
	system("pause");
	return 0;
}

(4) 指针与函数：
用途：利用指针作函数参数，可以修改实参的值（地址传递）
示例：

//地址传递
void swap2 (int * p1, int * p2)
{
	int temp = *p1;
	*p1 = *p2;
	*p2 = temp;
}
int main()
{
	int a =10;
	int b = 20;
	swap2(&a, &b);//地址传递会改变实参
	system("pause");
	return 0;
}

2. 空指针与野指针

(1) 空指针
定义：指针变量指向内存中编号为0的空间
用途：初始化指针变量
注意事项：空指针指向的内存是不可以访问的
示例：

int main() 
{
	//指针变量p指向内存地址编号为0的空间
	int * p = NULL;
	//内存编号0~255为系统占用内存，不允许用户访问
	cout << *p << endl;      //会出现访问空指针报错 
	return 0;
}

(2) 野指针
定义：指针变量指向非法的内存空间
注意：空指针和野指针都不是我们申请的空间，因此不要访问（后面会详细介绍出现野指针的情况）

四、结构体

1. 结构体基本概念与定义

基本概念：结构体属于用户自定义的数据类型，允许用户存储不同的数据类型
语法：struct结构体名{结构体成员列表}；通过结构体创建变量的方式有三种：
方式一. struct 结构体名变量名
方式二. struct 结构体名变量名 = { 成员1值，成员2值…}
方式三. 定义结构体时顺便创建变量
示例：

//结构体变量创建方式1
struct chen ch1;//struct关键字可以省略
//结构体变量创建方式2
struct chen stu2={"张三",18,90};
//结构体定义
struct chen
 {
	//成员列表
	string name; //姓名
	int age;   //年龄
	int score;  //分数
}ch3;//结构体变量创建方式3

2. 结构体的使用

(1) 结构体数组
作用：将自定义的结构体放入到数组中方便维护
语法：struct结构体名数组名[元素个数] = { {}, {}, … {}}
示例：

//结构体定义
struct student
 {
	//成员列表
	string name; //姓名
	int age;   //年龄
	int score;  //分数
};
int main()
{
	//结构体数组
	structstudentarr[3]=
	{
		{"张三",18,80},
		{"李四",19,60},
		{"王五",20,70}
	};
	return 0;
}

(2) 结构体指针
作用：通过指针访问结构体中的成员 。利用操作符->可以通过结构体指针访问结构体属性
示例：

//结构体定义
struct student
 {
	//成员列表
	string name; //姓名
	int age;   //年龄
	int score;  //分数
	};
int main()
{
	struct studen tstu = { "张三", 18, 100};
	struct student *p = &stu;
	p->score = 80;   //指针通过->操作符可以访问成员
    cout << "姓名：" << p->name << "年龄：" << p->age << "分数：" << p->score << endl;
	return 0;
}

(3) 结构体嵌套结构体
作用：结构体中的成员可以是另一个结构体
例如：每个老师辅导一个学员，一个老师的结构体中，记录一个学生的结构体
示例：

//结构体定义
struct student
 {
	//成员列表
	string name; //姓名
	int age;   //年龄
	int score;  //分数
};
//教师结构体定义
struct teacher 
{
	int id;//职工编号
	string name; //教师姓名
	int age; //教师年龄
	struct student stu;//子结构体学生
	};
int main()
{
   //老师的属性
	struct teachert1;
	t1.id = 1;
	t1.name = "老王";
	t1.age = 200;
	//老师带的学生的属性
	t1.stu.name = "张三";
	t1.stu.age = 18;
	t1.stu.score=100;
	return 0;
}

总结：在结构体中可以定义另一个结构体作为成员，用来解决实际问题

(4) 结构体作函数参数
作用：将结构体作为参数向函数中传递传递方式有两种：值传递和地址传递

//结构体定义
struct student
 {
	 string name; //姓名      
	 int age;   //年龄
};
//值传递
void printStudent(student stu)
{
	stu.age = 28;
	cout << "年龄："<< stu.age << endl;
}
//地址传递
void printStudent2(student * stu)
{
	stu->age=28;
	cout << "年龄：" << stu->age <<endl;
}
int main()
{
	student stu={"张三",18};
	printStudent(stu);
	//地址传递
	printStudent2(&stu);
	system("pause");
	return 0;
}

(5) 结构体中 const使用场景
作用：用const来防止误操作
示例：

//const使用场景，相当于常量指针
void printStudent(const student * stu)    //加const防止函数体中的误操作
{
	//stu->age=100;//操作失败，因为加了const修饰
	cout << "年龄：" << stu->age << "分数：" << stu->score << endl;
}
int main()
{
	studentstu={"张三",18};
	printStudent(&stu);    
	system("pause");
	return0;
}