【持更】
一、学习目标:
简易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;
}
如果修改指针指向变量的值,报错:
运行结果: