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

• • 1.变量——给内存空间起名，方便管理内存
  • 2.常量——记录程序中不可更改的数据
  • 3.关键字——C++中预先保留的单词
  • 4.标识符命名规则——（变量，常量）命名规则
  • 5.数据类型——给变量分配一个合适的内存空间（不同类型分配的内存空间是不一样的，空间越大取值范围越广）
  • • 5.1整型
    • 5.2size关键字——统计数据类型所占大小
    • 5.3实型（浮点型）
    • 5.4字符型
    • 5.5转义字符
    • 5.6字符串型
    • 5.7布尔类型
    • 5.8数据的输入
  • 6.运算符——用于执行代码运算
  • • 6.1算术运算符——处理四则运算
    • 6.2赋值运算符——将表达式的值赋给变量
    • 6.3比较运算符——比较表达式，并返回真或假
    • 6.4逻辑运算符——根据表达式的值，返回真或假
  • 7.程序流程结构——顺序，选择，循环
  • • 7.1选择结构
    • • if语句
      • 三目运算符
      • switch语句
    • 7.2循环结构
    • • while循环
      • do...while循环
      • for循环
      • 嵌套循环
    • 7.3跳转语句
    • • break语句
      • continue语句
      • goto语句
  • 8.数组——相同数据类型的数据元素的集合（数据类型相同、连续的内存位置）
  • • 8.1一维数组
    • 8.2二维数组
  • 9.函数——将一段经常使用的代码封装起来，减少代码
  • • 9.1定义
    • 9.2调用
    • 9.3样式
    • 9.4声明
    • 9.5分文件编写
  • 10.指针——可以通过指针间接访问内存
  • • 10.1指针的定义和使用
    • 10.2空指针
    • 10.3野指针
    • 10.4const修饰指针
    • 10.5指针和数组
    • 10.6指针和函数
  • 11.结构体——属于用户自定义的数据类型，允许用户储存不同的数据类型
  • • 11.1定义及使用
    • 11.2结构体数组
    • 11.3结构体指针
    • 11.4结构体嵌套
    • 11.5结构体做函数参数
    • 11.6结构体中const使用场景

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

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

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

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

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

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

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

//科学计数法：

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

• 用单引号括值

• 单引号内只能有一个字符

//求字符型变量对应的ASCⅡ码
//a - 97
//A - 65
char ch = 'a';
cout << (int)ch < 
5.5转义字符 
转义字符
含义
ACSⅡ码
n
换行
010
t
TAB
009
“”
092
5.6字符串型 
 
C风格字符串
 
//char 变量名[] = "字符串值";
char str1[] = "hello world";
cout << str1 << endl;
 
 
C++风格字符串
 
//首先需要导入#include
//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]) < 
 
一些实例
 
//倒序排列
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=" <
 
 
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 < 
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//引入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
#include

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 < 
//使用指针（使用解引用的方法来找到指针所指向的内存）

*p = 1000;
cout << " a = " << a << emdl;
cout << " *p = " << *p < 
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 < 
10.4const修饰指针 
const修饰指针的三种情况：
 
 
const修饰指针——常量指针（指针的指向可以修改，但指针指向的值不可以改）
 
 
const修饰常量——指针常量（指针的指向不可以改，但指针的指向的值可以改）
 
 
const既修饰指针，又修饰常量（指针的指向不可以改，但指针的指向的值也不可以改）
 
//无修饰状态
int a = 10;
int b = 20;
int * p = &a;
 
//常量指针
const int * p = &a;
 
//指针常量
int * const p = &a;
 
//既修饰指针又修饰常量
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 <//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);
}