C++基础学习笔记

1 常量

1. #define 宏常量 不可以被修改
2. const 修饰的变量 const int month = 12;

2 关键字

标识符命名规则：区分大小写、第一个字符必须英文或下划线，不可以是数字。

整型：指定类型，分配内存。
短整型：short 2字节
长整型：long win中4字节 lux中32位是4字节，64位是8字节
长长整型：long long 8字节

2.1 sizeof关键字

可以求出数据类型占用的内存大小，返回一个空间的大小/字节
语法：siazeof(数据类型 / 变量)

2.2 实型（浮点型）

单精度：float 4字节 7位有效数字，float f1 = 3.14f；//不加f默认是双精度
双精度：double 8字节 15-16 有效数字
默认情况下，输出一个小鼠，会吓死你hi一个6位有效数字

2.3 字符型

语法：char ch = 'a'; //只占用1个字节，单引号且只有一个字符
a = 97
A = 65

2.4 转义字符

转义字符 意义 ASCII码值（十进制）

\a	响铃(BEL)	007
\b	退格(BS) ，将当前位置移到前一列	008
\f	换页(FF)，将当前位置移到下页开头	012
\n	换行(LF) ，将当前位置移到下一行开头	010
\r	回车(CR) ，将当前位置移到本行开头	013
\t	水平制表(HT)	009
\v	垂直制表(VT)，占8个位置，整齐输出	011
\’	单引号	039
"	双引号	034
\	反斜杠	092

2.5 字符串型

C风格字符串：char 变量名[] = “字符串值”;
C++风格字符串：string 变量名 = "字符串值"; //需要包含头文件#include <string>

2.6 数据的输入

关键字：cin
语法：cin >> 变量；

两个整数相除，结果依然是整数，小数部分会去除

取模：（基于整数）
10%20 = 10
10%0 错误

3 逻辑运算符

！	非
&&	与
ll	或

3.1 if语句

语法：if (){...}else if(){...}else(){...}

3.2 三目运算符

语法：表达式1 ? 表达式2 :表达式3

3.3 shitch语句

switch(表达式){
	case 1:执行语句;
	break;
	case 2:执行语句;
	break;
	default:执行语句;
	break;
}

4 循环语句

4.1 while循环语句

语法：while(条件){...}
注意要避免死循环！！！

生成随机数：rand()%100 //生成0~99的随机数

4.2 do … while循环语句

语法：do{...}while(循环条件)

break和continue的区别

4.3 goto语句

语法：goto 标记;

...
goto FLAG;  //直接跳到FLAG标记处
...
FLAG:
...

5 数组

一、定义方式

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

5.1 数组名的用途

1. 可以通过数组名统计整个数组占用的内存大小
2. 可以通过数组名查看数组地址：cout << "首地址为" << (int)&数组名[] << endl;

数组名是一个常量，不可以进行赋值操作
数组的长度计算：sizeof(arr)/sizeof(arr[0]);

5.2 冒泡排序

5.3 二维数组

  1.数据类型 数组名[行数][列数]；
  2.数据类型 数组名[行数][列数]={{数据1，数据2，数据3}，{数据4，数据5，数据6}}
  3.数据类型 数组名[行数][列数]={数据1，数据2，数据3，数据4，数据5，数据6}
  4.数据类型 数组名[][列数]={数据1，数据2，数据3，数据4，数据5，数据6}   编译器可以自动捕捉到行数

int arr1[2][3] =
{
	{1,2,3},
	{4,5,6}
};

6 函数

6.1 函数定义

值传递：函数调用时，实参将数值传入给形参。
做值传递时，函数的形参发生改变，不会影响实参。形参改变不了实参。

rerturn值不需要的时候，可以不写return。

//函数常见样式
//1、 无参无返
void test01()
{
	//void a = 10; //无类型关键字不可以创建变量,原因是无法分配内存
	cout << "this is test01" << endl;
	//test01(); 函数调用
}

//2、 有参无返
void test02(int a)
{
	cout << "this is test02" << endl;
	cout << "a = " << a << endl;
}

//3、无参有返
int test03()
{
	cout << "this is test03 " << endl;
	return 10;
}

//4、有参有返
int test04(int a, int b)
{
	cout << "this is test04 " << endl;
	int sum = a + b;
	return sum;
}

6.2 函数的声名

如果不加函数声名，main函数必须写到最后。
如果加了函数声名，顺序就可以随意。
在开头加一个函数头
声名可以有多次，但定义只能有一次。

6.3 函数的分文件编写

