《四海小记c++学习之路》第一阶段基础

第一阶段基础
- 1 c++初识
- - 1.1 第一个c++程序
  - - 1.1.1创建项目
    - 1.1.3 c++书写Helloworld
  - 1.2 注释
  - 1.3 变量
  - 1.4 常量
  - 1.5 关键字
  - 1.6 标识符命名规则
- 2 数据类型
- - 2.1 整形
  - 2.2 sizeof关键字
  - 2.3 实型（浮点型）
  - 2.4 字符型
  - 2.5 转义字符
  - 2.6 字符串型
  - 2.7 布尔类型 bool
  - 2.8 数据的输入
- 3 运算符
- - 3.1 算数运算符
  - 3.2 赋值运算符
  - 3.3 比较运算符
  - 3.4 逻辑运算符
- 4 程序流程结构
- - 4.1 选择结构
  - - 4.1.1 if语句
    - 4.1.3 switch语句
  - 4.2 循环结构
  - - 4.2.1 while循环语句
    - 4.2.2 do...while循环语句
    - 4.2.3 for循环语句
    - 4.2.4 嵌套循环
  - 4.3 跳转语句
  - - 4.3.1 break语句
    - 4.3.2 continue语句
    - 4.3.3 goto 语句
- 5 数组
- - 5.1 概述
  - 5.2 一维数组
  - - 5.2.1 一维数组定义方式
    - 5.2.2 一维数组的数组名
    - 5.2.3 冒泡排序
  - 5.3 二维数组
  - - 5.3.1 二维数组的定义方式
- 6 函数
- - 6.1 概述
  - 6.2 函数的定义
  - 6.3 函数的调用
  - 6.4 值传递
  - 6.5 函数的常见样式
  - 6.6 函数的声明
- 7 指针
- - 7.1 指针的基本概念
  - 7.2 指针变量定义和使用
  - 7.3 指针所占内存空间
  - 7.4 空指针和野指针*
  - 7.5 const修饰指针
  - 7.6 指针和数组
  - 7.7 指针和函数
  - 7.8 指针、数组、函数
- 8 结构体
- - 8.1 结构体基本概念
  - 8.2 结构体定义和使用
  - 8.3 结构体数组
  - 8.4 结构体指针
  - 8.5 结构体嵌套结构体
  - 8.6 结构体做函数参数
  - 8.7 结构体中constd使用场景
- 通讯录管理系统

第一阶段基础

目的：对c++有初步了解，能够有基础编程能力

案例：通讯录管理系统

1 c++初识

1.1 第一个c++程序

编写一个c++程序总共分为4个步骤

创建项目
创建文件
编写代码
运行程序

1.1.1创建项目

visual Studio是我们用来编写c++程序的主要工具，我们先将它打开

点击创建新项目

然后找到c++的空项目，点击下一步

填写你的项目名称以及你要存放的位置，然后点击创建

在右边栏中找到源文件，右键->添加->新建项

找到c++文件（.cpp）填写你的cpp文件项目名，然后点击添加，这就创建好了你的第一个.cpp文件

1.1.3 c++书写Helloworld

#include<isotream>             //头文件using namespace std;           //命名空间int main(){cout<<"Helloworld"<<endl;    //endl作为换行可加可不加system("pause");           //等待用户按键return 0;}

1.2 注释

作用：在代码中加一些说明和解释，方便自己或其他程序员阅读代码

两种风格

1.单行注释 //描述信息

通常放在一行代码的上方，或者一条语句的末尾，对该行代码说明

2.多行注释/*描述信息*/

通常放在一行代码的上方，对该段代码做整体说明

提示：编译器在编译代码时，会忽略注释的内容

注释规范

/**************************************
Copyright       陈四海
Author:         created by 陈四海
Date:           2020-11-26
Description:    代码注释规范
Version:        1.0
**************************************//**************************************
Fuction:         函数名
Description:     作用描述
Input:           输入
Output:          输出
Return:          返回
Others:          其他
**************************************/

