学习笔记 | C++ | C++基础复习

原创已于 2022-07-14 23:07:31 修改 · 1k 阅读

2 ·

CC 4.0 BY-SA版权

文章标签：

#c++ #学习

于 2022-06-05 18:05:18 首次发布

本文是C++基础知识的复习笔记，涵盖了变量、常量、关键字、标识符命名规则、数据类型（包括整型、浮点型、字符型、字符串型等）、运算符、程序流程结构（选择、循环、跳转语句）、数组、函数、指针（包括空指针和野指针的处理）以及结构体的定义与应用。

C++基础复习

1.变量——给内存空间起名，方便管理内存

//数据类型 + 变量名 = 起始值；
int a = 1;

2.常量——记录程序中不可更改的数据

//#define 常量名 常量值
#define day 7

//const 数据类型 + 变量名 = 起始值；
const month = 12;

3.关键字——C++中预先保留的单词

定义变量或者常量的时候，不要用关键字（会发生歧义）

4.标识符命名规则——（变量，常量）命名规则

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

5.数据类型——给变量分配一个合适的内存空间（不同类型分配的内存空间是不一样的，空间越大取值范围越广）

5.1整型

数据类型	占用空间	取值范围
short——短整型	2字节	-2^15 ~ 2^15-1
int——整型	4字节	-2^31 ~ 2^31-1
long——长整型	windows下4字节，linux_32位下4字节，linux_64位下8字节	-2^31 ~ 2^31-1
long long ——长长整型	8字节	-2^63 ~ 2^63-1

5.2size关键字——统计数据类型所占大小

//sizeof(数据类型/变量)
cout << sizeof(int) << endl;

5.3实型（浮点型）

数据类型	占用空间	取值范围
float——单精度	4字节	7位有效数字
double——双精度	8字节	15 ~ 16位有效数字

//如果不加f(3.14)会自动转换为double
float f1 = 3.14f;

//科学计数法：

//3*10^2
float f1 = 3e2;
//3*0.1^2
float f2 = 3e-2;

5.4字符型

用单引号括值
单引号内只能有一个字符

//求字符型变量对应的ASCⅡ码
//a - 97
//A - 65
char ch = 'a';
cout << (int)ch <<endl;

5.5转义字符

转义字符	含义	ACSⅡ码
\n	换行	010
\t	TAB	009
\	“\”	092

5.6字符串型

C风格字符串

//char 变量名[] = "字符串值";
char str1[] = "hello world";
cout << str1 << endl;

c++风格字符串

//首先需要导入#include<string>
//string 变量名[] = "字符串值";
string str2 = "hello world";
cout << str2 << endl;

5.7布尔类型

true —— 真（1）

false —— 假（0）

bool flag = true;
//返回1（因为true）
cout << flag << endl;

5.8数据的输入

从键盘获取数据

//cin >> 变量
int a = 0;
cout << "请输入整形变量：" << endl;
cin >> a;
cout << a << endl;

6.运算符——用于执行代码运算

6.1算术运算符——处理四则运算

运算符	术语	示例	结果
+	正号	+1	1
-	负号	-1	-1
+	加	1+1	2
-	减	1-1	0
*	乘	2*2	4
/	除	2/2	1
%	取模（取余）	10%3	1
++	前置递增	a=2;b=++a;	a=3;b=3;
++	后置递增	a=2;b=a++;	a=3;b=2;
–	前置递减	a=2;b=–a;	a=1;b=1;
–	后置递减	a=2;b=a–;	a=1;b=2;

6.2赋值运算符——将表达式的值赋给变量

运算符	术语	示例	结果
=	赋值	a=2;b=3;	a=2;b=3;
+=	加等于	a=0;a+=2;	a=2;
-=	减等于	a=5;a-=3;	a=2;
*=	乘等于	a=2;a*=2;	a=4;
/=	除等于	a=4;a/=2;	a=2;
%=	模等于	a=3;a%=2;	a=1;

6.3比较运算符——比较表达式，并返回真或假

运算符	术语	示例	结果
==	相等于	4 == 3	0
!=	不等于	4 !=3	1
<	小于	4 < 3	0
>	大于	4 > 3	1
<=	小于等于	4 <= 3	0
>=	大于等于	4 >= 3	1

6.4逻辑运算符——根据表达式的值，返回真或假

运算符	术语	示例	结果
!	非	!a	如果a假，!a真；如果a真，!a假。
&&	与	a && b	如果a和b都真，结果真，否则假
\|\|	或	a \|\| b	如果a和b有一个真，结果真，否则假

7.程序流程结构——顺序，选择，循环

7.1选择结构

if语句

单行、多行、多条件、嵌套

三目运算符