1. 创建后缀名为.h的头文件，放入函数声名，要包含mian程序中的声名
2. 创建后缀名为.cpp的源文件，放入函数体，并在开头加入#include “xxx.h”
3. 在头文件中写函数的声明
4. 在源文件中写函数的定义
   在源文件中包含头文件 //笔者疑问：同名.h.cpp的关系？为何Vs2019中不包含也能正常调用？此时两者如何关联？
   使用：在欲使用的文件中包含.h头文件，即可使用同名.cpp中定义的函数

7 指针

7.1 基本概念

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

• 内存编号是从0开始记录的，一般用十六进制数字表示
• 可以利用指针变量存储地址

指针就是一个地址

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

int a = 10; 
int * p; //定义指针,整型的变量，定义一个整型的指针
p = &a; //让指针记录变量a的地址
//int * p = &a; //等价代码
//使用指针
//可以通过解引用的方式来找到指针指向的内存
//指针前加 * 代表解引用，找到指针指向的内存中的数据
*p = 1000; //拿到*p地址上的数据，并对他进行修改

int main() {
	//1、指针的定义
	int a = 10; //定义整型变量a
	//指针定义语法： 数据类型 * 变量名 ;
	int * p; //定义整型指针变量p

	//指针变量赋值
	p = &a; //指针指向变量a的地址
	cout << &a << endl; //打印数据a的地址
	cout << p << endl;  //打印指针变量p

	//2、指针的使用
	//通过*操作指针变量指向的内存
	cout << "*p = " << *p << endl;

	system("pause");
	return 0;
}

7.2 指针变量和普通变量的区别

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

总结1： 我们可以通过 & 符号 获取变量的地址

总结2：利用指针可以记录地址

总结3：对指针变量解引用(*p)，可以找到并操作指针指向的内存(内存中的数据)

简单记忆：&取地址，*取内容

7.3 指针所占内存空间

提问：指针也是种数据类型，那么这种数据类型占用多少内存空间？

int main() {
	int a = 10;
	int * p;
	p = &a; //指针指向数据a的地址

	cout << *p << endl; //* 解引用
	cout << sizeof(p) << endl;
	cout << sizeof(char *) << endl;
	cout << sizeof(float *) << endl;
	cout << sizeof(double *) << endl;
//32位操作系统下，指针是占4个字节空间大小，不管是什么数据类型
//在64位操作系统下，指针是占8个字节空间大小
	system("pause");
	return 0;
}

7.4 空指针和野指针

空指针：指针变量指向内存中编号为0的空间
用途：初始化指针变量
注意：空指针指向的内存是不可以访问的，因为0~255之间的内存编号是系统占用的，不可以访问

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

	system("pause");
	return 0;
}

野指针：指针变量指向非法的内存空间 ,在程序中，尽量避免出现野指针

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

	system("pause");
	return 0;
}

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

7.5 const修饰指针

const修饰指针有三种情况：

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

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

    //const既修饰指针又修饰常量
	const int* const p3 = &a;
	//p3 = &b; //错误
	//*p3 = 100; //错误

	system("pause");
	return 0;
}

常量指针指的是const修饰的是*p，指针常量指的是const修饰的是指针变量p，const修饰哪个，哪个不能改变

指针和数组

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

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;
}

7.6 指针和函数

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

//值传递
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); // 值传递不会改变实参
	swap2(&a, &b); //地址传递会改变实参

	cout << "a = " << a << endl;
	cout << "b = " << b << endl;

	system("pause");
	return 0;
}

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

7.7 指针、数组、函数

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

例如数组：int arr[10] = { 4,3,6,9,1,2,10,8,7,5 };

//冒泡排序函数
void bubbleSort(int * arr, int len)  //int * arr 也可以写为int arr[]；* arr是数组的首地址
{
	for (int i = 0; i < len - 1; i++)
	{
		for (int j = 0; j < len - 1 - i; j++)
		{
			if (arr[j] > arr[j + 1])
			{
				int temp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = temp;
			}
		}
	}
}

//打印数组函数
void printArray(int arr[], int len)
{
	for (int i = 0; i < len; i++)
	{
		cout << arr[i] << endl;
	}
}

int main() {
	int arr[10] = { 4,3,6,9,1,2,10,8,7,5 };
	int len = sizeof(arr) / sizeof(int);

	bubbleSort(arr, len);
	printArray(arr, len);

	system("pause");
	return 0;
}

8 结构体

8.1结构体基本概念

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

结构体定义和使用
语法(自定义结构体)：struct 结构体名 { 结构体成员列表 }；

通过结构体创建变量的方式有三种：