不记得从哪里嫖来的注释规范了，感觉挺好用的

1.3 变量

作用:给一段指定的内存空间起名，方便操作这段内存

语法1：数据类型变量名=初始值

语法2：数据类型变量名=有返回值函数

示例：

#include<iostream>using namespace std;int main(){//变量的定义//语法1：数据类型 变量名=初始值int i=0;//语法2：数据类型 变量名=有返回值函数int src=imread("D:/1.jpg");//opencv中导入图片return 0;}

1.4 常量

作用:用于记录程序中不可更改的数据

c++定义常量两种方式

1.#define 宏常量： #define 常量名常量值

通常在文件上方定义，表示一个常量

2.const修饰的变量 const 数据类型常量名 = 常量值

通常在变量定义前加关键字const，修饰该变量为常量，不可修改

示例：

#include<iostream>//宏常量
#define DEBUG //宏常量要全部大写using namepace std;int main(){//const修饰的变量const int a=0;system("pause");return 0;
}

1.5 关键字

作用：关键字是c++中预先保留的单词（标识符）

在定义变量或常量的时候，不要使用关键字

c++关键字如下：

提示：在给变量或常量起名称的时候，不要使用c++关键字，否者会引起歧义

1.6 标识符命名规则

作用：c++规定给标识符（变量、常量）命名时，有一套自己的规则

标识符不能是关键字
标识符只能由字母、数字、下划线组成
第一个字符必须为字母或下划线
标识符在中字母区分大小写

建议：给标识符命名时，争取做到见名知意的效果，方便自己和他人的阅读

2 数据类型

c++规定在创建一个变量或者常量时，必须要指定出相应的数据类型，否者无法给变量分配内存

2.1 整形

作用：整形变量表示的是整数类型的数据

c++中能够表示整形的类型有以下几种方式，区别在于所占内存空间不同：

2.2 sizeof关键字

作用：利用sizeof关键字可以统计数据类型所占内存大小

语法：sizeof（数据类型/变量）

**扩展：**在vector<数据类型> 变量名中可以通过.size()的方式获得该变量的大小

sizeof（）以及size（）大多用于循环某个数组

示例：

int main()
{int a;cout<<"a的大小为："<<sizeof(a)<<endl;vector<int> b;cout<<"b的大小为："<<b.size()<<endl;return 0;
}

2.3 实型（浮点型）

作用：用于表示小数

浮点型变量分为两种：

单精度浮点型 float
双精度浮点型 double

二者的区别在于表示的有效数字范围不同。

就是int<float<double现在一般不用考虑这个在前期float就基本公用了

2.4 字符型

作用：字符型变量用于显示单个字符

语法：char ch = ‘a’;

注意1：在显示字符型变量时，用但以后你好将字符括起来，不要用双引号（字符串才用双引号）

注意2：单引号内只能有一个字符，不可以是字符串

c和c++中字符型变量只占1个字节
字符型变量并不是把字符本身放到内存中储存，而是将对应的ASCII编码放入存储单元

示例：

int main()
{//字符变量定义char ch = 'a';//字符串变量定义char _ch[]="abcd"return 0;
}

2.5 转义字符

作用：用于表示一些不能显示出来的ASCII字符

现阶段我们常用的转义字符有： \n \\ \t

即用即查，不用记、

2.6 字符串型

作用：用于表示一串字符

两种风格

C分格字符串： char 变量名[] = “字符串值”
C++风格字符串：string 变量名 = “字符串值”

示例：

   int main(){char str1[] = "hello world";cout<<str1<<endl;string str2 = "hello world";cout<<str2<<endl;return 0;}

2.7 布尔类型 bool

作用：布尔数据类型代表真或假的值

bool类型只有两个值：

true — 真（本质是1）
false — 假（本质是0）

bool类型占一个字节大小

示例：

int main()
{//bool类型一般用于函数类型bool a();//通过返回值的真假，来判断该函数输出是否正确return 0;
}

