对C++有初步了解，能够有基础编程能力。 案例：通讯录管理系统
单行注释：// 多行注释：/*描述信息*/
意义：方便管理内存空间。 语法：
数据类型 变量名 = 变量初始值； int a = 10；作用：用于记录程序中不可更改的数据。 C++定义常量的两种方式：
1.#define 宏常量：
**#define 常量名 常量值** （通常在文件上方定义，表示一个常量。）2.const修饰的变量
**const 数据类型 常量名 = 常量值** （通常在变量定义前加关键字const，修饰该变量为常量，不可修改。）作用：关键字是C++中预先保留的单词（标识符） 在定义变量或常量时，不要使用关键字。
C++规定给标识符（变量、常量）命名时，有一套自己的规则：
标识符不能是关键字标识符只能由字母、数字、下划线构成第一个字母必须为字母或下划线标识符中字母区分大小写给变量分配合适的内存空空间。
表示整数类型的数据 分类：（所占内存空间不同）
利用sizeof关键字可以统计数据类型所占内存大小。 语法：
**sizeof（数据类型/变量）**用于表示小数 分类： 1.单精度float 2.双精度double （区别在于表示的有效数字范围不同） 默认情况下，输出一个小数，会显示6位有效数字。
//科学计数法：
用于显示单个字符。 语法：
char ch = 'a'；注： 1.在显示字符型变量时，用单引号，不要用双引号。 2.单引号内只能由一个字符，不可以是字符串。
C/C++中字符型变量只占用1个字节字符型变量并不是把字符本身放到内存中储存，而是将对应的ASCII编码放到存储单元中。用于表示一些不能显示出来的ASCII字符 常见： 换行符：\n 反斜杠：\ 水平制表符：\t（一共占8个位置） 【可保持对齐】
表示一串字符 两种风格： 1.C风格字符串：
**char 变量名[ ]="字符串值"** C风格字符串要用双引号括起来2.C++风格字符串：
**string 变量名 = "字符串值"** 需要包含 #include 头文件表示真或假的值 语法： bool 变量名 = true/false bool类型只有两个值：
true - 真 （本质是1）false - 假 （本质是0） 【输出会为1/0】 注： 1.bool类型占用1个字节大小 2.只要是非0的值都代表真作用：从键盘获取数据 关键字：cin 语法：
**cin >> 变量**作用：用于执行代码的运算 本章主要讲以下几类： 算术运算符 用于处理四则运算 赋值运算符 用于将表达式的值赋给变量 比较运算符 用于表达式的比较，并返回一个真值或假值 逻辑运算符 用于根据逻辑表达式的值返回真值或假值
注： 1.除数不能为0 2.两个小数可以相除，且结果可为小数 3.两个小数不可以做取模运算 4.前置递增/减：先让变量+/-1，再进行表达式运算 后置递增/减：先进行表达式运算，后让变量+/-1
注： 1.与：同真为真，其余为假 2.或：同假为假，其余为真
C/C++支持最基本的三种程序运行结构：顺序结构、选择结构、循环结构 顺序结构：程序按顺序执行。不发生跳转 选择结构：依据条件是否满足，有选择的执行相应功能 循环结构：依据条件是否满足，循环多次执行某段代码
三种形式：
1.单行格式if语句： **if（条件）{条件满足执行的语句}** 注：if条件后不要加分号；（会导致代码分离）
2.多行格式if语句：
**if（条件）{条件满足执行的语句}else{条件不满足执行的语句}**3.多条件的if语句： if（条件1）{条件1满足执行的语句}else if（条件2）{条件2满足执行的语句}...else{都不满足执行的语句}
嵌套if语句：在if语句中，可以嵌套使用if语句，达到更精确的条件判断
通过三目运算符实现简单的判断 语法：
**表达式1？表达式2：表达式3**解释： 如果表达式1的值为真，执行表达式2，并返回表达式2的结果； 如果表达式1的值为假，执行表达式3，并返回表达式3的结果。 注：在C++中三目运算符返回的是变量，可以继续赋值
执行多条件分支语句 语法：
switch（表达式） { case 结果1：执行语句；break； case 结果2：执行语句；break； ··· default：执行语句；break； }注： 1.switch判断的时候只能是整型或者字符型，不可一世一个区间 2.switch结构清晰，执行效率高 3.case如果没有break，程序会一直向下执行
作用：满足循环条件，执行循环结构
语法：
while（循环条件）{循环语句}解释：只要循环条件的结果为真，就执行循环语句 注：写循环时要避免死循环的出现
语法：
do{循环语句} while（循环条件）；注意：与while的区别在于do…while会先执行一次循环语句，再判断循环条件
语法：
for（起始表达式；条件表达式；末尾循环体） {循环语句；}注： 1.for循环中的表达式，需要用分号进行分割 2.for循环结构比较清晰，比较常用
用于跳出选择结构或者循环结构
使用时机： 1.出现在switch条件语句中，终止case并跳出switch 2.出现在循环语句中，跳出当前的循环语句 3.出现在嵌套循环中，跳出最近的内层循环语句
在循环语句中，跳过本次循环中余下尚未执行的语句，继续执行下一次循环
可以无条件跳转语句 语法：
goto 标记；标记一般用**大写字母：**表示 解释：如果标记的名称存在，执行goto语句时，会跳转到标记的位置
注：在程序中不建议使用goto语句，以免造成程序流程混乱
所谓数组，就是一个集合，里面存放了相同类型的数据元素
特点： 1.数组中的每个数据元素都是相同的数据类型 2.数组是由连续的内存位置组成的
三种方式： 1.数据类型 数组名 [ 数组长度 ]； 2.数据类型 数组名 [ 数组长度 ] = { 值1，值2...}； 3.数据类型 数组名 [ ] = {值1，值2...}；
注：如果在初始化数据时没有填充完，会用0来填补剩余数据
总结： 1.数组名的命名规则与变量名规范一致，不要和变量名重名 2.数组中下标是从0开始索引
一维数组名称的用法： 1.可以统计整个数组在内存中的长度 （用sizeof（arr）） 2.可以获取数组在内存中的首地址 （用cout<<arr<<endl;）
cout<<(int)&arr[0]<<endl; //(int)表示将16进制转成10进制形式输出 //&表示输出地址，而不是元素注： 数组名是常量，不可以进行赋值操作
作用：最常用的排序算法，对组内元素进行排序 1.比较相邻的元素，如果第一个比第二个大，就交换 2.对每一对相邻元素做同样的工作，执行完毕后，找到第一个最大值 3.重复以上的步骤，每次比较次数-1，直到不需要比较
总共排序的轮数=元素个数-1 次数=元素个数-当前对比轮数-1
#include<iostream> using namespace std; int main() { //利用冒泡排序实现升序序列 int arr[] = { 4,2,8,0,5,7,1,3,9 }; cout << "排序前的序列：" << endl; for (int i = 0; i < sizeof(arr) / sizeof(arr[0] ); i++) { cout << arr[i] << " "; } //开始冒泡排序 //总共排序的轮数=元素个数-1 for (int i = 0; i < sizeof(arr) / sizeof(arr[0] - 1); i++) { //内层循环对比 次数=元素个数-当前对比轮数-1 for (int j = 0; j < sizeof(arr) / sizeof(arr[0])-i-1; j++) { //如果第一个数字比第二个数字大，交换 if (arr[j]>arr[j+1]) { int temp = arr[j]; arr[j] = arr[j+1]; arr[j+1] = temp; } } } cout << endl; //排序后结果 cout << "排序后的结果为：" << endl; for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); i++) { cout << arr[i] << " "; } cout << endl; system("pause"); return 0; }二维数组就是在一维数组上，多加一个维度
四种方式： 1.数据类型 数组名 [ 行数 ] [ 列数 ]； 2.数据类型 数组名 [ 行数 ] [ 列数 ] = { {数据1，数据2}，{数据3，数据4} }； 3.数据类型 数组名 [ 行数 ] [ 列数 ] = { {数据1，数据2，数据3，数据4}； 4.数据类型 数组名 [ ] [ 列数 ] = { {数据1，数据2，数据3，数据4}；
建议：以上4种定义方式，利用第2种更加直观，提高代码的可读性
int arr[2][3] = { {1,2,3}, {4,5,6}1.查看二维数组所占内存空间 2.获取二维数组首地址
作用：将一段经常使用的代码封装起来，减少重复代码 一个较大的程序，一般分为若干个程序块，每个模块实现特定的功能
函数的定义一般主要有5个步骤： 1.返回值类型：在函数定义中一个函数可以返回一个值 **2.函数名：**给函数起个名称 **3.参数表列：**使用该函数时，传入的数据 **4.函数体语句：**花括号内的代码，函数内需要执行的语句 **5.return 表达式：**和返回值类型挂钩，函数执行完毕后，返回相应的数据
语法：
返回值类型 函数名 （参数列表） { 函数体语句 return 表达式 }功能：使用定义好的函数 语法：函数名（参数） 调用函数时，将实参的值传递给形参
作为值传递，就是函数调用实参将数值传入给形参 值传递时，如果形参发生改变，并不会影响实参
如果函数不需要返回值，声明的时候可以将返回值类型写成void，且不需要return表达式
常见的函数样式有4种： 1.无参无返 2.有参无返 3.无参有返 4.有参有返
#include<iostream> using namespace std; //函数常见形式： //1.无参无返 void test01() { cout << "this is test01" << endl; } //2.有参无返 void test02(int a) { cout << "this is test02 a = "<<a << endl; } //3.无参有返 int test03() { cout << "this is test03" << endl; return 1000; } //4.有参有返 int test04(int b) { cout << "this is test04 b =" << b << endl; return b; } int main() { test01(); //调用1 test02(10); //调用2 int num1 = test03(); //调用3 cout << "num1=" << num1 << endl; int num2 = test04(10000); //调用4 cout << "num2=" << num2 << endl; system("pause"); return 0; }作用：告诉编译器函数名称以及如何调用函数 函数的实际主体可以单独定义
函数的声明可以多次，但函数的定义只能有一次
#include<iostream> using namespace std; //函数的声明 //比较函数，实现两个整型数字进行比较，返回较大的值 //提前告诉编译器函数的存在，可以利用函数的声明 //函数的声明 int max(int a, int b); int main() { int a = 10; int b = 20; cout << max(a, b) << endl; system("pause"); return 0; } //定义 如果在定义前调用该函数，且在无声明的情况下，会报错 int max(int a, int b) { return a > b ? a : b; }作用：让代码结构更清晰
函数分文件编写一般有4个步骤： 1.创建后缀名为.h的头文件 2.创建后缀名为.cpp的源文件 3.在头文件中写函数的声明 4.在源文件中写函数的定义
指针的作用：可以通过指针间接访问内存
内存编号是从0开始记录的，一般用16进制数表示可以利用指针变量保存地址 指针就是一个地址指针变量定义语法：数据类型 * 变量名；
#include<iostream> using namespace std; int main() { //1.定义指针 int a = 10; int * p; //让指针记录变量a的地址 p = &a; cout << "a的地址为：" << &a << endl; cout << "指针p为：" << p << endl; //2.使用指针 //可以通过解引用的方式来找到指针指向的内存,且可以修改 //指针前加 * 代表解引用，找到指针指向的内存中的数据，并修改 *p = 1000; cout << "a=" << a << endl; cout << "*p=" << *p << endl; system("pause"); return 0; }指针通过解引用可以访问并修改其指向内存
Q：指针也是种数据类型，那么这种数据类型占用多少内存空间吗？ A：在32位操作系统下，占用4个字节空间；在64位操作系统下，占用8个字节空间
int a = 10; int * p = &a; cout <<"sizeof(int *) = "<<sizeof(int *)<<endl; cout <<"sizeof(float *) = "<<sizeof(float *)<<endl; cout <<"sizeof(double *) = "<<sizeof(double *)<<endl; cout <<"sizeof(char *) = "<<sizeof(char *)<<endl;空指针：指针变量指向内存中编号为0的空间 用途：初始化指针变量 注意：空指针指向的内存是不可以访问的 （0~255之间的编号时系统占用的，因此不可以访问）
#include<iostream> using namespace std; int main() { //空指针 int *p = NULL; //cout<<*p<<endl; (会报错） system("pause"); return 0; }野指针：指针变量指向非法的内存空间
#include<iostream> using namespace std; int main() { //野指针 //在程序中尽量避免出现野指针 int *p = (int *)0x1100; //未生成内存空间不可访问 cout << *p << endl; system("pause"); return 0; }空指针和野指针都不是我们申请的空间，因此不要访问
const修饰指针有三种情况：
const修饰指针——常量指针const修饰常量——指针常量const既修饰指针，又修饰常量 #include<iostream> using namespace std; int main() { //1.const修饰指针 常量指针 指针指向的值不可以改，指针的指向可以改 int a = 10; int b = 20; const int *p = &a; //*p = 20;错误 p = &b; //正确 //2.const修饰常量 指针常量 指针指向的值可以改，指针的指向不可以改 int * const p2 = &a; *p2 = 20; //正确 //p2 = &b; 错误 //3.const修饰指针和常量 指针指向的值和指针的指向都不可以改 const int * const p3 = &a; //*p3 = 20; 错误 //p3 = &b; 错误 system("pause"); return 0; }技巧：看const右侧紧跟着的是指针还是常量，是指针就是常量指针，是常量就是指针常量
作用：利用指针访问数组中的元素
#include<iostream> using namespace std; int main() { //指针和数组 //利用指针访问数组中的元素 int arr[10] = { 1,2,3,4,5,6,7,8,9,10 }; cout << "第一个元素为：" << arr[0] << endl; int *p = arr; //arr就是数组的首地址 cout << "利用指针访问第一个元素：" << *p << endl; //用指针的解引用访问内存，p是地址 p++; //让指针向后偏移4个字节 指针类型长度为4 cout << "利用指针访问第二个元素：" << *p << endl; cout << "利用指针遍历数组" << endl; int *p2 = arr; for (int i = 0; i < 10; i++) { //cout << arr[i] << endl; cout << *p2 << endl; p2++; //这两行可以整合成 cout << *p2++ <<endl; } system("pause"); return 0; }作用：利用指针作函数参数，可以修改实参的值
#include<iostream> using namespace std; //实现两个数字进行交换 void swap01(int a, int b) { int temp = a; a = b; b = temp; cout << "swap01 a = " << a << endl; cout << "swap01 b = " << b << endl; } void swap02(int *p1, int *p2) { int temp = *p1; *p1 = *p2; *p2 = temp; } int main() { //指针和函数 //1.值传递 int a = 10; int b = 20; //swap01(a, b); //cout << "a = " << a << endl; //cout << "b = " << b << endl; //2.地址传递（利用指针） 可以修饰实参 swap02(&a, &b); cout << "a = " << a << endl; cout << "b = " << b << endl; system("pause"); return 0; }案例描述：封装一个函数，利用冒泡排序，实现对整型数组的升序排序 例如数组：int arr[10]={4,3,6,9,1,2,10,8,7,5}
#include<iostream> using namespace std; //冒牌排序函数 void bubbleSort(int *arr, int len) //参数1--数组的首地址，参数2--数组长度 //C++在函数中不能值传递 因为不知道arr代表的是整个数组还是首地址 { for (int i = 0; i < len-1; i++) { for (int j = 0; j < len-i-1; j++) { //如果j > j+1的值，交换数字 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() { //1、先创建数组 int arr[10] = { 4,3,6,9,1,2,10,8,7,5 }; //数组长度 int len = sizeof(arr) / sizeof(arr[0]); //2、创建函数，实现冒泡排序 bubbleSort(arr, len); //3、打印排序后的数组 printArray(arr, len); system("pause"); return 0; }结构体属于用户自定义的数据类型，允许用户存储不同的数据类型 自定义数据类型：一些类型集合组成的一个类型
语法：struct 结构体名 {结构体成员列表}；
通过结构体创建变量的方式有三种： 1、struct 结构体名 变量名 2、struct 结构体名 变量名 = { 成员1值，成员2值...}； 3、定义结构体时顺便创建变量
#include<iostream> using namespace std; #include<string> //结构体定义 //1、创建学生数据类型： //自定义数据类型，一些类型集合组成的一个类型 struct student { //成员列表 string name; //姓名 int age; //年龄 int score; //分数 }stu3; //结构体变量创建方式3 int main() { //结构体创建方式1 struct student stu1; //关键字struct可以省略 （定义中不可以省，创建中可以省） //给stu1属性赋值，通过.访问结构体变量中的属性 stu1.name = "张三"; stu1.age = 20; stu1.score = 100; cout << "姓名：" << stu1.name << " 年龄：" << stu1.age << " 分数：" << stu1.score << endl; //结构体创建方式2 struct student stu2 = { "李四",19,90 }; cout << "姓名：" << stu2.name << " 年龄：" << stu2.age << " 分数：" << stu2.score << endl; //结构体创建方式3 stu3.name = "王五"; stu3.age = 18; stu3.score = 60; cout << "姓名：" << stu3.name << " 年龄：" << stu3.age << " 分数：" << stu3.score << endl; system("pause"); return 0; }一般用第1、2种较多，因为第三种在查看定义时容易被忽略 在定义结构体时struct关键字不可省略，创建结构体变量时可以省略
作用：将自定义的结构体放如到数组中方便维护 语法：struct 结构体名 数组名[元素个数] = { {},{},...{} }；
#include<iostream> using namespace std; #include<string> //创建结构体数组 //1、定义结构体 struct student { string name; //姓名 int age; //年龄 int score; //分数 }; int main() { //2、创建结构体数组 struct student stuArray[3]= { {"张三",18,100}, {"李四",28,80}, {"王五",38,60} }; //3、给结构体数组中的元素赋值 stuArray[2].name = "赵六"; stuArray[2].age = 80; stuArray[2].score = 60; //4、遍历结构体数组 for (int i = 0; i < 3; i++) { cout << stuArray[i].name <<"\t" <<stuArray[i].age<<"\t" << stuArray[i].score << endl; } system("pause"); return 0; }作用：通过指针访问结构体中的成员
利用操作符->可以通过结构体指针访问结构体属性 #include<iostream> using namespace std; #include<string> struct student { string name; //姓名 int age; //年龄 int score; //分数 }; int main() { //1、创建学生结构体变量 struct student s = { "张三",18,90 }; //2、通过指针指向结构体变量 student *p = &s; //3、通过指针访问结构体变量中的数据 //通过结构体指针访问结构体中的属性，需要运用->访问 cout << "姓名：" << (*p).name << " 年龄：" << p->age << " 分数：" << p->score << endl; //p->name相当于(*p).name system("pause"); return 0; }作用：结构体中的成员可以是另一个结构体 例如：每一个老师辅导一个学员，一个老师的结构体中，记录一个学生的结构体
#include<iostream> using namespace std; #include<string> struct teacher { int id; //编号 string name; //姓名 int age; //年龄 struct student stu; //学生 }; struct student { string name; //姓名 int age; //年龄 int score; //分数 }; int main() { //结构体嵌套结构体 //创建老师 teacher t; t.id = 10000; t.name = "老王"; t.age = 55; t.stu.age = 18; t.stu.name = "张三"; t.stu.score = 100; system("pause"); return 0; }作用：将结构体作为参数像函数中传递 传递方式有两种： 1、值传递 2、地址传递
#include<iostream> using namespace std; #include<string> struct student { string name; //姓名 int age; //年龄 int score; //分数 }; //值传递 void printStudent1(struct student s) { s.age = 100; cout << "在子函数中打印的信息：" << s.name << "\t" << s.age << "\t" << s.score << endl; } //地址传递 void printStudent2(struct student * s) { (*s).age = 100; cout << "在子函数中打印的信息：" << (*s).name << "\t" << (*s).age << "\t" << (*s).score << endl; } int main() { //结构体做函数参数 //将学生传入到一个参数中，打印学生身上所有信息 //创建结构体变量 struct student s; s.name = "张三"; s.age = 18; s.score = 100; //cout << "在main函数中打印的信息：" << s.name<<"\t" << s.age << "\t" << s.score << endl; printStudent1(s); //printStudent2(&s); cout << "在main函数中打印的信息：" << s.name << "\t" << s.age << "\t" << s.score << endl; system("pause"); return 0; }作用：用const来防止误操作
#include<iostream> using namespace std; #include<string> struct student { string name; //姓名 int age; //年龄 int score; //分数 }; //将函数中的形参改为指针，可以减少内存空间，而且不会复制新的副本出来，但存在信息被改动的隐患==》加const void printStudent(const student *s) { //s->age = 150; 加入const之后，一旦有修改操作会报错 cout << "姓名：" << s->name << " 年龄：" << s->age << " 分数：" << s->score << endl; } int main() { //创建结构体变量 student s = { "张三",18,90 }; //通过函数打印结构体变量信息 printStudent(&s); system("pause"); return 0; }案例描述： 学校正在做毕设项目，每名老师带领5个学生，总共有3名老师，需求如下： 设计学生和老师的结构体，其中在老师的结构体中，有老师姓名和一个存放5名学生的数组作为成员 学生的成员有姓名、考试分数 创建数组存放3名老师，通过函数给每个老师及所带的学生赋值 最终打印出老师数据以及老师所带的学生的数据
#include<iostream> using namespace std; #include<string> #include<ctime> //学生的结构体 struct student { string sName; int score; }; //老师的结构体 struct teacher { string tName; struct student sArray[5]; }; //给老师和学生们赋值的函数 void allocateSpace(struct teacher tArray[],int len) { string nameSeed = "ABCDE"; //给老师赋值 for (int i = 0; i < len; i++) { tArray[i].tName = "Teacher_"; tArray[i].tName += nameSeed[i]; //通过循环给每名老师所带的学生赋值 for (int j = 0; j < 5; j++) { tArray[i].sArray[j].sName = "Student_"; tArray[i].sArray[j].sName += nameSeed[j]; int random = rand() % 61 + 40; //表示随机出一个40~100之间的数 rand()%60表示0~60之间的数 tArray[i].sArray[j].score = random; } } } //打印所有信息函数 void printInfo(struct teacher tArray[], int len) { for (int i = 0; i < len; i++) { cout << "老师姓名为：" << tArray[i].tName << endl; for (int j = 0; j < 5; j++) { cout << "\t学生姓名为：" << tArray[i].sArray[j].sName << " 分数为： " << tArray[i].sArray[j].score << endl; } } } int main() { //随机数种子 srand((unsigned int)time(NULL)); //创建3名老师的数组 teacher tArray[3]; //通过函数给3名老师的信息赋值，并给老师带的学生信息赋值 int len = sizeof(tArray) / sizeof(tArray[0]); allocateSpace(tArray, len); //打印所有老师及所带学生的信息 printInfo(tArray, len); system("pause"); return 0; }案例描述： 设计一个英雄的结构体，包括成员姓名，年龄，性别 创建结构体数组，数组中存放5名英雄 通过冒泡排序的算法，将数组中的英雄按照年龄进行升序排序 最终打印排序后的结果
五名英雄信息如下： 1、{“刘备”，23，“男”}， 2、{“关羽”，22，“男”}， 3、{“张飞”，20，“男”}， 4、{“赵云”，21，“男”}， 5、{“貂蝉”，19，“女”}，
#include<iostream> using namespace std; #include<string> //1、设计英雄的结构体 struct hero { string name; int age; string sex; }; //冒泡排序函数 void bubbleSort(hero heroArray[], int len) { for (int i = 0; i < len-1; i++) { for (int j = 0; j < len-i-1; j++) { if (heroArray[j].age > heroArray[j + 1].age) { hero temp = heroArray[j]; heroArray[j] = heroArray[j + 1]; heroArray[j + 1] = temp; } } } } //打印输出函数 void printHero(hero heroArray[],int len) { for (int i = 0; i < len; i++) { cout << "姓名：" << heroArray[i].name << " 年龄：" << heroArray[i].age << " 性别：" << heroArray[i].sex << endl; } } int main() { //2、创建数组存放5名英雄 hero heroArray[5] = { {"刘备",23,"男"}, {"关羽",22,"男"}, {"张飞",20,"男"}, {"赵云",21,"男"}, {"貂蝉",19,"女"}, }; int len = sizeof(heroArray) / sizeof(heroArray[0]); /*for (int i = 0; i < len; i++) { cout << "姓名：" << heroArray[i].name << " 年龄：" << heroArray[i].age << " 性别：" << heroArray[i].sex << endl; }*/ //3、对数组进行排序，按照年龄进行升序排序 bubbleSort(heroArray, len); //4、打印输出 printHero(heroArray,len); system("pause"); return 0; }