第一章:C++介绍
1.第一个c++程序
c++程序:
编写c++程序的步骤: 创建项目 创建文件 编写代码 运行程序
//
// Created by ~风轻云淡~ on 2022/12/19.
//
#include "iostream"
using namespace std;
int main(){
cout<<"helloWorld"<<std::endl;
system("pause");
return 0;
}
2.注释:在代码中加一些说明和解释 方便自己和其他程序员阅读代码
两种格式:单行注释 // 通常放在一行代码的上方 对该代码说明
多行注释
/**/ t通常放在一段代码的上方
//
// Created by ~风轻云淡~ on 2022/12/19.
//
#include "iostream"
using namespace std;
int main(){
cout<<"helloWorld"<<std::endl;
system("pause");
//单行注释
/*
* 多行注射
* */
return 0;
}
//
// Created by ~风轻云淡~ on 2022/12/19.
//
#include "iostream"
using namespace std;
int main(){
cout<<"helloWorld"<<std::endl;
system("pause");
//单行注释
/*
* 多行注射
* */
return 0;
/*
* main是一个程序的入口 每个程序都必须有这么一个函数 有且仅有一个
*
* */
}
2.变量
变量存在的作用:方便我们管理内存空间
变量创建的语法:数据类型 变量名=变量的初始值;
int a =100;
//
// Created by ~风轻云淡~ on 2022/12/19.
//
#include "iostream"
using namespace std;
int main(){
// 变量创建的语法 :
//变量创建的语法:
int a=10;
cout <<"a="<<a<<endl;
system("pause");
return 0;
}
3.常量
作用:用于记录程序中不可更改的数据
c++定义常量的两种方式
1.#define 宏常量 :#define 常量名 常量值
通常在文件的上方定义 表示一个常量
2.const 修饰的变量 const 数据类型 常量名=常量值
通常在变量定义前加关键字const 修饰变量为常量 不可修改
#include <iostream>
/*常量的定义方式:
* #define 宏常量
* 2.const修饰的变量
* */
//1.#define N
#define Day 7
using namespace std;
int main() {
cout<<"一周有:"<<Day<<"天"<<endl;
///2.const修饰的变量 也是常量
const int m=12;
cout<<"m的值为:"<<m<<endl;
return 0;
}
4.编程常用的关键字
与java python 中的一样:
class return int float double
因此不能使用关键字给变量或常量起名字
5.标识符命名规则
标识符:1.标识符不能是关键字
int int=10 这样子不允许
2.标识符只能由字母 下划线 数字组成
int abc=10 int _abc=20
3.标识符中字母区分大小写
4.标识符是区分大小写的
第二章:数据类型
1.常见数据类型
#include <iostream>
#define Day 7
using namespace std;
int main() {
// 数据类型存在的意义:给变量分配合适的内存空间 区别就是占用的内存空间不同
/*
* short 短整型
*int 整型
* long 长整型
*
* */
//1.短整型:short
short num1=10;
//2.整型 int
int num2=10;
//3.长整型long
long num3=100;
//4.双精度
double num4=900;
//5.浮点型
float num5=90000;
return 0;
}
2.sizeof关键字
#include <iostream>
#define Day 7
using namespace std;
int main() {
// 数据类型存在的意义:给变量分配合适的内存空间 区别就是占用的内存空间不同
/*
* short 短整型
*int 整型
* long 长整型
*
* */
//1.短整型:short
short num1=10;
//2.整型 int
int num2=10;
//3.长整型long
long num3=100;
//4.双精度
double num4=900;
//5.浮点型
float num5=90000;
//利用sizeof求出数据类型的内存占用大小
//语法:sizeof(数据类型/变量)
cout<<"num1数据类型是" <<sizeof(num1) <<endl;
cout<< "num2的数据类型是:"<<sizeof (num2)<< endl;
return 0;
}
3.浮点型
float 浮点型
double 双精度
#include <iostream>
#define Day 7
using namespace std;
int main() {
//1.短整型:short
short num1=10;
//2.整型 int
int num2=10;
//3.长整型long
long num3=100;
//4.双精度
double num4=900;
//5.浮点型 默认情况下输出一个小数 会显示出6位有效数字
float num5=90.56f;
cout<< "num5="<< num5 <<endl;
//科学技术发:
float x=3e2;//3*10^2
cout<< "x的值为!"<< x<< endl;
return 0;
}
4.字符型
char ch='a' 作用:用于显示单个字符
#include <iostream>
#define Day 7
using namespace std;
int main() {
//1.创建字符型变量
char ch='a';
cout<<"转换一下" << ch+92<<endl;
//注意:不能使用双引号创建
//创建的时候单引号内只能有一个字符
//char j='dhdh'; 这个就是错误的
//字符对应的ASCII码:a 97 A-65
return 0;
}
5.转义字符
转义字符
\a
\b
\f
\n
\t
#include <iostream>
#define Day 7
using namespace std;
int main() {
//1.换行符 \n
cout<< "你好\n 你好\n" <<endl;
// 2.水平制表符 \t 整齐输出数据
cout<< "asfdasf\thjhjgjgh\t"<<endl;
return 0;
}
6.字符串类型
#include <iostream>
#define Day 7
using namespace std;
//使用c++风格的字符串要包含的头文件
#include "string"
int main() {
// 1.C语言字符串 cha 注意;char 字符串名[]
//等号后面要使用双引号包含起来
char str[]="hello word";
// 2.c++版本字符串
string string1="hello World";
cout<<string1 <<endl;
}
7.布尔类型
#include <iostream>
#define Day 7
using namespace std;
//使用c++风格的字符串要包含的头文件
#include "string"
int main() {
//布尔值:判断对错
bool flag= true;
cout<<flag<<endl;//输出1
bool j= false;
cout<<j<<endl;//输出0
}
8.数据的输入
作用:从键盘上获取数据
关键字:cin>>'值'
#include <iostream>
#define Day 7
using namespace std;
//使用c++风格的字符串要包含的头文件
#include "string"
int main() {
//1.整型
int a=0;
cout<<"请输入a的值"<<endl;
cin>>a;
cout<<"a的值为:"<<a<<endl;
// 2.浮点型
float b=0;
cout<<"请输入a的值"<<endl;
cin>>b;
cout<<"a的值为:"<<b<<endl;
//3.字符型
char c='a';
cout<<"请输入a的值"<<endl;
cin>>a;
cout<<"a的值为:"<<c<<endl;
//4.字符串类型
string str="hello";
cout<< "请输入"<< endl;
cin>>str;
cout<<"str的值为:"<<str<<endl;
}
第三章:运算符
1.算数,取模运算符
#include <iostream>
#define Day 7
using namespace std;
//使用c++风格的字符串要包含的头文件
#include "string"
int main() {
//1.加减乘除
int a1=10;
int a2=45;
cout<<a1+a2<<endl;
cout<<a1-a2<<endl;
cout<<a1*a2<<endl;
cout<<a1/a2<<endl;//两个指数相除 将小数部分去除
cout<<"你好"<<endl;
//2.取模运算:求两个相除的余数
cout<<a1%a2<<endl;
两个小数之间是不可以做取模运算的
return 0;
}
2.算数运算符
前置递增
后置递增
前置递减
后置递减
#include <iostream>
#define Day 7
using namespace std;
//使用c++风格的字符串要包含的头文件
#include "string"
int main() {
// 1.前置递增
int a=10;
++a;//让变量+1
cout<<"啊的值"<<a<<endl;
//2.后置递增
int b=10;
b++;//让变量+1
cout<<"b=?"<<b<<endl;
/*
* 前置和后置的区别:1前置递增 先让变量+1 如何在进行表达式运算
* 后置递增 先进行表达式运算 后让变量+1
* */
int a2=10;
int b2=++a2*10;
cout<<"a2"<<a2<<endl;
return 0;
}
3.赋值运算符
= 赋值
+= 加等于
-= 减等于
*=乘等于
#include <iostream>
using namespace std;
int main() {
//赋值运算符
//
// 1. =
int a=10;
a=100;
cout<<a<<endl;
//2.+=
a=10;
a+=2;//a=a+2
cout<<"a的值为"<<a<<endl;
// 3. *=
a*=2;
cout<<"a*=2为"<<a<<endl;
//4. /=
a=90;
a /=2;//a=a/2
cout<<"a的值为"<<a<<endl;
return 0;
}
4.比较运算符
#include <iostream>
using namespace std;
int main() {
/*比较运算符 :用于表达式的比较 并返回一个真值或假值
*
*
* ==相等
* !=不等于
* <小于
* >大于
* <=小于大于
* >= 大于大于
*
* */
int a=10;
int b=20;
cout<<(a==b)<<endl;//输出0
cout<<(2>90)<<endl;//注意:在c++中使用小括号来提高程序执行的优先级
cout<<(a>b)<<endl;//输出0
return 0;
}
5.逻辑运算符
#include <iostream>
using namespace std;
int main() {
/*
* 逻辑运算符:用于工具表达式的值返回真值或者假值
*
* ! 非
* && 与
* || 或
*
* */
//逻辑运算符 非
int a=10;
cout<<!(!a)<<endl;//先算!a 然后再整体取反 就是输出1
// 与运算
bool n= true;
bool m= false;
cout<<!(m&&n)<<endl;
//在计算机中只要是非0数字都是真 a=1 a=-1 等等都是真 只有a=0的时候才是假
cout<<!(a)<<endl;
//或运算||
cout<<(m||n)<<endl;
return 0;
}
第四章:程序流程语句
1.选择结构
三种运行结构:顺序结构 选择结构 循环结构
顺序结构:程序按照顺序执行 不发生跳转
选择结构:依照条件执行 是否满足 有选择的执行
循环结构:依照条件是否满足 循环多次执行某段代码
1.if语句
作用:执行满足条件的语句
单行格式的if语句
#include <iostream>
using namespace std;
int main() {
int a=10;
// 1.用户输入的分数
int score=0;
cout<<"请输入分数"<<endl;
cin>>score;
//2.打印用户输入的分数
cout<<"分数是:"<<score<<endl;
//3.判断房租是否大于600 大于就输出
//注意:if后面不要加分号
if (score>600){
cout<<"恭喜你考上了大学!"<<endl;
}
if (a<20){
cout<<"你好"<<a<<endl;
a++;
}
return 0;
}
2.多行格式的if语句
#include <iostream>
using namespace std;
int main() {
//多行 if语句
int score=0;
cout<<"请输入分数"<<endl;
cin>>score;
cout<<"你输入的分数"<<score<<endl;
if (score>600){//如果大于600分就执行下面大括号
cout<<"分数是"<<score<<"恭喜你录取了~·"<<endl;
} else{//不大于600分就执行下面的代码
cout<<"很遗憾 请耐心等待"<<endl;
}
return 0;
}
3.多条件语句
#include <iostream>
using namespace std;
int main() {
//多条件if语句:
//输入考上分数 如果大于600 分 就输出考上了 一本
//如果大于500 就输出二本大学
//如果大于400 就输出三本大学
//如果小于400 就输出 还未录取 请等待
int score=0;
cout<<"请输入分数"<<endl;
cin>>score;
if(score>600){
cout<<"恭喜你考上了一本大学!"<<endl;
} else if(score>500&&score<<600){
cout<<"恭喜你考上了二本大学"<<endl;
} else if(score>400&&score<500){
cout<<"恭喜你考上了三本大学"<<endl;
} else{
cout<<"很遗憾 你没有大学上了"<<endl;
}
return 0;
}
4.嵌套if语句
#include <iostream>
using namespace std;
int main() {
// 用户输入分数
int score=0;
cout<<"请用户输入分数"<<endl;
cin>>score;
if (score>700){
// 大于700还要分出考上北大或者清华
if (score>750){
cout<<"恭喜你 考上了北大"<<endl;
} else if(score>710&&score<=759){
cout<<"恭喜你 考上了人民大学"<<endl;
} else if(score>=710&&score<=710){
cout<<"恭喜你 考上了复旦大学"<<endl;
}
} else if(score <700&&score>500){
cout<<"恭喜你考了一本"<<endl;
} else if(score>400&&score<=500){
cout<<"恭喜你考了二本"<<endl;
}
return 0;
}
#include <iostream>
using namespace std;
int main() {
// 创建三个变量
int num1=0;
int num2=0;
int num3=0;
//让用户输入内容:
cout<<"请输入num1的值"<<endl;
cin>>num1;
cout<<"请输入num2的值"<<endl;
cin>>num2;
cout<<"请输入num3的值"<<endl;
cin>>num3;
if (num1>num2){
if (num1>num3){
cout<<"num2最大"<<num2<<endl;
} else{
cout<<"num3最大"<<num3<<endl;
}
} else{
if (num2>num3){
cout<<"num2最大"<<num2<<endl;
}
}
return 0;
}
5.三目运算符
#include <iostream>
using namespace std;
int main() {
/*
* 作用:通过三目运算符实现简单的判断
* 语法:表达式1?表达式2:表达式3 如果表达式1位真 则执行表达式2 并且返回表达式2的结果 以此类推
*
* */
/*三目运算符
* */
// 将a和b做义工比较 将变量大的值赋值给c
int a,b,c;
a=10;
b=10;
c=0;
c= (a>b?a:b) ;
cout<<"值为:"<<c<<endl;
// 创建三个变量 a b c
//在c++中三目运算符返回的是变量 可以继续赋值
system("pause");
return 0;
}
6.Switch语句
Switch:执行多条件分支语句
#include <iostream>
using namespace std;
int main() {
// switch语句
//1.提示用户输入
cout<<"请给电影打分"<<endl;
//2.用户开始评分
int score=0;
cin>>score;
cout<<"你打的分数是"<<score<<endl;
//4.根据用户输入的分数的不同来输出最后的结果
switch (score) {
case 10:
cout<<"您认为是经典"<<endl;
break;//退出这个分支
case 9:
cout<<"你认为是经典"<<endl;
break;//退出这个分支
case 8:
cout<<"烂片"<<endl;
break;
}
std::cout << "程序结束" << std::endl;
return 0;
}
switch缺点:判断时候只能是整型或者字符型 不可以是一个区间
优点:结构清晰 执行效率高
第五章:循环结构
1.While循环语句
#include <iostream>
using namespace std;
int main() {
/*
* 1.While语句:
* 作用满足循环条件 执行循环语句
* 语法: while(循环条件){循环语句}
*
*
*
* 主要循环条件一种为真就一直执行循环语句
*
*
*
*
*
*
* */
// 在控制台输出0到9这个数字
int num=0;
while (num<10){//在while中填入循环条件
cout<<num<<endl;//在while中书写代码体
num++;
}
while (1){//在书写程序的时候 一定要杜绝死循环
cout<<num<<endl;
num++;
}
std::cout << "Hello, World!" << std::endl;
return 0;
}
2.猜数字游戏
#include <iostream>
using namespace std;
#include "ctime"
int main() {
// 添加一个随机数的种子 作用利用当前系统时间生成随机数 防止每次随机数都一样
srand((unsigned int) time(NULL))
// 1.系统要生成一个随机数
int num= rand()%100;//0到99之间的随机数
//cout<<num<<endl;
//2.玩家进行猜测
int val=0;//玩家输入的数据
while (1){
cin>>val;
if (val>num){
cout<<"猜测过大"<<endl;
} else if{
cout<<"猜小了"<<endl;
}else{
cout<<"猜对了"<<endl;
break;//在循环中使用break来退出
}
}
//3.判断玩家的猜测
//猜对 退出游戏
//猜错 提示信息
return 0;
}
3.do…while语句
#include <iostream>
using namespace std;
int main() {
/*
* do...while()语句
* 作用:满足循环条件 执行循环语句
* 语法:do{循环语句} while(循环条件)
* 注意:与while的区别在于 do...while会先执行因此循环语句 在判断循环条件
* 先执行后判断
*
* */
// 示例:
int num=1;
do {
cout<<"计算机科学与技术学院"<<endl;
cout<<num<<endl;
num++;
} while (num<100);
}
4.练习案例
#include <iostream>
using namespace std;
int main() {
// 1.将所有的三位数输出
int num=100;
int a=0;
int c=0;
int b=0;
do {
a=num%10;
b=num/10%10;
c=num/100;
//2.在所有三位数中寻找水仙花数
if (a*a*a+b*b*b+c*c*c==num){
cout<<num<<endl;//3.输出水仙花数
}
num++;
} while (num<1000);
std::cout << "Hello, World!" << std::endl;
return 0;
}
5.for循环语句
#include <iostream>
using namespace std;
int main() {
// for循环语句:作用先满足循环条件 执行循环语句
//语法:for(起始表达式;条件表达式;末尾循环体){循环语句}
//示例:
for (int i = 0; i < 100; ++i) {
cout<<i<<endl;
}
}
6.嵌套循环
#include <iostream>
using namespace std;
int main() {
/* 嵌套循环:
* 外层执行一次 内存执行一周
*
* */
for (int i = 0; i <10 ; ++i) {
for (int j = 0; j < 10; ++j) {
cout<<"-"<<endl;
}
cout<< endl;
}
}
7.跳转语句
#include <iostream>
using namespace std;
int main() {
/*
* break语句:
* 作用跳出选择结构或者循环结构
* 使用:
* 出现在Switch语句中 作用就是跳出当前的循环语句
* 出现在嵌套循环中 跳出最近的内层循环语句
*
*
* */
// break的使用
//1.出现在Switch语句
int num=0;
cout<<"请选择难度"<<endl;
cout<<"1.普通"<<endl;
cout<<"2.困难"<<endl;
cout<<"3.最难"<<endl;
cin>>num;
switch (num) {
case 1:
cout<<"普通"<<endl;
break;
case 2:
cout<<"困难"<<endl;
break;
case 3:
cout<<"最难"<<endl;
break;
}
//2.出现在循环语句
for (int i = 0; i < 100; ++i) {
if (i==7){//如果i=7 就退出
cout<<"程序退出"<<endl;
cout<<i<<endl;
}
}
//3.出现在嵌套循环语句
for (int i = 0; i < 100; ++i) {
for (int j = 0; j <i ; ++j) {
if (i==j){
cout<<"退出循环"<<endl;
break;
}
}
}
}
#include <iostream>
using namespace std;
int main() {
// 跳转语句:continue语句: 执行到这一行代码就执行下一次的代码
for (int i = 0; i < 10; ++i) {
if (i%2==0){
cout<<"偶数是"<<i<<endl;
continue;//直接跳出语句 可以作为筛选条件 这个并没有使整个循环终止 而break直接跳出
} else if(i%2!=0){
cout<<"奇数是"<<i<<endl;
}
cout<<i<<endl;
}
}
#include <iostream>
using namespace std;
int main() {
/*
* goto语句: goto 标记; 如果标记存在 则执行到goto语句的时候会跳转到标记的位置
*
* */
goto label;
cout<<"你好"<<endl;
cout<<"你好"<<endl;
label:;
}
第五章:数组
1.一维数组
#include <iostream>
using namespace std;
int main() {
/*
* 数组特点:放在也快连续的内存空间中 数组中每个元素都是相同数据类型
*
*
* */
// 1.方式一:
int arr1[10];
arr1[0]=1;//给数组中的元素赋值
// 访问数组元素
cout<<arr1[0]<<endl;
/* for (int i = 0; i < 100; ++i) {
arr1[i]=i;
cout<<arr1[i]<<endl;
}
*/
//2.方式二:
int arr2[5]={10,22,22,34,34};
for (int i = 0; i < 5; ++i) {
cout<<arr2[i]<<endl;
}
//如果在初始化的时候没有全部填写完毕 则使用0来补齐
//3.方式三:
int arr3[]={9,1,2,3,4,5,67,8,8,9};
//定义数组的时候 必须有初始长度
cout<<arr3[4]<<endl;
}
2.一维数组的数组名称
#include <iostream>
using namespace std;
int main() {
//一维数组名称的用途;1.可以统计整个数组在内存中的大小 2.可以获取数组在内存中的首地址
int a[5]={1,2,3,4,5};
//统计数组长度 sizeof()
cout<<"数组长度"<< sizeof(a)<<endl;
//获取数组中元素的首地址
cout<<a<<endl;
//查看某个元素的首地址
cout<<&a[4]<<endl;
//数组名是常量 不可以进行赋值操作
std::cout << "Hello, World!" << std::endl;
return 0;
}
#include <iostream>
using namespace std;
int main() {
// 元素倒置
int arr[]={1,2,3,4,5,6,7,8};
// 实现数组元素的倒置
//1.创建数组
cout<<"逆序前的数组为"<<endl;
for (int i = 0; i < 8; ++i) {
cout<<arr[i]<<endl;
}
// 先记录一下起始下标的位置
int start=0;
int end=sizeof (arr) /sizeof (arr[0])-1;
int temp=arr[start];
while (start<end){
arr[start]=arr[start];
arr[start]=arr[end];
arr[end]=temp;
// 下标更新
start++;
end--;
}
cout<<"逆序后的数组为"<<endl;
for (int i = 0; i < 8; ++i) {
cout<<arr[i]<<endl;
}
//记录结束下标的位置
//起始下标与结束下标互换
//2.实现逆序数组
//3,打印逆序后的数组
}
#include <iostream>
using namespace std;
int main() {
/*冒泡排序思路:
* 1.比较相邻的数据 如果第一个对于第二个就交换
* 2.对每一对相邻元素做同样的工作 执行完毕后找到其最大值
* 3.重复以上操作
*
* 排序的总论数=元素个数-1
* 每轮对比的次数=元素个数-排序轮数
*
* */
int arr[]={4,2,3,0,6,7,8,9};
for (int i = 0; i < 9-1; ++i) {
for (int j = 0; j < 9-i-1; ++j) {
// 内层循环比较 次数=元素个数-当前轮数-1
// 如果第一个数字比第二个数字大 交换两个数字
if (arr[j]>arr[j+1]){
int temp=arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
}
for (int i = 0; i < 8; ++i) {
cout<<"排序后:"<<arr[i]<<endl;
}
}
3.二维数组
#include <iostream>
using namespace std;
int main() {
/*
* 二维数组:
*
* */
//方式一:
int arr[2][3];
arr[0][0]=1;
arr[0][1]=2;
arr[0][2]=3;
arr[1][0]=2;
// 外层循环打印行数 内层循环打印列数
for (int i = 0; i < 2; ++i) {
for (int j = 0; j < 3; ++j) {
cout<<"\n"<<arr[i][j]<<endl;
}
}
// 2.方式二:
int arr2[2][3]={
{1,2,3},
{2,345}
};
// 3.方式三:
int arr3[2][4]={123,232,232,231,23,12,212,232};
//4.方式四:
int arr4[][3]={123,456};
std::cout << "Hello, World!" << std::endl;
return 0;
}
第六章:函数
1.函数的定义
#include <iostream>
using namespace std;
//返回值列表 函数名 参数列表 (参数列表) { 函数体 return 返回值}
int main() {
/*
* 函数:将一段经常使用的代码封装起来 减少代码的重复
*
*
* 函数的定义一般有五步:
* 1-- 返回值类型
* 2-- 函数名
* 3--参数列表
* 4.函数体语句
* 5.return 表达式
*
* 返回值类型 函数名(参数列表)
* {
* 函数体语句
*
* return 表达式
*
* }
* */
}
double function(int a,int b){
for (int j=1;j<100;j++){
cout<<"你好"<<endl;
}
return a+b;
}
2.函数调用
#include <iostream>
using namespace std;
//返回值列表 函数名 参数列表 (参数列表) { 函数体 return 返回值}
int add(int a,int b){
int c=a+b;
return c;
}
int function(int v,int l){
int m=v+ (++v)+ (++l) +l++;
return m;
}
int main() {
/*
*
*
* 函数调用:
* main中调用
*
* 在函数定义的并没有实际参数 称为形参数
* 在调用的时候 才会有实参来传
*
* 注意:定义函数的时候 定义的函数要写在main函数的上面 不能在下面
*
* */
int a=10;
int b=100;
// 传递参数
int m=add(a,b);
cout<<"两个值为:"<<m<<endl;
cout<<"-------------------------"<<endl;
int v=90;
int l=70;
int n= function(v,l);
cout<<"前置++和后置++:"<<n<<endl;
}
3.值传递
#include <iostream>
using namespace std;
//返回值列表 函数名 参数列表 (参数列表) { 函数体 return 返回值}
int add(int a,int b){
int c=a+b;
return c;
}
int function(int v,int l){
int m=v+ (++v)+ (++l) +l++;
return m;
}
void swap(int num1,int num2){
// 定义一个临时变量
int temp;
temp=num1;
num1=num2;
num2=temp;
cout<<"交换完成后:"<<num1<< num2<<endl;
// 不需要返回值
}
int main() {
/*值传递:实现两个数字进行交换函数
* 如果函数不需要返回值 可以在函数名之前书写一个void
*
* */
int a=100;
int b=900;
swap(a,b);//因为这个函数没有返回值 所以不需要定义其他变量来接收这个值
// 当我们做值传递的时候 形参发送改变 并不会影响实参
}
4.参数的常见样式
#include <iostream>
using namespace std;
/*
* 函数的常见样式:
* 1.无参无返
* 2.有参无返
* 3.无参有返
* 4.有参有返
*
*
* */
//1.无参无返
void test1(){
cout<<"Hello 计算机"<<endl;
}
//2.有参无返
void test2(int a){
cout<<"有参无返"<<a<<endl;
}
//3.无参有返
int test3(){
return 1000;
}
//4.有参有返的
int test4(int a ,int b){
return a+b;
}
int main() {
test1();
test2(1);
int x= test3();//因为有返回值 所以可以定义变量来接收
cout<<x<<endl;
int y= test4(12,34);
cout<<y<<endl;
}
5.函数的声明
#include <iostream>
using namespace std;
/*
* 函数的声明:告诉编译器函数名称及如何调用函数 函数的实际主体可以单独定义
* 注意:函数的声明可以定义多次 但是函数的定义只能有一次
*
*
* */
//声明函数: 因为之前的代码 函数定义在main后面就报错 可以提前告诉编译器 函数是存在的
int max(int a,int b);//函数的声明
//函数声明可以由多次 但是函数的定义只能有一次
int main() {
int max1= max(12,45);
cout<<max1<<endl;
}
int max(int a,int b){
return a>b? a:b;
}
6.函数的分文件编写
swap. h
# include <iostream>
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<< b<< endl;
}
#include "iostream"
using namespace std;
#include "swap.h"
/*
* 函数的分文件编写:
* 作用:让代码结构更加清晰
* 函数分文件编写一般有四个步骤
* 1.创建后缀名为.h的头文件
* 2.创建后缀名为.cpp的文件
* 3.在头文件中写函数的声明
* 4.在原文件中写函数的定义
*
*
* */
//把swap的头文件包含过来即可使用
int main() {
int a=1;
int b=3;
swap(a,b);
//1.创建.h为后缀名的头文件
//2.创建.cpp后缀的原文件
//3.在头文件中写函数的声明
//4.在原文件中写函数的定义
system("pause");
return 0;
}
cmake_minimum_required(VERSION 3.21)
project(Pr08)
set(CMAKE_CXX_STANDARD 14)
add_executable(Pr08 main.cpp swap.h swap.cpp)//注意 在分文件编写的时候 一定要把文件的添加 加上 不然会无法识别
第七章:指针
1.指针的定义及使用
#include <iostream>
using namespace std;
int main() {
/*
* 指针的基本概念:
* 真正的作用:可以通过指针间接访问内存
*
* 内存编号是从0开始记录的 一般使用十六进制数来表示
* 可以用指针变量保存地址
*
*
* 1.定义一个指针
*
*
* 2.。使用指针
*
*
* */
//1.定义指针:
int a=10;
//指针定义的语法: 数据类型 *指针变量名称
int *p;
// 让指针记录变量b的值
p=&a;
cout<<"指针的地址是"<<&a<<endl;
cout<<"p的地址"<<p<<endl;
// 使用指针
// 可以通过解引用的方式来找到指针指向的内存
//指针前加 *代表解引用 找到指针指向内存中的数据
*p=100;
cout<<"*a="<<&a<<endl;
cout<<"*p="<<p<<endl;
cout<<p<<endl;
return 0;
}
2.指针所占的内存空间
#include <iostream>
using namespace std;
int main() {
/*
* 指针也是一种数据类型 那么指针占用多少内存呢?
*
* 在32操作系统下占用4个字节空间 在64位操作系统下占用8个字节
* 不管是什么数据类型 都是这样
* */
int *p;
cout<<sizeof p<<endl;//输出8
double *o;
cout<<sizeof p<<endl;
cout<<sizeof(float *)<<endl;
return 0;
}
3.空指针
#include <iostream>
int main() {
/* 空指针:空指针用于给指针变量进行初始化
*
*
*
*
* */
int *p=NULL;
// 2.空指针是不可以访问的 0-255之间的内存编号 是系统占用的 是不可以访问的
std::cout<<p<<std::endl;
std::cout << "Hello, World!" << std::endl;
return 0;
}
4.野指针
#include <iostream>
using namespace std;
int main() {
// 野指针 :指针变量指向非法的内存空间
//1.创建一个指针
int *p=(int *)0x1100;
cout<<*p<<endl;//在程序中 避免出现指针情况
}
5.const修饰指针
#include <iostream>
using namespace std;
int main() {
/* const修饰指针的三种情况:
* 1.const修饰指针 常量指针
* 2.const修饰常量 指针常量
* 3.const 修饰指针 又修饰常量
*
*
* */
int a=10;
int b=90;
//1.常量指针
const int *p=&b;//指针的值向可以修改 但是指针指向的值不可以改
// 2.指针常量
int * const i=&a;//特点:指针的指向不可以改 指向指向的值可以改
}
6.指针和数组
#include <iostream>
using namespace std;
int main() {
// 指针和数组
// 利用指针来访问数组中的元素
int arr[10]={1,2,3,34,};
cout<<arr[0]<<endl;//传统访问
//利用指针来访问
int *p=arr;//arr就是数组的首地址
cout<<"解引用:"<<*p<<endl;
//要想利用指针来访问 下一个元素 只需要 p++
p++;
cout<<"第二个元素为:"<<*p<<endl;
int *r=arr;
for (int i = 0; i < 4; ++i) {
cout<<"指针的元素为"<<*r<<endl;
r++;
}
}
7.指针和函数
#include <iostream>
using namespace std;
void swap(int a,int b){
int temp=a;
a=b;
b=temp;
cout<<a<<b<<endl;
}
void swap01(int *a,int *b){
int temp=*a;
*a=*b;
*b=temp;
cout<<"a的值为:"<<*a<<endl;
cout<<"b的值为:"<<*b<<endl;
}
int main() {
// 指针和函数
//1.值传递
int a=10;
int b=12;
swap(a,b);
// 2.地址传递
swap01(&a,&b);
}
8.指针配合函数的案例
#include <iostream>
using namespace std;
void Sort(int *arr,int len){
for (int i = 0; i < len-1; ++i) {
for (int j = 0; j < len-i-1; ++j) {
// 如果j>j+1 就交换数字
if (arr[j]>arr[j+1]){
int temp=arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
}
}
//打印数组
void printArray(int *arr,int len){
for (int i = 0; i < len; ++i) {
cout<<"排序后的数组:"<<arr[i]<<endl;
}
}
int main() {
// 封装一个函数 利用冒泡排序 实现对整型数组的升序排序
int arr[10]={23,43,3,21,23,34,56,21};
//数组长度的计算
int len=sizeof (arr)/sizeof (arr[0]);
// 传递参数
Sort(arr,len);
// 打印数组
printArray(arr,len);
}
第七章:结构体
1.结构体基本概念
#include <iostream>
using namespace std;
//1.创建学生数据类型 学生 (姓名,年龄,分数)
struct Student
{
// 自定义的数据类型就是一些类型集合组成的一个类型
// 语法 struct 类型名称 {成员列表}
// 成员列表
//姓名
string name;
//年龄
int age;
//分数
int score;
}s3;
int main() {
//结构体基本概念:
//结构体属于用户自定义的数据类型 允许用户存储不同的数据类型
//1.结构体的定义: 语法:struct 结构体名称 {结构体成员变量};
/* struct结构体名 变量名
* struct 结构体名 变量名
* struct 结构体名 变量名={成员1值 , 成员2值.....成员n值}
*
*
* */
//示例:
//1.通过类型来创建具体的学生
//方法一:
struct Student s1;
//给s1来赋值
//访问结构体变量中的属性
s1.name="吴邪";
s1.age=19;
s1.score=90;
cout<<"姓名:"<<s1.name<<"年龄:"<<s1.age<<"成绩:"<<s1.score<<endl;
//方式二:
struct Student s2={
"黑瞎子",
19,
99
};
cout<<"姓名:"<<s2.name<<"年龄:"<<s2.age<<"成绩:"<<s2.score<<endl;
// 方式三:在定义结构体的时候顺便创建结构体变量
s3.name="张启山";
s3.age=19;
s3.score=100;
cout<<"姓名:"<<s3.name<<"年龄:"<<s3.age<<"成绩"<<s3.score<<endl;
}
2.结构体数组
#include <iostream>
#include "string"
using namespace std;
//结构体数组:将自定义的结构体放入到数组中方便维护
//语法: struct 结构体名 数组名{元素个数}={{},{},{},.....{}}
//结构体数组:
// 1,创建一个结构体
struct Student{
string name;
int age;
int score;
};
int main() {
//2.创建一个结构体的数组
struct Student stuArray[3]={
{"吴邪",19,80},
{"黑瞎子",20,90},
{"张起灵",25,95}
};
// 3.给结构体数组中的元素赋值
stuArray[2].name="赵子龙";//可以修改里面的数据
stuArray[2].age=30;
stuArray[2].score=85;
//遍历结构体数组
for (int i = 0; i < 3; ++i) {
cout<<"姓名:"<<stuArray[i].name<<"——年龄:"<<stuArray[i].age<<"——成绩:"<<stuArray[i].score<<endl;
}
//4.变量结构体数组
}
3.结构体指针
#include <iostream>
#include "string"
using namespace std;
//结构体指针:
//1.定义学生结构体
struct student{
string name;//姓名
int age;//年龄
int score;//分数
};
int main() {
//创建学生的结构体变量
struct student s={"吴邪",18,90};
//通过指针来指向结构体变量
struct student *p=&s;
//通过指针来访问结构体中变量的数据
cout<<"姓名:"<<s.name<<endl;
cout<<"年龄:"<<s.age<<endl;
/*
* 结构体指针:通过指针访问结构体中的成员
* 利用操作符 -> 可以通过结构体指针访问结构体属性
*
*
* */
}
4.结构体嵌套结构体