2.8 数据的输入

作用：用于从键盘获取数据

关键字：cin

语法：cin>>变量

示例：

int main()
{int a;cin>>a;cout<<a<<endl;return 0;
}

3 运算符

作用：用于执行代码的运算

本章主要有以下几类运算符

3.1 算数运算符

作用：用于处理四则运算

算数运算符包括以下符号：

3.2 赋值运算符

作用：用于将表达式的值赋给变量

赋值运算符包括以下几个符号：

3.3 比较运算符

作用：用于表达式的比较，并返回一个真值或假值

比较运算符有以下符号：

3.4 逻辑运算符

作用：用于根据表达式的值返回真值或假值

逻辑运算符有以下符号：

4 程序流程结构

c/c++支持最基本的三种程序运算结构：顺序结构、选择结构、循环结构

顺序结构：程序按顺序执行，不发生跳转
选择结构：依据条件是否满足，有选择的执行相应的功能、
循环结构：依据条件是否满足，循环多次执行某段代码

4.1 选择结构

4.1.1 if语句

作用：执行满足条件的语句

if语句的三种形式

单行格式if语句
多行格式if语句
多条件的if语句

语法：if(判断条件){执行语句}；//当判断语句为真的时候执行

4.1.3 switch语句

作用：执行多条件分支语句

语法：

switch（表达式）
{case 结果1：执行语句；break;case 结果2：执行语句；break;...default:执行语句;break;//default用得比较少
}

4.2 循环结构

4.2.1 while循环语句

作用：满足循环条件，执行循环语句

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

解释：只要循环条件的结果为真，就执行循环语句

4.2.2 do…while循环语句

作用：满足循环条件，执行循环语句

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

注意：与while的区别在于do…while会先执行一次循环语句，在判断循环条件

4.2.3 for循环语句

作用：满足循环条件，执行循环语句

语法： for（起始表达式；条件表达式；尾句循环体）{循环语句；}

示例：

int main()
{//基础用法for(int i=0;i<100;i++){cout<<i<<endl;}//其他用法for(int i=0;i<100;cout<<i++<<endl);return 0;
}

4.2.4 嵌套循环

作用：在循环体中在嵌套一层循环，解决一些实际问题

示例：

int main()
{for(int i=0;i<100-1;i++)for(int j=i+1;j<100-1;j++)cout<<"*"<<endl;return 0;
}

4.3 跳转语句

4.3.1 break语句

作用：用于跳出选择结构或者循环结构

break使用的时机：

出现在switch条件语句中，作用是中止case并跳出switch
出现在循环语句中，作用是跳出当前循环语句
出现在嵌套循环中，跳出最近的内层循环语句

4.3.2 continue语句

作用：在循环语句中，跳过本次循环中余下尚未执行的语句，继续执行下一次循环

4.3.3 goto 语句

作用：可以无条件跳转语句

语法：goto 标记；

解释：如果标记名称存在执行到goto语句时，会跳转到标记的位置

//goto基本没人用了

5 数组

5.1 概述

所谓数组就是一个集合，里面存放了相同类型的数据元素

特点1：数组中的每个数据元素都是相同的数据结构

特点2：数组是由连续的内存位置组成的

5.2 一维数组

5.2.1 一维数组定义方式

一维数组定义的三种方式：

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

示例：

int main()
{//定义方式1int a1[20];//定义方式2int a2[3]={1,2,3};//定义方式3int a3[]={1,2,3};return 0;
}

5.2.2 一维数组的数组名

一维数组名称的用途：

可以统计整个数组在内存中的长度
可以获得数组在内存中的首地址

示例：