表达式1 ? 表达式2 : 表达式3 //表达式1真 -> 表达式2，否则表达式3

switch语句

switch(表达式)
{
	case 结果1: 执行语句;back;
	case 结果1: 执行语句;back;
	default: 执行语句;back;
}

7.2循环结构

while循环
```
while(循环条件){循环语句}
```
do…while循环
```
do{循环语句}while{循环条件};
```

for循环

for(起始表达式;条件表达式;末尾循环体){循环语句;}

嵌套循环
```
循环套循环
```

7.3跳转语句

break语句

跳出选择结构或者循环结构
continue语句

循环语句中，跳过本次循环，继续下一次循环

goto语句

跳转到标记的位置

跳过“3.___”
cout << "1.___" << endl; 
cout << "2.___" << endl; 
goto FLAG;
cout << "3.___" << endl; 
FLAG:
cout << "4.___" << endl;

8.数组——相同数据类型的数据元素的集合（数据类型相同、连续的内存位置）

8.1一维数组

定义

//数据类型 数组名[数组长度];
int score[3];
//数据类型 数组名[数组长度] = {值1,值2，...};//起始化中没定值的数据会用0来填补
int score[4] = {5,5,5};
//数据类型 数组名[] = {值1,值2，...};
int score[] = {5,5,5};

cout << "数组中元素个数为：" << sizeof(score) / sizeof(score[0]) <<endl;
cout << "数组首地址为：" << score <<endl;
cout << "数组中第一个元素地址为：" << &arr[0] <<endl;

一些实例

//倒序排列
int main() {
	int arr[5] = { 1,2,3,4,5 };
	int a = sizeof(arr)/ sizeof(arr[0]);
	int b;
	for (int i = 0; i < a; i++) {
		cout << arr[i] << ",";
	}
	cout << endl;
	cout << "a=" <<a << endl;
	for (int i = 0; i < a/2; i++) {
		b = arr[i];
		arr[i] = arr[a-1];
		arr[a-1] = b;
		a--;
	}
	a = sizeof(arr) / sizeof(arr[0]);
	for (int i = 0; i < a; i++) {
		cout << arr[i] <<",";
	}
	return 0;
}

//降序排列
int main() {
	int arr[5] = { 45,65,78,23,85 };
	int a = sizeof(arr)/ sizeof(arr[0]);
	int b;
	for (int i = 0; i < a; i++) {
		for(int j = i+1; j < a; j++ ){
			b = arr[i];
			if (b < arr[j]) {
				arr[i] = arr[j];
				arr[j] = b;
			}
		}
		for (int i = 0; i < a; i++) {
			cout << arr[i] << ",";
		}
		cout << endl;
	}
	return 0;
}

8.2二维数组

定义

//数据类型 数组名[ 行数 ][ 列数 ];
int score[2][3];
//数据类型 数组名[ 行数 ][ 列数 ] = {{值1,值2，...},{值n,值n+1，...}};
int score[2][3] = {
    {1,2,3},
    {4,5,6}
};
//数据类型 数组名[ 行数 ][ 列数 ] = {值1,值2，...};
int score[2][3] = {1,2,3,4,5,6};
//数据类型 数组名[  ][ 列数 ] = {值1,值2，...};
int score[][3] = {1,2,3,4,5,6};

9.函数——将一段经常使用的代码封装起来，减少代码

9.1定义

//返回值类型 函数名(参数列表) {
	函数体语句 
	return表达式
}
int add(int num1,int num2){
	int sum = num1 + num2;
	return sum;
}

9.2调用

//函数名(参数)
int main(){
	int a = 1;
	int b = 2;
	//调用add函数
	int sum = add(a,b);
	cout << "sum=" << sum <<endl;
}

9.3样式

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

9.4声明

//声明可以多次，定义只能一次
//声明
int max(int a,int b);
//定义
int max(int a,int b){
	return a > b ? a : b;
}

9.5分文件编写

//1.创建后缀名为.h的头文件
//2.创建后缀名为.cpp的源文件
//3.在头文件中写函数的声明
//4.在源文件中写函数的定义
//5.调用时引入头文件

//swap.h文件（头文件）

#include<iostream>//引入c++框架
using namespace std;

void swap(int a,int b);

//swap.cpp文件（源文件）

#include"swap.h"//引入头文件

void swap(int a,int b){
	int temp = a;
	a = b;
	b = temp;
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
}

//调用函数的文件

#include<iostream>
#include<string>

using namespace std;
#include"swap.h"//引入头文件

int main() {
	int a = 10;
	int b = 20;
	swap(a, b);
	return 0;
}

10.指针——可以通过指针间接访问内存

10.1指针的定义和使用

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

