【持更】
一、学习目标：
简易C++入门
学习简单的C++语法
二、学习内容：
1、 C++基础语法
第一章 C++初识
1-1.第一个C++程序
#include<iostream>
using namespace std;
int main()
{
cout << "Hello World"<<endl;
return 0;
}
1-2.注释
两种格式的注释：
（1）单行注释：
//注释内容写在此处
（2）多行注释：
/*多行注释写在此处*/
1-3.变量
（1）作用：方便我们管理内存空间。
（2）语法：
数据类型 变量名 = 变量初始值；
1-4.常量
（1）作用：用于记录程序中不可更改的数据
（2）两种定义方式：
①.#define 宏常量
语法：#define 常量名 常量值
【通常在文件上方定义，表示一个常量】
②.const修饰的变量
语法：const 数据类型 常量名 = 常量值
【通常在变量定义前加关键字const，修饰该变量为常量，不可修改】
1-5.关键字（标识符）
（1）作用：关键字是C++预先保留的单词（标识符）
所以在定义变量/常量时，不可以使用关键字，否则会产生歧义（2）标识符命名规则
①.标识符不能是关键字
②.标识符只能由字母、数字、下划线组成
③.第一个字符必须是数字或下划线
④标识符中的字母区分大小写
1-6.科学计数法
语法：float 变量名 = num1 e num2
num2 > 0 时，变量值 = num1*10num2
num2 < 0 时，变量值 = num1*10num2
第二章 数据类型
·数据类型存在的意义：给变量分配合适的内存空间
C++
2-1.sizeof 关键字
1.作用：利用sizeof关键字可以统计数据类型所占内存的大小
2.语法：sizeof（数据类型）或 sizeof（变量名）
整型大小比较：short < int <= long <= long long
2-2. 整型
·1.作用：整型变量表示的是整数类型的数据
·2.类型
2-3.实型（浮点型）
·1.作用：浮点变量表示的是小数类型的数据
·2.类型
·一般在定义单精度数的时候，都会在数据后加一个f，否则默认数据类型为双精度double类型的数字，如：float f1 = 3.14f；
2-4.字符型
·1.作用：字符型变量用于表示 单个字符。
·2.语法：char 变量名 = ‘字符’
如char ch1 = ‘a’；
·3.注意：
①.在显示字符型变量时，常用单引号将字符引起。
②.单引号中只能有一个字符，不可以是字符串
·4.性质（特点）
①.在C和C++中，字符变量仅占用一个字节
②.字符型变量不是把字符本身放入内存中存储，而是将对应的ASCII码放入存储单元
2-5.字符串型
·1.作用：字符串型变量用于表示 一个字符串。
·2.语法：①.char 变量名 [ ] = ‘字符串值’
如char str[ ] = ‘hello world’；
·该类型的定义方法字符串值需要用双括号包含字符串
②.string 变量名 = ‘字符串值’
如string str = hello world；
·该类型的定义需要有头文件 #include <string>
2-6.布尔类型（bool）
·1.作用：布尔值类型表示一个真或假的值
·2.分类：
①TRUE：真【本质是1】
②FALSE：假【本质是0】
·3.语法：bool 变量名 = false/true;
`4.占用内存：在C++中，布尔值仅占一个字节
2-7.数据的输入 cin
(1).作用：从键盘上获取数值
(2).语法：cin>>变量
2-8.转义字符
·1.作用：用于表示一些不能显示出来的ASCII字符
·2.重要的转义字符:
\n:换行【将当前位置移到下一行的开头】
\t:水平制表【跳到下一个TAB位置】
\\:一个反斜杠
第三章 运算符
3-1.算术运算符
作用：用于处理四则运算
- +（正号）
- -（负号）
- +（加号）
- -（减号）
- *（乘号）
- /（除号）
- %（取模）
·取模运算的本质就是求余数
·两个数相除，除数不能为零，所以也做不了取模运算
·两个小数不能做取模运算
- ++（前置递增）
先让变量相对自身加1，再进行表达式运算
#include<iostream>
using namespace std;
int main()
{
int a, b;
a = 2;
b = ++a;
cout<< "a = "<<a<<endl; //输出结果 a = 3
cout<< "b = "<<b<<endl; //输出结果 b = 3
return 0;
}
- ++（后置递增）
先让变量进行表达式运算，再相对自身加1
#include<iostream>
using namespace std;
int main()
{
int a, b;
a = 2;
b = a++;
cout<< "a = "<<a<<endl; //输出结果 a = 3
cout<< "b = "<<b<<endl; //输出结果 b = 2
return 0;
}
- --（前置递减）
先让变量相对自身减1，再进行表达式运算
#include<iostream>
using namespace std;
int main()
{
int a, b;
a = 2;
b = --a;
cout<< "a = "<<a<<endl; //输出结果 a = 1
cout<< "b = "<<b<<endl; //输出结果 b = 1
return 0;
}
- --（后置递减）
先让变量进行表达式运算，再相对自身减1
#include<iostream>
using namespace std;
int main()
{
int a, b;
a = 2;
b = --a;
cout<< "a = "<<a<<endl; //输出结果 a = 1
cout<< "b = "<<b<<endl; //输出结果 b = 2
return 0;
}
3-2.赋值运算符
作用：用于将表达式的值赋给变量
- =（赋值）
- +=（加等于）
a += 2; 等价于 a=a+2;
- -=（减等于）
a -= 2; 等价于 a=a-2;
- *=（乘等于）
a = 2; 等价于 a = a2;
- /=（除等于）
a /= 2; 等价于 a = a / 2;
- %=（模等于）
a %= 2; 等价于 a = a % 2;
3-3.比较运算符
作用：用于 表达式的比较，并返回一个真或假的值
- ==（相等于）
- !=（不等于）
- <（小于）
- >（大于）
- <=（小于等于）
- >=（大于等于）
3-4.逻辑运算符
·1.作用：用于根据表达式返回真假值
·2.分类：
- !（非） 若a为false，则!a为true
- &&（与）
- ||（或）
第四章 程序流程结构
4-0.引入
- C++支持最基本的三种程序运行结构：顺序结构、选择结构、循环结构
- 顺序结构：程序按顺序执行，不发生跳转
- 循环结构：依据条件是否满足，有选择地执行相应功能
- 跳转语句：依据条件是否满足，循环多次地执行某段代码
4-1.顺序结构
1.if语句
①作用：执行满足条件的语句
②分类：
·i单行if语句
1.语法：if（条件）{待执行语句}
2.注意：if条件后不加分号
·i多行if语句
语法：if（条件）{待执行语句}
else（条件）{待执行语句}
·i多条件的if语句
语法：if（条件）{待执行语句}
else if（条件）{待执行语句}
…
else（条件）{待执行语句}
2.switch语句
①作用：执行多条分支语句
②语法：switch（表达式）{
case 结果1 ： 执行语句； break；
case 结果2 ： 执行语句； break；
…
case 结果n ： 执行语句； break；
default ： 执行语句； break；
③.优点：结构清晰、执行效率高；
④.缺点：判断的时候只能是整形或者字符型，不可以是一个区间；
3.三目运算符
①作用：实现简单的判断
②语法：表达式1？表达式2：表达式3
【解释】：
表达式1的值为真，执行表达式2；
表达式1的值为假，执行表达式3；
4-2.循环结构
1.while循环语句
- 作用：满足循环条件，执行循环语句；
- 语法：while （循环条件）{循环语句}
- 只要循环条件的值为 1就执行循环
2.do…while循环语句
- 作用：满足循环条件，执行循环语句；
- 语法：do {循环语句} while （循环条件）
- 与while循环语句的区别是：do… while语句会先执行一次循环语句，再判断循环条件
3.for循环语句
- 作用：满足循环条件，执行循环语句；
- 语法：for（起始表达式 ； 条件表达式 ； 末尾循环体）{语句}
4.嵌套循环
- 作用：在循环中嵌套一个循环，用于解决实际问题。
4-3.跳转语句
1.break 语句
1.作用：用于跳出循环结构或者跳出选择结构
2.break语句的使用时机
出现在switch条件语句中，作用是：终止case并跳出switch
出现在循环语句中，作用是：跳出当前的循环语句
出现在嵌套循环中，作用是：跳出最近的内层循环语句
2.continue 语句
作用：在循环语句中，跳过本次循环中尚未执行的语句，执行下一次循环。
3.goto语句
作用：可以无条件跳转语句。
语法：goto 标记
#include<iostream>
using namespace std;
int main(){
cout<<1<<endl;
goto FLAG; //如果程序中有标记的名称存在，执行到goto语句时，会跳转到标记位置
cout<<2<<endl;
cout<<3<<endl;
FLAG:
cout<<5<<endl;
return 0;
}
运行结果如下：
第五章 数组
数组就是一个集合，里面存放了相同类型的数据元素
·特点：数组中的每个元素都是**相同的数据类型**
数组是由连续的内存位置组成的
5-1.一维数组
1.定义方式
- 数据类型 数组名 [数组长度]
- 数据类型 数组名 [数组长度] = {值1、值2…值n}
- 数据类型 数组名 [ ]= {值1、值2…值n}
2.数组名
【注意】： 数组名是常量，不能进行赋值操作
- 一维数组名的用途
①.可以统计整个数组所占内存中的大小
②.可以获取数组在内存中的首地址
#include<iostream>
using namespace std;
int main(){
int a[10] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
cout<<"整个数组在内存中所占的空间为"<< sizeof(a) << endl;
cout<<"每个元素所占的空间为"<< sizeof(a[0]) << endl;
cout<<"数组中的元素个数为为"<< sizeof(a)/sizeof(a[0]) << endl;
cout<<"数组的首地址为"<<a << endl;
return 0;
}
运行结果：
3.冒泡排序
- 最常用的排序算法，对数组内的元素进行排序；
- 作用：
①.比较相邻元素，如果前一个元素大于后一个元素，那么两个元素互换位置。
②.对每一对相邻的元素都做相同的工作，执行完毕后找到最大值。
③.重复以上步骤，直到不需要比较。- 排序总轮数 = 元素个数 - 1
- 每轮对比数 = 元素个数 - 正在进行的排序轮数 - 1
5-2.二维数组
1.定义方式
- 数据类型 数组名 [行数] [列数]
- 数据类型 数组名 [行数] [列数] = { {值1，值2} {值3，值4}…值n}
- 数据类型 数组名 [行数] [列数]= {值1、值2…值n}
- 数据类型 数组名 [ ][列数]= {值1、值2…值n}
#include<iostream>
using namespace std;
int main()
{
int a[2][4]={0, 1, 2, 3, 4, 5, 6, 7};
for(int i=0;i<2;i++)
{
for(int j = 0;j<4;j++)
{
cout<<" "<<a[i][j];
}
cout<<endl;
}
return 0;
}
运行结果：
2.数组名
【注意】： 数组名是常量，不能进行赋值操作
- 二维数组名的用途
①.可以统计整个数组所占内存中的大小
②.可以获取数组在内存中的首地址
#include<iostream>
using namespace std;
int main()
{
int a[2][4]={0, 1, 2, 3, 4, 5, 6, 7};
for(int i=0;i<2;i++)
{
for(int j = 0;j<4;j++)
{
cout<<" "<<a[i][j];
}
cout<<endl;
}
cout<<"二维数组所占内存空间大小为： "<<sizeof(a)<<endl;
cout<<"二维数组第一行所占内存空间大小为 "<<sizeof(a[0])<<endl;
cout<<"二维数组的行数为： "<<sizeof(a)/sizeof(a[0])<<endl;
cout<<"二维数组的列数为： "<<sizeof(a[0])/sizeof(a[0][0])<<endl;
cout<<"二维数组的首地址为： "<<(int)a<<endl;
cout<<"二维数组第一行的首地址为： "<< (int)a[0]<<endl;
cout<<"二维数组第二行的首地址为： "<< (int)a[1]<<endl;
return 0;
}
运行结果为：
第六章 函数
6-1.概述
- 作用：将一段经常使用的函数代码封装，减少重复代码。
·一个较大的程序，一般分为若干个程序块，每个模块实现特定的功能。
6-2.函数的定义
1.函数定义的五个步骤
①.返回值类型
②.函数名
③.函数表列
④.函数体语句
⑤.return表达式
2.语法
·
6-3.函数的调用
1.功能：
使用定义好的函数
2.语法：
函数名 （参数）
#include<iostream>
using namespace std;
//定义一个使两个整数相加的函数
int add(int num1, int num2) //函数定义中 num1和um2是两个形参
{
int sum;
sum = num1 + num2;
return sum;
}
int main()
{
int a = 10;
int b = 20;
//函数调用时，实参的值会传递给形参
int sum = add(a,b); //a 和 b是两个实参
cout<<"a+b = "<<sum<<endl;
return 0;
}
程序运行结果为：
6-4.值传递
定义：
-所谓的值传递就是函数调用时，实参的值传递给形参
-值传递时，形参发生的任何变化都不会影响实参
#include <iostream>
using namespace std;
//定义一个函数，用来交换两个形参的值
void swap(int num1, int num2)
{
int temp;
temp = num1;
num1 = num2;
num2 = temp;
cout << "形参num1 = " << num1 << endl;
cout << "形参num2 = " << num2 << endl;
}
int main()
{
//定义两个实参 a, b;
int a = 10;
int b = 20;
//调用swap函数，交换两个形参的值
swap(a,b);
cout << "实参a = " << a << endl;
cout << "实参b = " << b << endl;
return 0;
}
运行结果：
说明值传递中，形参的变化不会对实参的值进行改变
6-5.函数的常见样式
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.有参有返
void test04(int a)
{
cout<<"This is test04 a = "<< a <<endl;
return a;
}
6-6.函数的声明
- 作用：告诉编译器函数名称以及如何调用函数
- 语法：返回值类型 函数名 （参数列表）
函数可以多次声明，但是只能定义一次
6-7.函数的分文件编写
·1.作用：让代码的结构更加清晰
·2.步骤：
①.创建后缀名为.h的文件
②.创建后缀名为.cpp的源文件
③.在头文件中写函数声明
④.在源文件中写函数数的定义
第七章
7-1. 指针的基本概念
指针的作用：可以通过指针 间接访问内存
- 内存编号是从0开始记的，一般用十六进制数字表示
- 可以用指针变量保存地址
7-2.指针变量的定义和使用
1.定义指针：
·语法：数据类型 * 指针变量名
2.使用指针：
·可以通过 解引用的方法来找到指针所指的内存。
·语法：指针前加 * 代表解引用，找到指针指向的内存中的数据。
//指针的定义和使用
#include <iostream>
using namespace std;
int main()
{
int a, *p; //定义一个变量和一个指针
a =10;
p = &a; //指针p记录变量a的地址
cout << " a = " << a << endl;
cout << " p = " << *p << endl;
*p = 1000;
cout << " a = " << a << endl;
cout << " p = " << *p << endl;
return 0;
}
运行结果为：
7-3. 指针所占内存空间
- 在32位操作系统中，指针所占内存大小为：四个字节，无论数据类型
- 在64位操作系统中，指针所占内存大小为：八个字节，无论数据类型
7-4. 空指针和野指针
1.空指针：指针变量指向内存中编号为0的空间
- 用途：初始化指针变量
- 注意：空指针指向的内存空间是不可以访问的（编号为0-255 的内存空间都被系统所占用）
- 定义方法： int *p = NULL;
2.野指针：指针变量指向非法的内存空间
- 程序中尽量避免野指针
eg: int * p = (int*)0X1100;
cout << *p << endl; //无权限；
7-5. const修饰指针
1. const修饰指针的三种情况：
- 1.const修饰指针 —>常量指针
- 2.const修饰变量 —>指针常量
- 3.const既修饰指针又修饰常量
2. 常量指针：const修饰指针
指针的指向可以修改，指针指向的值不能改
#include <iostream>
using namespace std;
int main()
{
int a = 10, b = 20; //定义两个变量 a 和 b;
//定义一个常量指针，即const修饰指针
const int * p = &a;
cout << " a = " << a << endl;
cout << " b = " << b << endl;
cout << " p = " << *p << endl;
cout << endl;
//尝试修改指针指向地址表示的变量的值
/* *p = 1000; //报错！
cout << " a = " << a << endl;
cout << " p = " << *p << endl;
*/
p = &b; //更改指针的指向
cout << "执行修改指针的指向" << endl;
cout << " b = " << b << endl;
cout << " p = " << *p << endl;
return 0;
}
·若改变指针指向的变量的值报错：
·执行结果：
3. 指针常量：const修饰变量
指针的指向不可以修改，指针指向的值可以改
#include <iostream>
using namespace std;
int main()
{
int a = 10, b = 20; //定义两个变量 a 和 b;
//定义一个指针常量，即const修饰变量
int * const p = &a;
cout << " a = " << a << endl;
cout << " b = " << b << endl;
cout << " p = " << *p << endl;
cout << endl;
//尝试修改指针指向地址表示的变量的值
cout << "执行修改指针指向变量的值" << endl;
*p = 1000;
cout << " a = " << a << endl;
cout << " p = " << *p << endl;
//更改指针的指向
/*
p = &b; //报错！
cout << "执行修改指针的指向" << endl;
cout << " b = " << b << endl;
cout << " p = " << *p << endl;
*/
return 0;
}
·若改变指针指向的变量,报错：
·运行结果：
4. const既修饰指针又修饰变量
指针的指向和指针指向的值都不能改
#include <iostream>
using namespace std;
int main()
{
int a = 10, b = 20; //定义两个变量 a 和 b;
//定义一个指针常量，即const修饰变量
const int * const p = &a;
cout << " a = " << a << endl;
cout << " b = " << b << endl;
cout << " p = " << *p << endl;
cout << endl;
// 修改指针指向变量的值
//*p = 1000; //报错！
// 修改指针指向的变量
//p = &b; //报错！
return 0;
}
- 运行结果：
7-6. 指针和指针数组
- 作用：利用指针访问数组中的元素
#include <iostream>
using namespace std;
int main()
{
int arr[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int *p = arr; //此处的arr表示的是数组的首地址；
for(int i=0; i<10; i++)
{
cout <<" "<<*p;
p++; //使 p自增，访问到数组的下一个元素
}
cout << endl;
return 0;
}
- 运行结果：
7-7.指针和函数
- 作用：利用指针做函数参数，可以改变实参的值
- 地址传递：可以改变实参的值
#include <iostream>
using namespace std;
//定义一个交换函数
void swap(int *p1, int * p2)//传入两个指针作为函数的参数
{
cout <<"交换前形参p1 = "<< *p1 << endl;
cout <<"交换前形参p2 = "<< *p2 << endl;
cout << endl;
int temp = * p1;
*p1 = *p2;
*p2 = temp;
cout <<"交换后形参p1 = "<< *p1 << endl;
cout <<"交换后形参p2 = "<< *p2 << endl;
cout << endl;
}
int main()
{
int a, b;
a = 10;
b = 20;
cout << "交换前实参a = " << a << endl;
cout << "交换前实参b = " << b << endl;
cout << endl;
swap(&a, &b); //传入两个变量的地址作为实参
//检查实参的值是否发生了改变
cout << "交换后实参a = " << a << endl;
cout << "交换后实参b = " << b << endl;
cout << endl;
return 0;
}
运行结果：
第八章
8-1. 基本概念
- 结构体属于用户自定义的数据类型，匀速用户储存不同的数据类型
8-2. 结构体的定义与使用
- 语法：struct 结构体名 { 结构体成员列表 }
- 创建结构体变量的方法：
①. struct 结构体名 变量名
②. struct 结构体名 变量名 { 成员1值，成员2值…}
③.定义结构体时顺便创建变量
定义一个学生结构体：
#include <iostream>
#include<string>
using namespace std;
struct Student //定义结构体
{
//成员列表
string name;
int age, score;
};
//创建一个函数，用来输出结构体中的内容
void printStudent(struct Student s)
{
cout << "学生的名字是： " << s.name << endl;
cout << "学生的年龄是： " << s.age << endl;
cout << "学生的成绩是： " << s.score << endl;
}
int main()
{
struct Student s1;
//通过 “ .”来访问结构体成员的属性
s1.name = "王二麻子";
s1.age = 18;
s1.score = 99;
printStudent(s1);
return 0;
}
运行结果为：
8-3. 结构体数组
- 作用：将自定义的结构体放入数组中方便维护。
- 语法：struct 结构体名 数组名 {元素个数} = { { }， { }…}
#include <iostream>
using namespace std;
struct Student //定义结构体
{
string name;
int age;
int score;
};
int main()
{
//创建结构体数组，并给元素赋值
struct Student stuArr[3]={
{"张三", 18, 90},
{"李四", 25, 80},
{"王五", 23, 99}
};
stuArr[1].age = 15; //修改元素的age属性
//遍历元素
for(int i=0; i<3; i++)
{
cout << "学生的姓名为：" << stuArr[i].name <<" "
<< "学生的年龄为：" << stuArr[i].age << " "
<< "学生的成绩为：" << stuArr[i].score <<endl;
}
return 0;
}
运行结果：
8-4. 结构体指针
- 作用：通过指针访问结构体成员
利用操作符 ->,可以通过结构体指针访问结构体属性。
#include <iostream>
using namespace std;
struct Student
{
string name;
int age;
int score;
};
int main()
{
//创建学生结构体变量
struct Student s = {"张三", 18, 100};
//通过指针指向结构体变量
struct Student *p = &s;
//通过指针访问结构体变量中的数据
cout << "姓名：" << p->name <<" "<<"年龄："<< p->age <<" " <<"成绩：" << p->score <<endl;
return 0;
}
运行结果：
8-5.结构体嵌套
- 在结构体中，可以定义另一个结构体作为结构体成员，以解决实际问题。
8-6. 结构体做函数参数
- 作用：
- 将结构体作为参数向函数中传递。
- 传递方式
【若不想修改主函数中的数据，就用值传递；反之，用地址传递】
①.值传递： 形参可以修改实参的数据
②.地址传递： 形参不能修改实参的数据
#include <iostream>
using namespace std;
struct Student
{
string name;
int age;
int score;
};
//值传递
void printStudents1(struct Student s)
{
cout << "子函数1中，学生的姓名：" << s.name << " " << "年龄：" << s.age << " " << "成绩:" << s.score << endl;
}
//地址传递
void printStudents2(struct Student *p)
{
cout << "子函数2中，学生的姓名：" << p->name << " " << "年龄：" << p->age << " " << "成绩:" << p->score << endl;
}
int main()
{
//创建学生结构体变量
struct Student s;
s.name = "王二麻子";
s.age = 18;
s.score = 99;
printStudents1(s);
printStudents2(&s);
return 0;
}
运行结果：
8-7. 结构体中const 的使用场景
- 作用：使用const来防止误操作。
#include <iostream>
using namespace std;
struct Student
{
string name;
int age;
int score;
};
//地址传递
void printStudents2(const Student *p) //const防止函数体中的误操作
{
//错误，操作失败，const修饰指针，指针指向变量的值不可以改
//p->name = "张三";
cout << "子函数2中，学生的姓名：" << p->name << " " << "年龄：" << p->age << " " << "成绩:" << p->score << endl;
}
int main()
{
//创建学生结构体变量
struct Student s;
s.name = "王二麻子";
s.age = 18;
s.score = 99;
printStudents2(&s);
return 0;
}
如果修改指针指向变量的值，报错：
运行结果：
1066
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