• struct 结构体名 变量名
• struct 结构体名 变量名 = { 成员1值 ， 成员2值…}
• 定义结构体时顺便创建变量

//结构体定义
struct student
{
	//成员列表
	string name;  //姓名
	int age;      //年龄
	int score;    //分数
}stu3; //结构体变量创建方式3 

int main() {
	//结构体变量创建方式1
	struct student stu1; //struct 关键字可以省略

	stu1.name = "张三";
	stu1.age = 18;
	stu1.score = 100;
	cout << "姓名：" << stu1.name << " 年龄：" << stu1.age  << " 分数：" << stu1.score << endl;

	//结构体变量创建方式2
	struct student stu2 = { "李四",19,60 };
	cout << "姓名：" << stu2.name << " 年龄：" << stu2.age  << " 分数：" << stu2.score << endl;
	
	stu3.name = "王五";
	stu3.age = 18;
	stu3.score = 80;
	cout << "姓名：" << stu3.name << " 年龄：" << stu3.age  << " 分数：" << stu3.score << endl;
	system("pause");
	return 0;
}

总结1：定义结构体时的关键字是struct，不可省略

总结2：创建结构体变量时，关键字struct可以省略

总结3：结构体变量利用操作符 ‘’.’’ 访问成员

8.2 结构体数组

作用：将自定义的结构体放入到数组中方便维护

语法(创建变量)：struct 结构体名 数组名[元素个数] = { {} , {} , ... {} }

//结构体定义
struct student
{
	//成员列表
	string name;  //姓名
	int age;      //年龄
	int score;    //分数
};

int main() {
	//结构体数组
	struct student arr[3]=
	{
		{"张三",18,80 },
		{"李四",19,60 },
		{"王五",20,70 }
	};

//给结构体数组中的元素进行赋值/更改
	arr[2].name = "赵六";
	arr[2].agw = 60;
	arr[2].score = 59;
	
	for (int i = 0; i < 3; i++)
	{
		cout << "姓名：" << arr[i].name << " 年龄：" << arr[i].age << " 分数：" << arr[i].score << endl;
	}
	
	system("pause");
	return 0;
}

8.3 结构体指针

作用：通过指针访问结构体中的成员

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

//结构体定义
struct student
{
	//成员列表
	string name;  //姓名
	int age;      //年龄
	int score;    //分数
};

int main() {
	struct student stu = { "张三",18,100, }; //struct 关键字可以省略
	
	struct student * p = &stu;  //struct 关键字可以省略
	
	p->score = 80; //指针通过 -> 操作符可以访问成员

	cout << "姓名：" << p->name << " 年龄：" << p->age << " 分数：" << p->score << endl;
	
	struct student stu2 = { "顾川",24,150, };
    struct student * p1 = &stu2;
    cout<< "姓名：" <<(*p1).name<<endl;
	system("pause");
	return 0;
}

8.4 结构体嵌套结构体

作用：结构体中的成员可以是另一个结构体

例如：每个老师辅导一个学员，一个老师的结构体中，记录一个学生的结构体

//学生结构体定义
struct student
{
	//成员列表
	string name;  //姓名
	int age;      //年龄
	int score;    //分数
};

//教师结构体定义
struct teacher
{
    //成员列表
	int id; //职工编号
	string name;  //教师姓名
	int age;   //教师年龄
	struct student stu; //子结构体 辅导的学生
};

int main() {

	struct teacher t1;
	t1.id = 10000;
	t1.name = "老王";
	t1.age = 40;

	t1.stu.name = "张三";
	t1.stu.age = 18;
	t1.stu.score = 100;

	cout << "教师 职工编号： " << t1.id << " 姓名： " << t1.name << " 年龄： " << t1.age << endl;
	cout << "辅导学员 姓名： " << t1.stu.name << " 年龄：" << t1.stu.age << " 考试分数： " << t1.stu.score << endl;

	system("pause");
	return 0;
}

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

注意：子结构体的自定义需要在使用它的父结构体的前面

8.5 结构体做函数参数

作用：将结构体作为参数向函数中传递

传递方式有两种：

• 值传递
• 地址传递

//学生结构体定义
struct student
{
	//成员列表
	string name;  //姓名
	int age;      //年龄
	int score;    //分数
};

//值传递
void printStudent(student stu )
{
	stu.age = 28;
	cout << "子函数中 姓名：" << stu.name << " 年龄： " << stu.age  << " 分数：" << stu.score << endl;
}

//地址传递
void printStudent2(student *stu)
{
	stu->age = 28;
	cout << "子函数中 姓名：" << stu->name << " 年龄： " << stu->age  << " 分数：" << stu->score << endl;
}