int a = 10;
int * p;//数据类型要一致（int 对 int）
p = &a;
cout << "a的地址为" << p <<endl;

//使用指针（使用解引用的方法来找到指针所指向的内存）

*p = 1000;
cout << " a = " << a << emdl;
cout << " *p = " << *p <<endl;

10.2空指针

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

用途：起始化指针变量

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

0~255之间的内存是系统占用的，因此不可以访问

解引用空指针——————程序崩溃

int * p = NULL;
cout << "指针p保存的低地址：" << p << endl;//结果为0

10.3野指针

在程序中，应尽量避免，要求对暂时闲置的指针一定先初始化为NULL

概念：指针变量指向不可知的（随机的，不正确的，没又明确限制的）内存空间

解引用野指针——————程序数据错乱

int * p;//未起始化

int * p = NULL;
{
    int number = 0;
    p = &number;
}
cout << p <<endl;//number占用的空间已经被释放

int * p = (int *)0x1100;//随机抽取的空间

10.4const修饰指针

const修饰指针的三种情况：

const修饰指针——常量指针（指针的指向可以修改，但指针指向的值不可以改）
const修饰常量——指针常量（指针的指向不可以改，但指针的指向的值可以改）

const既修饰指针，又修饰常量（指针的指向不可以改，并且指针的指向的值也不可以改）

//无修饰状态
int a = 10;
int b = 20;
int * p = &a;

//常量指针
int a = 10;
int b = 20;
const int* p = &a;
*p = 1000;//报错
p = &b;

//指针常量
int a = 10;
int b = 20;
int * const p = &a;
*p = 1000;
p = &b;//报错

//既修饰指针又修饰常量
const int * const p = &a;

10.5指针和数组

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

10.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;
    retrun 0;
}

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

11.1定义及使用

//struct 结构体名 { 结构体成员列表 };
struct Student {
	string name;
	int age;
	int score;
};

int main() {
	struct Student s1;//此处struct可以省略
	s1.name = "张三";
	s1.age = 12;
	s1.score = 85;

	cout << "姓名：" << s1.name << "  年龄：" << s1.age << "  分数：" << s1.score << endl;
	return 0;
}

11.2结构体数组

//struct 结构体名 数组名[元素个数] = { {}, {}, ...{} }
struct Student {
    string name;
    int age;
    int score;
};
int main() {
    //结构体数组
    struct Student arr[3] = {
        {"张三", 15, 15},
        {"李四", 13, 65},
        {"王五", 18, 65}
    };
    arr[2].name = "安安";
    arr[2].age = 56;
    arr[2].score = 56;

    for (int i = 0; i < 3; i++) {
        cout << "姓名：" << arr[i].name << "  年龄：" << arr[i].age << "  分数：" << arr[i].score << endl;
    }
}

11.3结构体指针

struct Student {
    string name;
    int age;
    int score;
};
int main() {
    struct Student stu = {"张三", 15, 15};
    //结构体指针
    struct Student * p = &stu;
    for (int i = 0; i < 3; i++) {
        cout << "姓名：" << p->name << "  年龄：" << p->age << "  分数：" << p->score << endl;
    }
}

11.4结构体嵌套

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

struct Teacher {
    int id;
    string name;
    int age;
    //嵌套Student结构体
    struct Student stu;
};
int main() {
    Teacher t;
    t.id = 1;
    t.name = "老王";
    t.age = 85;
    t.stu.name = "张三";
    t.stu.age = 12;
    t.stu.score = 60;

    cout << "老师姓名：" << t.name << "  老师年龄：" << t.age << "  学生姓名：" << t.stu.name << "  学生年龄：" << t.stu.age << "  学生分数：" << t.stu.score << endl;
}

11.5结构体做函数参数

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

//值传递
void printStudent(Student stu) {
    stu.age = 24;
    cout << "子函数中 姓名：" << stu.name << "年龄：" << stu.age << "分数：" << stu.score << endl;
}
//地址传递
void printStudent(Student * p) {
    p->age = 24;
    cout << "子函数中 姓名：" << p->name << "年龄：" << p->age << "分数：" << p->score << endl;
}

int main() {
    struct Student s;
    s.name = "张三";
    s.score = 54;
    cout << "值传递" << endl;
    printStudent(s);
    cout << "地址传递" << endl;
    printStudent(&s);
}

11.6结构体中const使用场景

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

//使用地址传值是为了节省开销
void printStudent(const Student * p) {
    //p->age = 24; //防止误操作改变数据
    cout << "子函数中 姓名：" << p->name << "年龄：" << p->age << "分数：" << p->score << endl;
}

int main() {
    struct Student s;
    s.name = "张三";
    s.age = 15;
    s.score = 54;
    cout << "地址传递" << endl;
    printStudent(&s);
}