C++基础语法入门（二）

C++基础语法

笔记是跟着B站黑马视频学习记下来的，https://www.bilibili.com/video/BV1et411b73Z?p=1

语法1：数组
1）一维数组
定义方式：

• 数据类型 数组名 [数组长度]
• 数据类型 数组名 [数组长度] =｛值1 值2 值3…｝
• 数据类型 数组名 [ ] = {值1 值2 值3…}
  注意：数组名命名不要和变量重名，数组中下标是从0开始索引

一维数组名称的用途：
(1）可以统计整个数组在内存中的长度
(2）可以获取数组在内存中的首地址

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

二维数组名称的用途：
（1）查看二维数组所占内存空间
（2）获取二维数组首地址

语法2： 函数

• 作用：
  将一段经常使用的代码封装起来，减少重复，每个模块实现特定的功能
• 定义：函数的定义一般有五个步骤
  1.返回值类型 2.函数名 3.参数列表 4.函数体语句 5.return表达式

	返回值类型 函数名(参数列表)
	{
		函数体语句

		return表达式
	}

• 函数的调用
  函数名（参数）

• 值传递
  1.所谓值传递，就是函数调用时实参将数值传入给形参
  2.值传递时，如果形参发生改变，不会影响实参。

• 函数常见样式
  有四种：1.无参无返 2.有参无返 3.无参有返 4.有参有返

• 函数的声明
  1.作用：告诉编译器函数名称以及如何调用函数，函数可以声明很多次，但是函数的定义只能有一次

• 函数的分文件编写
  1）作用：让代码机构更加的清晰
  2）函数分文件编写一般有五个步骤：
    1.创建后缀名为.h的头文件
    2.创建后缀名为.cpp的源文件（cpp就是c++）
    3.在头文件中写函数的声明
    4.在源文件中写函数的定义
    5.在源文件中必须要进行#include “函数名.h”的头文件

语法3：指针

• 指针的定义及使用
  1）作用：可以通过指针保存一个地址，指针就是地址
  2）指针定义的语法：数据类型 *指针变量名

• 指针所占内存空间
  1）指针也是种数据类型，在32位操作系统下占4个字节空间，在64位中占8个字节空间

• 空指针和野指针
  1）空指针：指针变量窒息那个内存中编号为0的空间
  2）空指针用途：初始化指针变量
  注意：空指针指向的内存是不可以访问的

  3）野指针：指针变量指向非法的内存空间，应尽量避免野指针
  总之：空指针和野指针都不是我们申请的空间，因此不要访问。

• const修饰指针
  const修饰指针有三种情况：
     1）const修饰指针--------常量指针
     2）const修饰常量--------指针常量
     3）const既修饰指针又修饰常量

• 指针和数组
  1）作用：利用指针访问数组中的元素

• 指针和函数
  1）作用：利用指针作为函数参数，可以修改实参的值

语法4：结构体

• 基本概念
  结构体属于用户自定义的数据类型，允许用户存储不同的数据类型

• 结构体的定义和使用
  1）定义：struct 结构体名 ｛结构体成员列表｝；
  2）通过结构体创建变量的方式有三种：
    1. struct 结构体名 变量名
    2. struct 结构体名 变量名 = ｛成员1值，成员2值…｝
    3. 定义结构体时顺便创建变量
  注意1 ：一般是使用第一种和第二种
  注意2：创建结构体变量时，struct 的关键字在c++中可以省略

• 结构体数组
  1）作用：将自定义的结构体放入到数组中方便维护
  2）语法：struct 结构体名 数组名[元素个数] = ｛ ｛｝，｛｝，…｛｝｝

• 结构体指针
  1）通过指针访问结构体中的成员，利用操作符 —> 可以通过结构体指针访问结构体属性

• 结构体嵌套结构体
  1）作用：结构体中的成员可以是另一个结构体

• 结构体做函数参数
  1）作用：将结构体作为参数向函数中传递
  2）传递方式有两种：值传递和地址传递
  注意：值传递修饰形参，实参不变，地址传递中，修饰形参，实参跟着改变

• 结构体中 const 使用场景
  1）用 const 来防止误操作
  总结：将函数中的形参改为指针，可减少内存空间，不会复制新的副本出来，但是容易误操作，将实参值改变，因此在形参前面加 const 修饰，就可以防止误操作。

与语法对应的实例

例子1：数组
1）一维数组

int main()
{   //1）可以统计整个数组在内存中的长度
	int arr[10] = {1,2,3,4,5,6,7,8,9,10};
	cout << "整个数组占用的内存空间为：" << sizeof(arr) << endl;
	cout << "数组中元素的个数为" << sizeof(arr) / sizeof(arr[0]) << endl;
	//2）可以获取数组在内存中的首地址
	cout << "数组首地址为：" << arr << endl;
	cout << "数组中第一个元素的地址为：" << &arr[0] << endl;
	system("pause");
	return 0;
}

**冒泡排序例子：

//冒泡排序 
int main()//升序排列 4 2 8 0 5 7 1 3 9，利用冒泡排序，每次将最大值筛选出来
{   
	int arr[9] = {4,2,8,0,5,7,1,3,9};
	cout << "排序前为：" << endl;
	for (int i = 0;i < 9;i++)
	{
		cout << arr[i] << " ";
	}
	cout << endl;
	//开始冒泡排序 总共9个元素，因此排序8轮，每轮选出一个最大值
	for (int i = 0;i < 8;i++)
	{
		//内层循环对比
		for (int j = 0;j < 9 - i - 1;j++)
		{
			if (arr[j]>arr[j+1])
			{
				int temp = arr[j];
				arr[j] = arr[j+1];
				arr[j+1] = temp;
			}		
		}	
	}
	cout << "排序后：" << endl;
	for (int i = 0;i < 9;i++)
	{
		cout << arr[i] << " ";
	}
	system("pause");
	return 0;
}

2）二维数组

int main()
{
	//二维数组第二种定义方式
	int arr[2][3] =
	{
		{1,2,3},
		{4,5,6}
     };
	for (int i=0;i<2;i++)
	{
		for (int j = 0;j < 3;j++)
		{
			cout << arr[i][j] << " ";
		}
		cout << endl;
	}
	system("pause");
	return 0;
}

例子2：函数
1）函数的定义与调用

//加法函数，实现两个整形相加，并且将结果进行返回
int add(int num1, int num2)//num1和num2为形参
{
	int sum = num1 + num2;
	return sum;
}

int main()
{
	int a = 10;//a和b为实参
	int b = 20;
	int c = add(a,b);
	cout << "c = " << c << endl;
	system("pause");
	return 0;
}

2）值传递

//值传递
//定义函数，实现两个数字进行交换的函数
//如果函数不需要返回值，声明的时候可以写出void,返回值也可以不用写
void swap(int num1, int num2)//num1和num2为形参
{
	int temp = num1;
	num1 = num2;
	num2 = temp;
}

3）函数的声明

//函数的声明
int max(int a,int b);//如果函数体写在之后或者写在新的项目文件夹里，主函数调用其时需要提前声明它的存在。

int main()
{
	int a = 10;//a和b为实参
	int b = 2;
	int c = max(a,b);
	cout << "c = " << c << endl;
	system("pause");
	return 0;
}
int max(int num1, int num2)//num1和num2为形参
{
	int re = num1 > num2 ? num1 : num2;
	return re;
}

例子3：指针
1）指针的定义及使用

int main()
{
	int a = 10;
	//定义指针
	int *p;
	p = &a;
	cout << "a的地址为：" << &a << endl;
	//使用指针
	//可以通过解引用的方式来找到指针指向的内存，
	//指针前加 * 代表解引用，找到指针指向的 内存中的数据
	*p = 1000;//间接访问，可读可写
	cout << "a的值为：" << a << endl;
	system("pause");
	return 0;
}

2）空指针

int main()
{
	//空指针
	int *p = NULL;
	//但是不可以对该指针进行访问
	//0~255之间的内存编号是系统占用的，因此不可以访问
	system("pause");
	return 0;
}

3）const修饰指针

int main()
{   //const代表常量，不可修改，谁被const修饰，谁就不能被修改
	int a = 10;
	int b = 10;
	//1.常量指针
	const int * p = &a;
	//特点：指针的指向可以修改，但是指针指向的值不可以改
	//也就是，指针能够指向b，但是依旧是a的值

	//2.指针常量
	int * const p = &a;
    //特点：指针的指向不可以改，指针指向的值可以改
	//也就是，指针不能够指向其他内存b，但是指针指向的值改为b的值

	//3.const既修饰指针，又修饰常量
	const int * const p = &a;
	//特点：指针的指向和指针指向的值都不可以修改
	system("pause");
	return 0;
}

4）指针和数组

int main()
{  
	int arr[10] = {1,2,3,4,5,6,7,8,9,10};
	int * p = arr;//arr就是数组的首地址
	cout << "利用指针访问第一个元素：" << *p << endl;
	p++;//让指针向后偏移4个字节
	cout << "利用指针访问第二个元素：" << *p << endl;

	system("pause");
	return 0;
}

5）指针和函数

//1.值传递中实参传入形参，实参的值不会改变，形参发生改变

//2.地址传递:可以修改实参的值
void swap(int * p1, int * p2)
{
	int temp = *p1;
	*p1 = *p2;
	*p2 = temp;
}
int main()
{
	int a = 10;
	int b = 20;
	swap(&a,&b);
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;

	system("pause");
	return 0;
}

例子5：结构体
1）结构体定义和使用

#include <iostream>
using namespace std;
#include <string>

//创建student数据类型
struct student
{
	string name; //姓名
	int age; //年龄
	int score; //分数
}s3;
//通过student类型创建具体学生
int main()
{   //创建变量方式一
	struct student s1;
	s1.name = "张三";
	s1.age = 18;
	s1.score = 100;
	//创建变量方式二
	struct student s2 = {"李四",19,80};
	//创建变量方式三:s3,直接在结构体末尾处加上s3
	s3.name = "王五";
	s3.age = 20;
	s3.score = 60;
	system("pause");
	return 0;
}

2）结构体数组

struct student
{
	string name; //姓名
	int age; //年龄
	int score; //分数
};

int main()
{   //创建结构体数组
	struct student stuArr[3] =
	{
		{"张三",18,100},
		{"李四",28,99},
		{"王五",38,66}
	};
	//给结构体数组中的元素赋值
	stuArr[0].score = 95;

	cout << "姓名 " << stuArr[0].name << " 分数 " << stuArr[0].score << endl; 
	system("pause");
	return 0;
}

3）结构体指针

struct student
{
	string name;
	int age;
	int score;
};

int main()
{   //创建结构体变量
	struct student s = { "张三",18,100 };

	//通过指针指向结构体变量
	struct student * p = &s;

	//通过指针访问结构体中的数据,利用->进行访问
	cout << "姓名 " << p->name << " 分数 " << p->score << endl; 
	system("pause");
	return 0;
}

4）结构体嵌套结构体

//定义学生的结构体
struct student
{
	string name;
	int age;
	int score;
};
//定义老师的结构体
struct teacher
{
	int id;//教师编号
	string name;//教师姓名
	int age;//年龄
	struct student stu;//辅导的学生
};
int main()
{   
	//创建老师
	teacher t;
	t.name = "老王";
	t.age = 50;
	t.stu.name = "小王";
	t.stu.score = 70;

	cout << "老师姓名 " << t.name << " 老师辅导的学生 " << t.stu.name<< endl; 
	system("pause");
	return 0;
}

5）结构体做函数参数

struct student
{
	string name;
	int age;
	int score;
};
void printStudent1(struct student s)//值传递
{
	cout << " 姓名 " << s.name << " 年龄 " << s.age << " 分数 " << s.score << endl;
};
void printStudent2(struct student *p)//地址传递
{
	cout << " 姓名 " << p->name<< " 年龄 " << p->age << " 分数 " << p->score << endl;
};
//将学生传入到一个参数中，打印学生身上的所有信息
int main()
{   
	struct student s;
	s.name = "张三";
	s.age = 20;
	s.score = 85;

	printStudent1(s);//值传递
	printStudent2(&s);//地址传递
	system("pause");
	return 0;
}

6）结构体中 const 使用场景

//const 使用场景
struct student
{
	string name;
	int age;
	int score;
};
void printStudengts(const student *s)//指针节省空间，加const防止误操作
{
	cout << " 姓名 " << s->name << " 年龄 " << s->age << " 分数 " << s->score << endl;
};
int main()
{   //创建结构体变量
	struct student s = { "张三" , 15 , 70 };

    printStudengts(&s);
	system("pause");
	return 0;
}