int main() {
	student stu = { "张三",18,100 };
	//值传递
	printStudent(stu);
	cout << "主函数中 姓名：" << stu.name << " 年龄： " << stu.age << " 分数：" << stu.score << endl;

	cout << endl;

	//地址传递
	printStudent2(&stu);
	cout << "主函数中 姓名：" << stu.name << " 年龄： " << stu.age  << " 分数：" << stu.score << endl;

	system("pause");
	return 0;
}

总结：如果不想修改主函数中的数据，用值传递，反之用地址传递

注意：结构体的自定义同样要在使用它的函数之前

8.6 结构体中const使用场景

作用：用const来防止误操作

//学生结构体定义
struct student
{
	//成员列表
	string name;  //姓名
	int age;      //年龄
	int score;    //分数
};

//const使用场景
//将函数中的形参改为指针，可以减少内存空间，而且不会复制新的副本出来
void printStudent(const student *stu) //加const防止函数体中的误操作
{
	//stu->age = 100; //操作失败，因为加了const修饰
	cout << "姓名：" << stu->name << " 年龄：" << stu->age << " 分数：" << stu->score << endl;

}

int main() {

	student stu = { "张三",18,100 };

	printStudent(&stu);

	system("pause");
	return 0;
}

8.7 结构体案例

案例1
案例描述：

学校正在做毕设项目，每名老师带领5个学生，总共有3名老师，需求如下

设计学生和老师的结构体，其中在老师的结构体中，有老师姓名和一个存放5名学生的数组作为成员

学生的成员有姓名、考试分数

创建数组存放3名老师，通过函数给每个老师及所带的学生赋值

最终打印出老师数据以及老师所带的学生数据。

struct Student
{
	string name;
	int score;
};
struct Teacher
{
	string name;
	Student sArray[5];
};

void allocateSpace(Teacher tArray[] , int len)
{
	string tName = "教师";
	string sName = "学生";
	string nameSeed = "ABCDE";
	for (int i = 0; i < len; i++)
	{
		tArray[i].name = tName + nameSeed[i];//字符串拼接
		
		for (int j = 0; j < 5; j++)
		{
			tArray[i].sArray[j].name = sName + nameSeed[j];//字符串拼接
			tArray[i].sArray[j].score = rand() % 61 + 40;//取40~100的随机数
		}
	}
}

void printTeachers(Teacher tArray[], int len)
{
	for (int i = 0; i < len; i++)
	{
		cout << tArray[i].name << endl;
		for (int j = 0; j < 5; j++)
		{
			cout << "\t姓名：" << tArray[i].sArray[j].name << " 分数：" << tArray[i].sArray[j].score << endl;
		}
	}
}

int main() {
	srand((unsigned int)time(NULL)); //随机数种子 头文件 #include <ctime>
	Teacher tArray[3]; //老师数组
	int len = sizeof(tArray) / sizeof(Teacher);
	allocateSpace(tArray, len); //创建数据
	printTeachers(tArray, len); //打印数据
	
	system("pause");
	return 0;
}

案例2
案例描述：

设计一个英雄的结构体，包括成员姓名，年龄，性别;创建结构体数组，数组中存放5名英雄。

通过冒泡排序的算法，将数组中的英雄按照年龄进行升序排序，最终打印排序后的结果。

五名英雄信息如下：
{“刘备”,23,“男”},
{“关羽”,22,“男”},
{“张飞”,20,“男”},
{“赵云”,21,“男”},
{“貂蝉”,19,“女”},

//英雄结构体
struct hero
{
	string name;
	int age;
	string sex;
};
//冒泡排序
void bubbleSort(hero arr[] , int len)
{
	for (int i = 0; i < len - 1; i++)
	{
		for (int j = 0; j < len - 1 - i; j++)
		{
			if (arr[j].age > arr[j + 1].age)
			{
				hero temp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = temp;
			}
		}
	}
}
//打印数组
void printHeros(hero arr[], int len)
{
	for (int i = 0; i < len; i++)
	{
		cout << "姓名： " << arr[i].name << " 性别： " << arr[i].sex << " 年龄： " << arr[i].age << endl;
	}
}

int main() {

	struct hero arr[5] =
	{
		{"刘备",23,"男"},
		{"关羽",22,"男"},
		{"张飞",20,"男"},
		{"赵云",21,"男"},
		{"貂蝉",19,"女"},
	};
	int len = sizeof(arr) / sizeof(hero); //获取数组元素个数
	bubbleSort(arr, len); //排序
	printHeros(arr, len); //打印

	system("pause");
	return 0;
}