int main()
{//数组名用途//1.可以获得整个数组占用内存空间大小int arr[10]={1,2,3,4,5,6,7,8,9,0};cout<<"整个数组所占内存空间为："<<sizeof(arr)<<endl;cout<<"每个元素所占内存空间为："<<sizeof(arr[0])<<endl;cout<<"数组的元素个数为"<<sizeof(arr)/sizeof(arr[0])<<endl;//2.可以通过数组名获取到数组的首地址cout<<"数组的首地址为:"<<(int)arr<<endl;cout<<"数组中第一个元素地址为："<<(int)&arr[0]<<endl;//arr=100;错误，数组名是常量，因此不可以赋值return 0;
}

5.2.3 冒泡排序

作用:最常用的排序算法，对数组内元素进行排序

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

示例：将数组{1，4，5，3，7，2}进行升序排序

int main()
{int arr[6]={1，4，5，3，7，2};for(int i=0;i<6-1;i++)for(int j=0;j<6-i-1;j++)if(arr[j]>arr[j+1]){int temp = arr[j];a[j]=a[j+1];a[j+1]=temp;}return 0;
}

5.3 二维数组

二维数组就是在一维数组上，多加一个维度。

5.3.1 二维数组的定义方式

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

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

建议：以上四种定义方式，利用第二种更加直观，提高代码的可读性

示例：

int main()
{//方式1//数组类型 数组名 [行数][列数]int arr[2][3];arr[0][0]=1;arr[0][1]=2;arr[1][0]=3;arr[1][1]=4;//剩下就不写了return 0;
}

6 函数

6.1 概述

作用：将一段经常使用的代码封装起来，减少重复代码

一个较大的程序，一般分为若干个程序块，每个模块实现特定的功能。

6.2 函数的定义

函数的定义一般主要有五个步骤：

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

语法：

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

6.3 函数的调用

功能：使用定义好的函数

语法：函数名（参数）

示例：

//函数定义
int add(int num1,int num2)//定义中的num1，num2称为形式参数，简称形参
{int sum=num1+num2;return sum;
}
int main(){int a = 10;int b = 10;//调用add函数int sum=add(a,b);//调用时的a,b称为实际参数，简称实参cout<<"sum = "<<sum<<endl;a=100;b=100;c= add(a,b);cout<<"c="<<c<<endl;
}

6.4 值传递

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

示例：

void swap(int num1,int num2)
{cout<<"交换前："<<endl;cout<<"num1="<<num1<<endl;cout<<"num2="<<num2<<endl;int temp=num1;num1=num2;num2=temp;cout<<"交换后："<<endl;cout<<"num1 = "<<num1<<endl;cout<<"num2 = "<<num2<<endl;
}
int main()
{int  a=10;int  b=20;cout<<"a="<<a<<endl;cout<<"b="<<b<<endl;//当我们做值传递的时候，函数的形参发生改变，但并不会影响实参sawp(a,b);cout<<"a="<<a<<endl;cout<<"b="<<b<<ednl;return 0;
}

6.5 函数的常见样式

常见的函数样式有4种

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

示例：

//函数常见样式
//1、无参返回
void test1()
{cout<<"this is test1"<<endl;
}
//2、有参返回
void test2(int a)
{cout<<"this is test2 a="<<a<<endl;
}
//3.无参有返
int test3()
{int a=100;cout<<"this is test3"<<endl;return a;
}
//有参有返
int test4(int a)
{cout<<"this is test4"<<endl;return a;
}

6.6 函数的声明

作用：告诉编译器函数名称及如何调用函数，函数的主体可以单独定义。

函数的声明可以多次，但是函数的定义只能有一次

7 指针

7.1 指针的基本概念

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

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

7.2 指针变量定义和使用

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

示例：

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

7.3 指针所占内存空间

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

解答：（x86）下为4个字节/（x64）下为8个字节，因为指针是用来存储地址的，所以不需要太多的内存空间，不会因为数据类型的改变而改变

示例：

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

7.4 空指针和野指针*

这个问题我经常犯，要注意！

空指针：指针变量指向内存中编号为0的空间

用途：初始化指针变量

注意：空指针指向的内存是不可以访问的

示例1：空指针

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

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

示例：野指针

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

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

7.5 const修饰指针

const修饰指针有三种情况：

const修饰指针 —常量指针
const修饰指针 —指针常量
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;return 0;
}

7.6 指针和数组

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

示例：

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

7.7 指针和函数

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

示例：

//值传递
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;//1、值传递swap1(a,b);cout<<a<<b<<endl;//第一次系统会保留cout<<a<<b<<endl;//第二次不会//2、地址传递int * pa = &a;int * pb = &b;swap2(pa,pb);cout<<a<<b<<endl;//cout<<a<<b<<endl;//return 0;
}

7.8 指针、数组、函数

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

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

示例：

//冒泡排序函数
void bubbleSort(int * arr, int len)//int * arr 也可以写成 arr[]
{for(int i = 0; i < len - 1; i++){for(int j = 0;j<len - 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 arr[10] = {4,3,6,9,1,2,10,8,7,5};bubbleSort(arr,sizeof(arr)/sizeof(arr[0]));for(int i = 0; i < 10; cout << arr[i++]);return 0;
}

8 结构体

8.1 结构体基本概念

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

8.2 结构体定义和使用

语法： struct 结构体名 { 结构体成员列表 }；

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

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

示例：

//结构体定义
//1、创建学生数据类型：学生包括（姓名，年龄，分数）
//自定义数据类型，一些类型集合的一个类型
//语法 struct 结构体名 变量名 = {成员列表 };
struct student
{//成员列表string name;//名字int age; //年龄int score;  //分数
}s3;//创建结构体时顺便创建结构体变量
int main(){//1.struct 结构体名 变量名;struct student s1;//创建结构体变量的时候struct是可以省略的s1.name = "张三";s1.age = 18;s1.score = 100;cout<<"姓名："<<s1.name << "年龄；"<< s1.age << "分数："<< s1.score<<endl;//2.struct 结构体名 变量名 = {成员1值，成员2值...};struct student s2 = {"李四", 19,80};cout<<"姓名："<<s2name << "年龄；"<< s2age << "分数："<< s2score<<endl;//3 在定义结构体时顺便创建结构体变量s3.name = "王五”;s3.age = 20;s3.score = 60;cout<<"姓名："<<s3.name<<"年龄；"<<s3.age<<"分数："<< s3.score<<endl;return 0;
}

8.3 结构体数组

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

语法： struct 结构体名数组名[元素个数] = {{},{},{}…}

示例：

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

8.4 结构体指针

作用：通过指针访问结构体中的成员(这个一般用于在函数内对结构体成员进行更改)

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

示例：

//结构体定义
struct student
{//成员列表string name;//名字int age; //年龄int score;  //分数
};
int main(){//创建学生变量struct student stu = {"张三", 18，100};//通过指针指向结构体变量struct student * p = &stu;//通过指针访问结构体变量中的数据cout<<"姓名："<< p->name<<"年龄:"<< p->age<<"分数:"<< p->score<<endl; return 0;
}

8.5 结构体嵌套结构体

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

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

示例：

//结构体定义
struct student
{//成员列表string name;//名字int age; //年龄int score;  //分数
};
//教师结构体定义
struct teacher
{//成员列表int id;//职员编号string name;//教师编号int age;  //教师年龄struct student stu;//子结构体 学生
}

8.6 结构体做函数参数

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

传递方式两种：

值传递 //用于遍历
地址传递 //用于增删改

示例：

//结构体定义
struct student
{//成员列表string name;//名字int age; //年龄int score;  //分数
};
//值传递、
void printStudent1(student stu)
{stu.age = 28;
}
//地址传递
void printStudent2(struct student * stu)
{}//这个前面讲过就不细写了

8.7 结构体中constd使用场景

作用：用const来防止误操作

示例：

//结构体定义
struct student
{//成员列表string name;//名字int age; //年龄int score;  //分数
};
//值传递、
void printStudent(const student *stu)
{//stu.age = 28;这时就无法对结构体内变量进行操作
}

通讯录管理系统