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是一个程序的入口 每个程序都必须有这么一个函数 有且仅有一个
*
* */
}
变量存在的作用：方便我们管理内存空间
变量创建的语法：数据类型 变量名=变量的初始值;
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;
}
作用：用于记录程序中不可更改的数据
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;
}
与java python 中的一样：
class return int float double
因此不能使用关键字给变量或常量起名字
标识符：1.标识符不能是关键字
int int=10 这样子不允许
2.标识符只能由字母 下划线 数字组成
int abc=10 int _abc=20
3.标识符中字母区分大小写
4.标识符是区分大小写的
#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;
}
#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;
}
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;
}
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;
}
转义字符
\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;
}
#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;
}
#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
}
作用：从键盘上获取数据
关键字：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;
}
#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;
}
前置递增
后置递增
前置递减
后置递减
#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;
}
= 赋值
+= 加等于
-= 减等于
*=乘等于
#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;
}
#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;
}
#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.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;
}
#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;
}
#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;
}
#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;
}
#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;
}
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缺点：判断时候只能是整型或者字符型 不可以是一个区间
优点：结构清晰 执行效率高
#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;
}
#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;
}
#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);
}
#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;
}
#include <iostream>
using namespace std;
int main() {
// for循环语句：作用先满足循环条件 执行循环语句
//语法：for(起始表达式;条件表达式;末尾循环体){循环语句}
//示例：
for (int i = 0; i < 100; ++i) {
cout<<i<<endl;
}
}
#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;
}
}
#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:;
}
#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;
}
#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;
}
}
#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;
}
#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;
}
#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;
}
#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);//因为这个函数没有返回值 所以不需要定义其他变量来接收这个值
// 当我们做值传递的时候 形参发送改变 并不会影响实参
}
#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;
}
#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;
}
swap. h
# include <iostream> ;
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)//注意 在分文件编写的时候 一定要把文件的添加 加上 不然会无法识别
#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;
}
#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;
}
#include <iostream>
int main() {
/* 空指针：空指针用于给指针变量进行初始化
*
*
*
*
* */
int *p=NULL;
// 2.空指针是不可以访问的 0-255之间的内存编号 是系统占用的 是不可以访问的
std::cout<<p<<std::endl;
std::cout << "Hello, World!" << std::endl;
return 0;
}
#include <iostream>
using namespace std;
int main() {
// 野指针 ：指针变量指向非法的内存空间
//1.创建一个指针
int *p=(int *)0x1100;
cout<<*p<<endl;//在程序中 避免出现指针情况
}
#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;//特点：指针的指向不可以改 指向指向的值可以改
}
#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++;
}
}
#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);
}
#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);
}
#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;
}
#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.变量结构体数组
}
#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;
/*
* 结构体指针：通过指针访问结构体中的成员
* 利用操作符 -> 可以通过结构体指针访问结构体属性
*
*
* */
}
#include <iostream>
#include "string"
using namespace std;
//作用：结构体中的成员可以是另一个结构体
/*
* 1.嵌套结构体的使用
*
*
*
*
*
* */
struct student{//定义一个学生的结构体
string name;//学生姓名
int age;//学生年龄
int score;//学生成绩
};
//定义一个结构体
struct teacher{
int id;//教师编号
string name;//教师姓名
int age;//教师年龄
struct student stu;//辅导的学生
};
int main() {
teacher t;
//调用里面的属性
t.id=001;
t.name="吴邪";
t.age=35;
t.stu.name="黎簇";//在嵌套结构体里面 调用最里面的属性 需要使用点号 依次从外到里依次调用
t.stu.age=19;
t.stu.score=98;
cout<<"教师姓名："<<t.name<<" 老师年龄："<<t.age<<" 老师id号："<<t.id<<" 老师辅导的学生："<<t.stu.name<<" 老师辅导学生的成绩："<<
t.stu.score<<endl;
}
#include <iostream>
#include "string"
using namespace std;
/*
* 作用：将结构体作为参数向函数中传递
*
* 传递方式：值传递 地址传递
*
*
* */
//结构体作为函数参数
//将插入到一个参数中 打印学生身上的所有信息
struct student{
string name;//姓名
int age;//年龄
int score;//分数
};
//1.值传递
//打印学生信息的函数
void printStudent1(struct student s){
cout<<"子函数"<< s.name<< s.age<< s.score<<endl;
}
//2.地址传递
void printStudent2(struct student *s){
cout<<"地址传递:"<<s->name<< s->age<< s->score<<endl;
}
int main() {
// 创建一个结构体变量
struct student s;
string n= s.name="吴邪";
int a= s.age=35;
int l= s.score=98;
cout<<" 学生姓名："<<n<<" 学生年龄："<<a<<" 学生成绩："<<l<<endl;
//1.值传递
printStudent1(s);
//2.地址传递
printStudent2(&s);
}
#include <iostream>
#include "string"
using namespace std;
/*
* 使用const：作用就是防止一个误操作
*
* */
struct student{
string name;
int age;
int score;
};
//将函数中的形参改为指针 可以减少内存空间 而且不会复制新的副本出来
void printStudent(const student *s){
cout<<"姓名"<<s->name<<s->score<<s->age<<endl;
}
int main() {
// 创建结构体变量
struct student s={"吴邪",28,98};
//通过函数来打印信息
printStudent(&s);
}
#include <iostream>
#include "string"
using namespace std;
//定义学生的结构体
struct Student{
// 学生姓名
string sName;
// 分数：
int score;
};
//老师结构体定义：
struct Teacher{
// 姓名
string tName;
struct Student sArray[5];//学生数组
};
//给老师和学生赋值的函数
void allocateSpace(struct Teacher tArray[],int len){
string nameSeed="teacher";
// 给老师进行赋值
for (int i = 0; i < len; ++i) {
tArray[i].tName="Teacher";
tArray[i].tName+=nameSeed[i];
// 通过循环给每名老师所带的学生赋值
for (int j = 0; j < 5; ++j) {
tArray[i].sArray[j].sName="Student";
tArray[i].tName+=nameSeed[j];
tArray[i].sArray[j].score=60;
}
}
}
//打印所有信息的函数
void printInfo(struct Teacher tArray[],int len){
for (int i = 0; i < len; ++i) {
cout<<"老师姓名\t"<<tArray[i].tName<<"老师年龄\t"<<endl;
for (int j = 0; j < 5; ++j) {
cout<<"\t学生姓名："<<tArray[i].sArray[j].sName<<"\t学生成绩\t"<<tArray[i].sArray[j].score<<endl;
}
}}
int main() {
//创建三名老师的数组
struct Teacher tArray[3];
//通过函数给三名老师数组赋值 并且给学生也赋值
int len=sizeof (tArray)/sizeof (tArray[0]);
allocateSpace(tArray,len);
//打印老师及所带学生的信息
printInfo(tArray,len);
}
#include <iostream>
#include "string"
using namespace std;
/* 1.系统需求：
* 功能如下：
* 添加联系人 向通讯录里面添加联系人 信息包括（姓名 性别 年龄 联系电话 家庭住址） 最多记录1000人
* 显示联系人：显示通讯录中所有联系人信息
* 删除联系人 按照姓名进行删除指定联系人
* 查找联系人 按照姓名查看指定联系人信息
* 修改联系人 按照姓名重新修改指定联系人
* 清空联系人 清空通讯录中的所有信息
* 退出通讯录 退出当前使用的通讯录
*
*
*
*
* 1.创建项目：
* 2.添加文件
*
*
*
*
* */
//菜单界面
void showMenu(){
cout<<"****1.添加联系人****"<<endl;
cout<<"****2.显示联系人****"<<endl;
cout<<"****3.删除联系人****"<<endl;
cout<<"****4.查找联系人****"<<endl;
cout<<"****5.修改联系人****"<<endl;
cout<<"****6.清空联系人****"<<endl;
cout<<"****0.退出通讯录****"<<endl;
}
int main() {
showMenu();
system("pause");
}
#include <iostream>
#include "string"
using namespace std;
/* 1.系统需求：
* 功能如下：
* 添加联系人 向通讯录里面添加联系人 信息包括（姓名 性别 年龄 联系电话 家庭住址） 最多记录1000人
* 显示联系人：显示通讯录中所有联系人信息
* 删除联系人 按照姓名进行删除指定联系人
* 查找联系人 按照姓名查看指定联系人信息
* 修改联系人 按照姓名重新修改指定联系人
* 清空联系人 清空通讯录中的所有信息
* 退出通讯录 退出当前使用的通讯录
*
*
*
*
* 1.创建项目：
* 2.添加文件
*
*
*
*
* */
//菜单界面
void showMenu(){
cout<<"****1.添加联系人****"<<endl;
cout<<"****2.显示联系人****"<<endl;
cout<<"****3.删除联系人****"<<endl;
cout<<"****4.查找联系人****"<<endl;
cout<<"****5.修改联系人****"<<endl;
cout<<"****6.清空联系人****"<<endl;
cout<<"****0.退出通讯录****"<<endl;
}
int main() {
int select=0;//创建用户选择输入的变量
while (true){
showMenu();//菜单调用
cout<<"请选择功能："<<endl;
cin>>select;
switch (select) {
case 1: //1.添加联系人
break;
case 2: //2.显示联系人
break;
case 3://3.删除联系人
break;
case 4://4.查找联系人
break;
case 5://5.修改联系人
break;
case 6://6.清空联系人
break;
case 0://0 退出通讯
cout<<"欢迎 下次使用"<<endl;
system("pause");
return 0;
break;
}
}
system("pause");
}
#include <iostream>
#include "string"
using namespace std;
#define MAX 1000
/* 1.系统需求：
* 功能如下：
* 添加联系人 向通讯录里面添加联系人 信息包括（姓名 性别 年龄 联系电话 家庭住址） 最多记录1000人
* 显示联系人：显示通讯录中所有联系人信息
* 删除联系人 按照姓名进行删除指定联系人
* 查找联系人 按照姓名查看指定联系人信息
* 修改联系人 按照姓名重新修改指定联系人
* 清空联系人 清空通讯录中的所有信息
* 退出通讯录 退出当前使用的通讯录
*
*
*
*
* 1.创建项目：
* 2.添加文件
*
*
*
*
* */
//菜单界面
void showMenu(){
cout<<"****1.添加联系人****"<<endl;
cout<<"****2.显示联系人****"<<endl;
cout<<"****3.删除联系人****"<<endl;
cout<<"****4.查找联系人****"<<endl;
cout<<"****5.修改联系人****"<<endl;
cout<<"****6.清空联系人****"<<endl;
cout<<"****0.退出通讯录****"<<endl;
}
//设计联系人结构体
struct Person{
// 姓名
string m_Name;
//性别
int m_Sex;
//年龄
int m_age;
//电话
string m_Phone;
//住址
string m_Addr;
};
//设计通讯录结构体
struct Addressbooks{
// 通讯录保存的联系人
struct Person personArray[MAX];
//通讯录中当前记录联系人的个数
int m_Size;
};
int main() {
int select=0;//创建用户选择输入的变量
while (true){
showMenu();//菜单调用
cout<<"请选择功能："<<endl;
cin>>select;
switch (select) {
case 1: //1.添加联系人
break;
case 2: //2.显示联系人
break;
case 3://3.删除联系人
break;
case 4://4.查找联系人
break;
case 5://5.修改联系人
break;
case 6://6.清空联系人
break;
case 0://0 退出通讯
cout<<"欢迎 下次使用"<<endl;
system("pause");
return 0;
break;
}
}
system("pause");
}
#include <iostream>
#include "string"
using namespace std;
#define MAX 1000
/* 1.系统需求：
* 功能如下：
* 添加联系人 向通讯录里面添加联系人 信息包括（姓名 性别 年龄 联系电话 家庭住址） 最多记录1000人
* 显示联系人：显示通讯录中所有联系人信息
* 删除联系人 按照姓名进行删除指定联系人
* 查找联系人 按照姓名查看指定联系人信息
* 修改联系人 按照姓名重新修改指定联系人
* 清空联系人 清空通讯录中的所有信息
* 退出通讯录 退出当前使用的通讯录
*
*
*
*
* 1.创建项目：
* 2.添加文件
*
*
*
*
* */
//菜单界面
void showMenu(){
cout<<"****1.添加联系人****"<<endl;
cout<<"****2.显示联系人****"<<endl;
cout<<"****3.删除联系人****"<<endl;
cout<<"****4.查找联系人****"<<endl;
cout<<"****5.修改联系人****"<<endl;
cout<<"****6.清空联系人****"<<endl;
cout<<"****0.退出通讯录****"<<endl;
}
//设计联系人结构体
struct Person{
// 姓名
string m_Name;
//性别
int m_Sex;
//年龄
int m_age;
//电话
string m_Phone;
//住址
string m_Addr;
};
//设计通讯录结构体
struct Addressbooks{
// 通讯录保存的联系人
struct Person personArray[MAX];
//通讯录中当前记录联系人的个数
int m_Size;
};
//添加联系人
void addPerson(Addressbooks *abs){
// 判断通讯录是不是已经满了 如果满了 就不在添加了
if (abs->m_Size==MAX){
cout<<"通讯录已经满了 无法在添加了"<<endl;
return;
} else{
// 添加具体联系人
//姓名
string name;
cout<<"请输入姓名"<<endl;
cin>>name;
abs->personArray[abs->m_Size].m_Name=name;
//性别
cout<<"请输入性别："<<endl;
cout<<"1，男"<<endl;
cout<<"2、女"<<endl;
int sex=0;
while (true){
cin>>sex;
if (sex==1||sex==2){
abs->personArray[abs->m_Size].m_Sex=sex;
break;
}
cout<<"输入错误 重新输入"<<endl;
}
//年龄
cout<<"请输入年龄"<<endl;
int age=0;
cin>>age;
abs->personArray[abs->m_Size].m_age=age;
//电话
cout<<"请输入联系电话"<<endl;
string phone;
cin>>phone;
abs->personArray[abs->m_Size].m_Phone=phone;
//住址
cout<<"请输入家庭住址："<<endl;
string address;
cin>>address;
abs->personArray[abs->m_Size].m_Addr=address;
}
// 更新通讯录人数
abs->m_Size++;
cout<<"添加成功！"<<endl;
system("pause");//请按任意键操作
system("cls");//清屏操作
}
int main() {
// 创建通讯录的结构体变量
Addressbooks abs;
// 初始化通讯录中当前人员个数
abs.m_Size=0;
int select=0;//创建用户选择输入的变量
while (true){
showMenu();//菜单调用
cout<<"请选择功能："<<endl;
cin>>select;
switch (select) {
case 1: //1.添加联系人
addPerson(&abs);//利用地址传递可以修改参数
break;
case 2: //2.显示联系人
break;
case 3://3.删除联系人
break;
case 4://4.查找联系人
break;
case 5://5.修改联系人
break;
case 6://6.清空联系人
break;
case 0://0 退出通讯
cout<<"欢迎 下次使用"<<endl;
system("pause");
return 0;
break;
}
}
system("pause");
}
#include <iostream>
#include "string"
using namespace std;
#define MAX 1000
/* 1.系统需求：
* 功能如下：
* 添加联系人 向通讯录里面添加联系人 信息包括（姓名 性别 年龄 联系电话 家庭住址） 最多记录1000人
* 显示联系人：显示通讯录中所有联系人信息
* 删除联系人 按照姓名进行删除指定联系人
* 查找联系人 按照姓名查看指定联系人信息
* 修改联系人 按照姓名重新修改指定联系人
* 清空联系人 清空通讯录中的所有信息
* 退出通讯录 退出当前使用的通讯录
*
*
*
*
* 1.创建项目：
* 2.添加文件
*
*
*
*
* */
//菜单界面
void showMenu(){
cout<<"****1.添加联系人****"<<endl;
cout<<"****2.显示联系人****"<<endl;
cout<<"****3.删除联系人****"<<endl;
cout<<"****4.查找联系人****"<<endl;
cout<<"****5.修改联系人****"<<endl;
cout<<"****6.清空联系人****"<<endl;
cout<<"****0.退出通讯录****"<<endl;
}
//设计联系人结构体
struct Person{
// 姓名
string m_Name;
//性别
int m_Sex;
//年龄
int m_age;
//电话
string m_Phone;
//住址
string m_Addr;
};
//设计通讯录结构体
struct Addressbooks{
// 通讯录保存的联系人
struct Person personArray[MAX];
//通讯录中当前记录联系人的个数
int m_Size;
};
//添加联系人
void addPerson(Addressbooks *abs){
// 判断通讯录是不是已经满了 如果满了 就不在添加了
if (abs->m_Size==MAX){
cout<<"通讯录已经满了 无法在添加了"<<endl;
return;
} else{
// 添加具体联系人
//姓名
string name;
cout<<"请输入姓名"<<endl;
cin>>name;
abs->personArray[abs->m_Size].m_Name=name;
//性别
cout<<"请输入性别："<<endl;
cout<<"1，男"<<endl;
cout<<"2、女"<<endl;
int sex=0;
while (true){
cin>>sex;
if (sex==1||sex==2){
abs->personArray[abs->m_Size].m_Sex=sex;
break;
}
cout<<"输入错误 重新输入"<<endl;
}
//年龄
cout<<"请输入年龄"<<endl;
int age=0;
cin>>age;
abs->personArray[abs->m_Size].m_age=age;
//电话
cout<<"请输入联系电话"<<endl;
string phone;
cin>>phone;
abs->personArray[abs->m_Size].m_Phone=phone;
//住址
cout<<"请输入家庭住址："<<endl;
string address;
cin>>address;
abs->personArray[abs->m_Size].m_Addr=address;
}
// 更新通讯录人数
abs->m_Size++;
cout<<"添加成功！"<<endl;
system("pause");//请按任意键操作
system("cls");//清屏操作
}
//显示联系人
//判断如果当前通讯录中没有人员 就提示记录为空 人数大于0 显示通讯录中信息
void showPerson(Addressbooks *abs){
// 判断通讯录人数是否为0 如果为0 提示记录为空 如果不为0
// 显示记录联系人信息
if (abs->m_Size==0){
cout<<"当前记录为空"<<endl;
} else{
for (int i = 0; i < abs->m_Size; ++i) {
cout<<"姓名："<<abs->personArray[i].m_Name<<endl;
cout<<"性别："<<abs->personArray[i].m_Sex<<endl;
cout<<"年龄："<<abs->personArray[i].m_age <<endl;
cout<<"电话："<<abs->personArray[i].m_Phone<<endl;
cout<<"住址："<<abs->personArray[i].m_Addr<<endl;
}
}
system("pause");//按任意键继续
system("cls");//清空屏幕
}
int main() {
// 创建通讯录的结构体变量
Addressbooks abs;
// 初始化通讯录中当前人员个数
abs.m_Size=0;
int select=0;//创建用户选择输入的变量
while (true){
showMenu();//菜单调用
cout<<"请选择功能："<<endl;
cin>>select;
switch (select) {
case 1: //1.添加联系人
addPerson(&abs);//利用地址传递可以修改参数
break;
case 2: //2.显示联系人
showPerson(&abs);
break;
case 3://3.删除联系人
break;
case 4://4.查找联系人
break;
case 5://5.修改联系人
break;
case 6://6.清空联系人
break;
case 0://0 退出通讯
cout<<"欢迎 下次使用"<<endl;
system("pause");
return 0;
break;
}
}
system("pause");
}
#include <iostream>
#include "string"
using namespace std;
#define MAX 1000
/* 1.系统需求：
* 功能如下：
* 添加联系人 向通讯录里面添加联系人 信息包括（姓名 性别 年龄 联系电话 家庭住址） 最多记录1000人
* 显示联系人：显示通讯录中所有联系人信息
* 删除联系人 按照姓名进行删除指定联系人
* 查找联系人 按照姓名查看指定联系人信息
* 修改联系人 按照姓名重新修改指定联系人
* 清空联系人 清空通讯录中的所有信息
* 退出通讯录 退出当前使用的通讯录
*
*
*
*
* 1.创建项目：
* 2.添加文件
*
*
*
*
* */
//菜单界面
void showMenu(){
cout<<"****1.添加联系人****"<<endl;
cout<<"****2.显示联系人****"<<endl;
cout<<"****3.删除联系人****"<<endl;
cout<<"****4.查找联系人****"<<endl;
cout<<"****5.修改联系人****"<<endl;
cout<<"****6.清空联系人****"<<endl;
cout<<"****0.退出通讯录****"<<endl;
}
//设计联系人结构体
struct Person{
// 姓名
string m_Name;
//性别
int m_Sex;
//年龄
int m_age;
//电话
string m_Phone;
//住址
string m_Addr;
};
//设计通讯录结构体
struct Addressbooks{
// 通讯录保存的联系人
struct Person personArray[MAX];
//通讯录中当前记录联系人的个数
int m_Size;
};
//添加联系人
void addPerson(Addressbooks *abs){
// 判断通讯录是不是已经满了 如果满了 就不在添加了
if (abs->m_Size==MAX){
cout<<"通讯录已经满了 无法在添加了"<<endl;
return;
} else{
// 添加具体联系人
//姓名
string name;
cout<<"请输入姓名"<<endl;
cin>>name;
abs->personArray[abs->m_Size].m_Name=name;
//性别
cout<<"请输入性别："<<endl;
cout<<"1，男"<<endl;
cout<<"2、女"<<endl;
int sex=0;
while (true){
cin>>sex;
if (sex==1||sex==2){
abs->personArray[abs->m_Size].m_Sex=sex;
break;
}
cout<<"输入错误 重新输入"<<endl;
}
//年龄
cout<<"请输入年龄"<<endl;
int age=0;
cin>>age;
abs->personArray[abs->m_Size].m_age=age;
//电话
cout<<"请输入联系电话"<<endl;
string phone;
cin>>phone;
abs->personArray[abs->m_Size].m_Phone=phone;
//住址
cout<<"请输入家庭住址："<<endl;
string address;
cin>>address;
abs->personArray[abs->m_Size].m_Addr=address;
}
// 更新通讯录人数
abs->m_Size++;
cout<<"添加成功！"<<endl;
system("pause");//请按任意键操作
system("cls");//清屏操作
}
//删除联系人
//按照姓名进行删除联系人
int isExist(Addressbooks *abs,string name){
// 参数1 通讯录 参数2 对比姓名
for (int i = 0; i < abs->m_Size; ++i) {
//找到用户输入的姓名
if (abs->personArray[i].m_Name==name)
{
return i;
}
}
return -1;//如果遍历结束都没有找到 返回-1
}
//显示联系人
//判断如果当前通讯录中没有人员 就提示记录为空 人数大于0 显示通讯录中信息
void showPerson(Addressbooks *abs){
// 判断通讯录人数是否为0 如果为0 提示记录为空 如果不为0
// 显示记录联系人信息
if (abs->m_Size==0){
cout<<"当前记录为空"<<endl;
} else{
for (int i = 0; i < abs->m_Size; ++i) {
cout<<"姓名："<<abs->personArray[i].m_Name<<endl;
cout<<"性别："<<abs->personArray[i].m_Sex<<endl;
cout<<"年龄："<<abs->personArray[i].m_age <<endl;
cout<<"电话："<<abs->personArray[i].m_Phone<<endl;
cout<<"住址："<<abs->personArray[i].m_Addr<<endl;
}
}
system("pause");//按任意键继续
system("cls");//清空屏幕
}
int main() {
// 创建通讯录的结构体变量
Addressbooks abs;
// 初始化通讯录中当前人员个数
abs.m_Size=0;
int select=0;//创建用户选择输入的变量
while (true){
showMenu();//菜单调用
cout<<"请选择功能："<<endl;
cin>>select;
switch (select) {
case 1: //1.添加联系人
addPerson(&abs);//利用地址传递可以修改参数
break;
case 2: //2.显示联系人
showPerson(&abs);
break;
case 3://3.删除联系人
//这里代码太多了 用代码块来封装就好
{
cout<<"请输入姓名"<<endl;
string name;
cin>>name;
if (isExist(&abs,name)) {
cout<<"没有这个人"<<endl;
} else{
cout<<"找到了"<<endl;
}
}
break;
case 4://4.查找联系人
break;
case 5://5.修改联系人
break;
case 6://6.清空联系人
break;
case 0://0 退出通讯
cout<<"欢迎 下次使用"<<endl;
system("pause");
return 0;
break;
}
}
system("pause");
}
#include <iostream>
#include "string"
using namespace std;
#define MAX 1000
/* 1.系统需求：
* 功能如下：
* 添加联系人 向通讯录里面添加联系人 信息包括（姓名 性别 年龄 联系电话 家庭住址） 最多记录1000人
* 显示联系人：显示通讯录中所有联系人信息
* 删除联系人 按照姓名进行删除指定联系人
* 查找联系人 按照姓名查看指定联系人信息
* 修改联系人 按照姓名重新修改指定联系人
* 清空联系人 清空通讯录中的所有信息
* 退出通讯录 退出当前使用的通讯录
*
*
*
*
* 1.创建项目：
* 2.添加文件
*
*
*
*
* */
//菜单界面
void showMenu(){
cout<<"****1.添加联系人****"<<endl;
cout<<"****2.显示联系人****"<<endl;
cout<<"****3.删除联系人****"<<endl;
cout<<"****4.查找联系人****"<<endl;
cout<<"****5.修改联系人****"<<endl;
cout<<"****6.清空联系人****"<<endl;
cout<<"****0.退出通讯录****"<<endl;
}
//设计联系人结构体
struct Person{
// 姓名
string m_Name;
//性别
int m_Sex;
//年龄
int m_age;
//电话
string m_Phone;
//住址
string m_Addr;
};
//设计通讯录结构体
struct Addressbooks{
// 通讯录保存的联系人
struct Person personArray[MAX];
//通讯录中当前记录联系人的个数
int m_Size;
};
//添加联系人
void addPerson(Addressbooks *abs){
// 判断通讯录是不是已经满了 如果满了 就不在添加了
if (abs->m_Size==MAX){
cout<<"通讯录已经满了 无法在添加了"<<endl;
return;
} else{
// 添加具体联系人
//姓名
string name;
cout<<"请输入姓名"<<endl;
cin>>name;
abs->personArray[abs->m_Size].m_Name=name;
//性别
cout<<"请输入性别："<<endl;
cout<<"1，男"<<endl;
cout<<"2、女"<<endl;
int sex=0;
while (true){
cin>>sex;
if (sex==1||sex==2){
abs->personArray[abs->m_Size].m_Sex=sex;
break;
}
cout<<"输入错误 重新输入"<<endl;
}
//年龄
cout<<"请输入年龄"<<endl;
int age=0;
cin>>age;
abs->personArray[abs->m_Size].m_age=age;
//电话
cout<<"请输入联系电话"<<endl;
string phone;
cin>>phone;
abs->personArray[abs->m_Size].m_Phone=phone;
//住址
cout<<"请输入家庭住址："<<endl;
string address;
cin>>address;
abs->personArray[abs->m_Size].m_Addr=address;
}
// 更新通讯录人数
abs->m_Size++;
cout<<"添加成功！"<<endl;
system("pause");//请按任意键操作
system("cls");//清屏操作
}
//删除联系人
//按照姓名进行删除联系人
int isExist(Addressbooks *abs,string name){
// 参数1 通讯录 参数2 对比姓名
for (int i = 0; i < abs->m_Size; ++i) {
//找到用户输入的姓名
if (abs->personArray[i].m_Name==name)
{
return i;
}
}
return -1;//如果遍历结束都没有找到 返回-1
}
//显示联系人
//判断如果当前通讯录中没有人员 就提示记录为空 人数大于0 显示通讯录中信息
void showPerson(Addressbooks *abs){
// 判断通讯录人数是否为0 如果为0 提示记录为空 如果不为0
// 显示记录联系人信息
if (abs->m_Size==0){
cout<<"当前记录为空"<<endl;
} else{
for (int i = 0; i < abs->m_Size; ++i) {
cout<<"姓名："<<abs->personArray[i].m_Name<<endl;
cout<<"性别："<<abs->personArray[i].m_Sex<<endl;
cout<<"年龄："<<abs->personArray[i].m_age <<endl;
cout<<"电话："<<abs->personArray[i].m_Phone<<endl;
cout<<"住址："<<abs->personArray[i].m_Addr<<endl;
}
}
system("pause");//按任意键继续
system("cls");//清空屏幕
}
//删除联系人
void deletePerson(Addressbooks *abs){
cout<<"请输入要输出的联系人"<<endl;
string name;
cin>>name;
// 调用判断联系人是否存在的函数
int ret= isExist(abs,name);
if (ret!=-1){
// 找到了 那就要删除了
for (int i = 0; i < abs->m_Size; ++i) {
// 数据前移操作
abs->personArray[i]=abs->personArray[i+1];
}
abs->m_Size--;
cout<<"删除成功了"<<endl;
} else{
cout<<"查无此人"<<endl;
}
}
int main() {
// 创建通讯录的结构体变量
Addressbooks abs;
// 初始化通讯录中当前人员个数
abs.m_Size=0;
int select=0;//创建用户选择输入的变量
while (true){
showMenu();//菜单调用
cout<<"请选择功能："<<endl;
cin>>select;
switch (select) {
case 1: //1.添加联系人
addPerson(&abs);//利用地址传递可以修改参数
break;
case 2: //2.显示联系人
showPerson(&abs);
break;
case 3://3.删除联系人
//这里代码太多了 用代码块来封装就好
{
cout<<"请输入姓名"<<endl;
string name;
cin>>name;
if (isExist(&abs,name)) {
cout<<"没有这个人"<<endl;
} else{
cout<<"找到了"<<endl;
// 调用删除函数
deletePerson(&abs);
}
}
break;
case 4://4.查找联系人
break;
case 5://5.修改联系人
break;
case 6://6.清空联系人
break;
case 0://0 退出通讯
cout<<"欢迎 下次使用"<<endl;
system("pause");
return 0;
break;
}
}
system("pause");
}
#include <iostream>
#include "string"
using namespace std;
#define MAX 1000
/* 1.系统需求：
* 功能如下：
* 添加联系人 向通讯录里面添加联系人 信息包括（姓名 性别 年龄 联系电话 家庭住址） 最多记录1000人
* 显示联系人：显示通讯录中所有联系人信息
* 删除联系人 按照姓名进行删除指定联系人
* 查找联系人 按照姓名查看指定联系人信息
* 修改联系人 按照姓名重新修改指定联系人
* 清空联系人 清空通讯录中的所有信息
* 退出通讯录 退出当前使用的通讯录
*
*
*
*
* 1.创建项目：
* 2.添加文件
*
*
*
*
* */
//菜单界面
void showMenu(){
cout<<"****1.添加联系人****"<<endl;
cout<<"****2.显示联系人****"<<endl;
cout<<"****3.删除联系人****"<<endl;
cout<<"****4.查找联系人****"<<endl;
cout<<"****5.修改联系人****"<<endl;
cout<<"****6.清空联系人****"<<endl;
cout<<"****0.退出通讯录****"<<endl;
}
//设计联系人结构体
struct Person{
// 姓名
string m_Name;
//性别
int m_Sex;
//年龄
int m_age;
//电话
string m_Phone;
//住址
string m_Addr;
};
//设计通讯录结构体
struct Addressbooks{
// 通讯录保存的联系人
struct Person personArray[MAX];
//通讯录中当前记录联系人的个数
int m_Size;
};
//添加联系人
void addPerson(Addressbooks *abs){
// 判断通讯录是不是已经满了 如果满了 就不在添加了
if (abs->m_Size==MAX){
cout<<"通讯录已经满了 无法在添加了"<<endl;
return;
} else{
// 添加具体联系人
//姓名
string name;
cout<<"请输入姓名"<<endl;
cin>>name;
abs->personArray[abs->m_Size].m_Name=name;
//性别
cout<<"请输入性别："<<endl;
cout<<"1，男"<<endl;
cout<<"2、女"<<endl;
int sex=0;
while (true){
cin>>sex;
if (sex==1||sex==2){
abs->personArray[abs->m_Size].m_Sex=sex;
break;
}
cout<<"输入错误 重新输入"<<endl;
}
//年龄
cout<<"请输入年龄"<<endl;
int age=0;
cin>>age;
abs->personArray[abs->m_Size].m_age=age;
//电话
cout<<"请输入联系电话"<<endl;
string phone;
cin>>phone;
abs->personArray[abs->m_Size].m_Phone=phone;
//住址
cout<<"请输入家庭住址："<<endl;
string address;
cin>>address;
abs->personArray[abs->m_Size].m_Addr=address;
}
// 更新通讯录人数
abs->m_Size++;
cout<<"添加成功！"<<endl;
system("pause");//请按任意键操作
system("cls");//清屏操作
}
//删除联系人
//按照姓名进行删除联系人
int isExist(Addressbooks *abs,string name){
// 参数1 通讯录 参数2 对比姓名
for (int i = 0; i < abs->m_Size; ++i) {
//找到用户输入的姓名
if (abs->personArray[i].m_Name==name)
{
return i;
}
}
return -1;//如果遍历结束都没有找到 返回-1
}
//显示联系人
//判断如果当前通讯录中没有人员 就提示记录为空 人数大于0 显示通讯录中信息
void showPerson(Addressbooks *abs){
// 判断通讯录人数是否为0 如果为0 提示记录为空 如果不为0
// 显示记录联系人信息
if (abs->m_Size==0){
cout<<"当前记录为空"<<endl;
} else{
for (int i = 0; i < abs->m_Size; ++i) {
cout<<"姓名："<<abs->personArray[i].m_Name<<endl;
cout<<"性别："<<abs->personArray[i].m_Sex<<endl;
cout<<"年龄："<<abs->personArray[i].m_age <<endl;
cout<<"电话："<<abs->personArray[i].m_Phone<<endl;
cout<<"住址："<<abs->personArray[i].m_Addr<<endl;
}
}
system("pause");//按任意键继续
system("cls");//清空屏幕
}
//删除联系人
void deletePerson(Addressbooks *abs){
cout<<"请输入要输出的联系人"<<endl;
string name;
cin>>name;
// 调用判断联系人是否存在的函数
int ret= isExist(abs,name);
if (ret!=-1){
// 找到了 那就要删除了
for (int i = 0; i < abs->m_Size; ++i) {
// 数据前移操作
abs->personArray[i]=abs->personArray[i+1];
}
abs->m_Size--;
cout<<"删除成功了"<<endl;
} else{
cout<<"查无此人"<<endl;
}
}
//查找指定联系人信息
void FindPerson(Addressbooks *abs){
cout<<"请输入您要查找的联系人"<<endl;
string name;
cin>>name;
// 判断指定的联系人是否存在
int ret= isExist(abs,name);
if (ret !=-1){
// 找到了联系人
cout<<"姓名"<<abs->personArray[ret].m_Name<<"\t";
cout<<"性别"<<abs->personArray[ret].m_Sex<<"\t";
cout<<"年龄"<<abs->personArray[ret].m_age<<"\t";
cout<<"电话"<<abs->personArray[ret].m_Phone<<"\t";
} else{
cout<<"查无此人"<<endl;
}
}
int main() {
// 创建通讯录的结构体变量
Addressbooks abs;
// 初始化通讯录中当前人员个数
abs.m_Size=0;
int select=0;//创建用户选择输入的变量
while (true){
showMenu();//菜单调用
cout<<"请选择功能："<<endl;
cin>>select;
switch (select) {
case 1: //1.添加联系人
addPerson(&abs);//利用地址传递可以修改参数
break;
case 2: //2.显示联系人
showPerson(&abs);
break;
case 3://3.删除联系人
//这里代码太多了 用代码块来封装就好
{
cout<<"请输入姓名"<<endl;
string name;
cin>>name;
if (isExist(&abs,name)) {
cout<<"没有这个人"<<endl;
} else{
cout<<"找到了"<<endl;
// 调用删除函数
deletePerson(&abs);
}
}
break;
case 4://4.查找联系人
FindPerson(&abs);
break;
case 5://5.修改联系人
break;
case 6://6.清空联系人
break;
case 0://0 退出通讯
cout<<"欢迎 下次使用"<<endl;
system("pause");
return 0;
break;
}
}
system("pause");
}
#include <iostream>
#include "string"
using namespace std;
#define MAX 1000
/* 1.系统需求：
* 功能如下：
* 添加联系人 向通讯录里面添加联系人 信息包括（姓名 性别 年龄 联系电话 家庭住址） 最多记录1000人
* 显示联系人：显示通讯录中所有联系人信息
* 删除联系人 按照姓名进行删除指定联系人
* 查找联系人 按照姓名查看指定联系人信息
* 修改联系人 按照姓名重新修改指定联系人
* 清空联系人 清空通讯录中的所有信息
* 退出通讯录 退出当前使用的通讯录
*
*
*
*
* 1.创建项目：
* 2.添加文件
*
*
*
*
* */
//菜单界面
void showMenu(){
cout<<"****1.添加联系人****"<<endl;
cout<<"****2.显示联系人****"<<endl;
cout<<"****3.删除联系人****"<<endl;
cout<<"****4.查找联系人****"<<endl;
cout<<"****5.修改联系人****"<<endl;
cout<<"****6.清空联系人****"<<endl;
cout<<"****0.退出通讯录****"<<endl;
}
//设计联系人结构体
struct Person{
// 姓名
string m_Name;
//性别
int m_Sex;
//年龄
int m_age;
//电话
string m_Phone;
//住址
string m_Addr;
};
//设计通讯录结构体
struct Addressbooks{
// 通讯录保存的联系人
struct Person personArray[MAX];
//通讯录中当前记录联系人的个数
int m_Size;
};
//添加联系人
void addPerson(Addressbooks *abs){
// 判断通讯录是不是已经满了 如果满了 就不在添加了
if (abs->m_Size==MAX){
cout<<"通讯录已经满了 无法在添加了"<<endl;
return;
} else{
// 添加具体联系人
//姓名
string name;
cout<<"请输入姓名"<<endl;
cin>>name;
abs->personArray[abs->m_Size].m_Name=name;
//性别
cout<<"请输入性别："<<endl;
cout<<"1，男"<<endl;
cout<<"2、女"<<endl;
int sex=0;
while (true){
cin>>sex;
if (sex==1||sex==2){
abs->personArray[abs->m_Size].m_Sex=sex;
break;
}
cout<<"输入错误 重新输入"<<endl;
}
//年龄
cout<<"请输入年龄"<<endl;
int age=0;
cin>>age;
abs->personArray[abs->m_Size].m_age=age;
//电话
cout<<"请输入联系电话"<<endl;
string phone;
cin>>phone;
abs->personArray[abs->m_Size].m_Phone=phone;
//住址
cout<<"请输入家庭住址："<<endl;
string address;
cin>>address;
abs->personArray[abs->m_Size].m_Addr=address;
}
// 更新通讯录人数
abs->m_Size++;
cout<<"添加成功！"<<endl;
system("pause");//请按任意键操作
system("cls");//清屏操作
}
//删除联系人
//按照姓名进行删除联系人
int isExist(Addressbooks *abs,string name){
// 参数1 通讯录 参数2 对比姓名
for (int i = 0; i < abs->m_Size; ++i) {
//找到用户输入的姓名
if (abs->personArray[i].m_Name==name)
{
return i;
}
}
return -1;//如果遍历结束都没有找到 返回-1
}
//显示联系人
//判断如果当前通讯录中没有人员 就提示记录为空 人数大于0 显示通讯录中信息
void showPerson(Addressbooks *abs){
// 判断通讯录人数是否为0 如果为0 提示记录为空 如果不为0
// 显示记录联系人信息
if (abs->m_Size==0){
cout<<"当前记录为空"<<endl;
} else{
for (int i = 0; i < abs->m_Size; ++i) {
cout<<"姓名："<<abs->personArray[i].m_Name<<endl;
cout<<"性别："<<abs->personArray[i].m_Sex<<endl;
cout<<"年龄："<<abs->personArray[i].m_age <<endl;
cout<<"电话："<<abs->personArray[i].m_Phone<<endl;
cout<<"住址："<<abs->personArray[i].m_Addr<<endl;
}
}
system("pause");//按任意键继续
system("cls");//清空屏幕
}
//删除联系人
void deletePerson(Addressbooks *abs){
cout<<"请输入要输出的联系人"<<endl;
string name;
cin>>name;
// 调用判断联系人是否存在的函数
int ret= isExist(abs,name);
if (ret!=-1){
// 找到了 那就要删除了
for (int i = 0; i < abs->m_Size; ++i) {
// 数据前移操作
abs->personArray[i]=abs->personArray[i+1];
}
abs->m_Size--;
cout<<"删除成功了"<<endl;
} else{
cout<<"查无此人"<<endl;
}
}
//查找指定联系人信息
void FindPerson(Addressbooks *abs){
cout<<"请输入您要查找的联系人"<<endl;
string name;
cin>>name;
// 判断指定的联系人是否存在
int ret= isExist(abs,name);
if (ret !=-1){
// 找到了联系人
cout<<"姓名"<<abs->personArray[ret].m_Name<<"\t";
cout<<"性别"<<abs->personArray[ret].m_Sex<<"\t";
cout<<"年龄"<<abs->personArray[ret].m_age<<"\t";
cout<<"电话"<<abs->personArray[ret].m_Phone<<"\t";
} else{
cout<<"查无此人"<<endl;
}
}
//修改联系人信息
void modifyPerson(Addressbooks *abs){
cout<<"请输入要修改的联系人"<<endl;
string name;
cin>>name;
int ret= isExist(abs,name);
if (ret !=-1){
//找到指定的联系人
// 姓名
string Personname;
cout<<"请输入姓名"<<endl;
cin>>Personname;
abs->personArray[ret].m_Name=Personname;
//性别
cout<<"请输入性别："<<endl;
cout<<"1----男"<<endl;
cout<<"2----女"<<endl;
int sex=0;
while (true){
cin>>sex;
if (sex==1||sex==2){
abs->personArray[ret].m_Sex=sex;
}
}
// 未找到
cout<<"输入有误"<<endl;
}
}
int main() {
// 创建通讯录的结构体变量
Addressbooks abs;
// 初始化通讯录中当前人员个数
abs.m_Size=0;
int select=0;//创建用户选择输入的变量
while (true){
showMenu();//菜单调用
cout<<"请选择功能："<<endl;
cin>>select;
switch (select) {
case 1: //1.添加联系人
addPerson(&abs);//利用地址传递可以修改参数
break;
case 2: //2.显示联系人
showPerson(&abs);
break;
case 3://3.删除联系人
//这里代码太多了 用代码块来封装就好
{
cout<<"请输入姓名"<<endl;
string name;
cin>>name;
if (isExist(&abs,name)) {
cout<<"没有这个人"<<endl;
} else{
cout<<"找到了"<<endl;
// 调用删除函数
deletePerson(&abs);
}
}
break;
case 4://4.查找联系人
FindPerson(&abs);
break;
case 5://5.修改联系人
break;
case 6://6.清空联系人
break;
case 0://0 退出通讯
cout<<"欢迎 下次使用"<<endl;
system("pause");
return 0;
break;
}
}
system("pause");
}
1.内存分区模型：
代码区：存放函数的二进制代码 由操作系统进行管理】
全局区：存放全局变量 静态变量 以及常量
栈区：有编译器自动分配释放 存放函数的参数值 局部变量等
堆区：由程序员分配和释放 程序结束的时候 不释放资源 由操作系统回收
不同的四区存放的数据 赋予不同的生命周期 给我们灵活编程
代码区：在程序编译后 生成了exe可执行程序 未执行该程序前分为两个区域
代码区：
存放cpu执行的机制指令
代码区是共享的 共享的目的是对于频繁被执行的程序 只需要在内存中有一份代码即可
代码区是只读的 使其只读的原因是防止程序意外地修改了它的指令
全局区：
全局变量和静态变量存放在此
全局区还包含了常量区 字符串常量和其他常量也存放在此
#include <iostream>
using namespace std;
//全局变量
int Max=100;
//全局常量
const int G=100;
int main() {
// 全局区
//全局变量 静态变量 常量
//创建局部变量
int a=10;
int b=100;
//打印变量地址
cout<<"变量a的地址为"<<&a<<endl;
cout<<"全局变量的地址为"<<&Max<<endl;
// 静态变量
static int p=900;//在普通变量的前面加上static修饰符 就是静态常量
cout<<"静态变量的地址是:"<<&p<<endl;
//常量：
//字符串常量
cout<< "字符串常量地址为" <<&"HelloWorld"<<endl;
// const修饰的变量 const修饰的全局变量 const修饰的局部变量
cout<<"全局常量地址"<<&G<<endl;
const int c=10;
cout<<"地址为："<<&c<<endl;
}
#include <iostream>
using namespace std;
//全局变量
int Max=100;
//全局常量
const int G=100;
//栈区数据注意事项：栈区的数据由编译器管理开辟和释放
//不要返回局部变量的地址
int *func(){
int a=100;
return &a;//局部变量存在栈区 栈区区的数据在函数执行完后自动释放
}
int main() {
//栈区：由编译器自动分配释放 存放函数的参数值
int * p=func();
cout<<*p<<endl;
}
#include <iostream>
using namespace std;
//堆区： 在c++中使用new关键字开辟数据
int *func(){
// 利用new关键字来开辟
//指针：本质也是全局变量 放在栈上 指针保存的数据是放在堆区
int *p= new int(10);
return p;
}
int main() {
int *p=func();
cout<<*p<<endl;
}
#include <iostream>
using namespace std;
/*
* 在c++利用new关键字在堆区开辟数据
* 堆区开辟的数据 由程序员开辟 手动释放 释放利用操作符 delete
* 语法：new 数据类型
*
* 利用new创建的数据 会返回该数据对应的类型指针
* */
int *func(){
// 在堆区创建整型数据
//new返回的是 该数据类型的指针
int *p= new int(10);
return p;
}
void test1(){
int *p=func();
cout<<*p<<endl;
// 如果想要释放堆区的数据 利用关键字delete
delete p;
}
//在堆区开辟一个数组
void test2(){
// 创建整型数组
int*arr= new int[10];//代表数组有10个元素
for (int i = 0; i < 10; ++i) {
arr[i]=i+100;
}
for (int i = 0; i < 10; ++i) {
cout<<arr[i]<<endl;
}
// 释放数组的时候要告诉编译器这个是数组
delete []arr;
}
int main() {
// 1.new的基本语法
// test1();
test2();
}
#include <iostream>
using namespace std;
int main() {
/*
* 引用的基本使用：
* 作用：给变量起别名
* 语法：数据类型 &别名=原名
*
* */
//引用的基本语法： 数据类型 &别名=原名
int a=10;
//创建引用：
int &b=a;
cout<<"a="<<a<<endl;
b=110;
cout<<"b="<<b<<endl;
//注意：引用必须初始化 引用在初始化后 不可以改变
int j=100;
int &o=j;//必须初始化 不然就报错
j=101;//赋值操作并不是改变引用
cout<<j<<endl;
}
#include <iostream>
using namespace std;
//交换函数
//1.值传递
void mySwap(int a,int b){
int temp=a;
a=b;
b=temp;
cout<<"a="<<a<<"b="<<b<<endl;
}
//2、地址传递
void swap(int *a,int *b){
int *temp=a;
a=b;
b=temp;
cout<<"a="<<a<<"b="<<b<<endl;
}
//引用传递：
void mySwapTest(int &a,int &b){
int temp=a;
a=b;
b=temp;
// return a,b;
}
int main() {
/*
* 引用作为参数：函数传递参数时 可以利用引用的技术让形参代替实参
*
*
* */
int a=10;
int b=20;
// mySwap(a,b);
/*swap(a,b);
cout<<"a="<<a<<endl;
swap(b,a);
cout<<"b="<<b<<endl;*/
// swap(&a,&b);//地址传递
mySwapTest(a,b);//引用传递 形参会修饰实参
cout<<"a="<<a<<"b="<<b<<endl;
}
#include <iostream>
using namespace std;
/* 引用作为函数的返回值：
* 1.不要返回局部变量的引用
* 2。函数调用可以作为左值
*
*
* */
int test0(){
int a=10;//这个存放在栈区
return a;
}
//2.左值
int& test1(){
static int a=10;//静态变量 存放在全局区 全局区上的数据在程序结束后就释放了
return a;
}
int main() {
int a= test0();
cout<<a<<endl;//第一次是正确的
cout<<a<<endl;//第二次就销毁了 因为是栈区的数据 无法一直保留
int &ref=test1();
test1()=1000;//如果函数的返回值是引用 这个函数调用可以作为左值
cout<<ref<<endl;
}
#include <iostream>
using namespace std;
int main() {
/*引用的本质：就是一个指针常量
*
*
*
* */
}
#include <iostream>
using namespace std;
//打印函数
void ShowValue(int &a){
cout<<a<<endl;
}
int main() {
/*
* 1.常量的引用：
* 常量引用主要是用来修饰形参 防止误操作
* 在函数参数列表中 可以加const修饰形参 防止参数改变实参
* */
// 用来修饰实参
int a=10;
const int &ref=10;//加上const后 编译器将代码修改了
ShowValue(a);
}
#include <iostream>
using namespace std;
//如果我们自己传入了数据 就使用传递进去的数据 如果没有传递数据 就使用 默认的即可
int func(int a,int b=290,int c=1000,int d=100,int e=10){
return a+b+c+d+c+d+e;
//语法：返回值类型 函数名 （形参=默认值）{}
//注意事项：如果某个位置已经有了默认参数 那么这个位置从左往右 都必须有默认值
}
int func1(int a=1,int b=100, int d=109){
return a+b+d;//形参列表的参数
// 如果函数的声明有了默认参数 函数实现就不能有默认参数
}
//函数声明
int fun(int a,int b);
//函数实现：
int fun(int a,int b){
return a+b;
}
int main() {
/*
* 在c++中 函数的形参列表中的形参是有默认值的
* 语法：返回值类型 函数名称(参数=默认值){}
* 声明和实现只能有一个有默认参数
* */
int c= func(12,21,12,12,21);
cout<<c<<endl;
cout<<fun(12,23)<<endl;
/*
*
*
*
* */
}
#include <iostream>
using namespace std;
//占位参数
void func(int a,int){
cout<<"hello func this who"<<endl;
}
int main() {
/*函数占位参数：c++的形参列表中可以由占位参数 用来做占位 调用函数时必须填补该位置
*
* 语法：返回值类型 函数名 (数据类型) {}
*
* 占位参数 还可以有默认参数
* 在现阶段 暂时不会使用
*
* */
func(12,3);
}
#include <iostream>
using namespace std;
/*
* 函数重载：函数名称可以相同 提高复用性
*
* 函数重载满足条件：
* 同一个作用域下
* 函数名相同
* 函数参数类型不同 或者参数个数不同 或者顺序不同
* 注意：函数的返回值不可以作为函数重载的条件
*
* 函数的返回值 不能作为函数重载的条件
*
* */
void func(){
cout<<"hello this function tack "<<endl;
}
//相同的就不可以共存
void func(int a){
cout<<"hello this function tack "<<endl;
}
void func(int a,int ){
cout<<"hello this function tack "<<endl;
}
void func(int a,int v,int k){
cout<<"yor are beauty！"<<endl;
}
int main() {
// 1.都在同一个作用域下 2.函数名称相同 3.函数参数或个数不同
// 调用函数
func();
func(1);
func(12,12);
func(11,23,34);
}
c++中面向对象三大特性：封装 继承 多态
#include <iostream>
using namespace std;
/*
* 面向对象：
*
*
* */
//设计一个圆类来求周长：
class Actor{
// class 类名{}
//访问权限
public:
// 属性：
double radius;
//行为：获取周长的函数
double showL(){
return 2*3.14*radius;
}
};
int main() {
// 通过圆类来创建具体的圆(对象)\
Actor c;
c.radius=10;
double L=c.showL();
cout<<"周长为："<<L<<endl;
}
#include <iostream>
using namespace std;
#include "string"
/*
* 设计一个学生类：
*
* */
class Student{
public://把权限打开
string StudentName;
int number;
string StudentId;
// 学生的行为
void showStudent(){
cout<<"姓名："<<StudentName<<"学生学号："<<StudentId<<"学生号码："<<number<<endl;
}
//给姓名赋值
void setName(string Sname){
StudentName=Sname;
}
//给学号赋值
void setId(int Id){
StudentId=Id;
}
};
int main() {
// 测试
Student s;
s.StudentName="吴邪";
s.number=1290211;
s.StudentId=001;
//调用类里面的方法
s.showStudent();
//调用set方法来修改
Student n;
n.setId(122);
n.setName("王胖子");
n.showStudent();
/*
* 类中的属性和行为 我们统称为 成员
* 属性 成员属性 成员变量
* 行为 成员函数 成员方法
* 属性
*
* */
}
#include <iostream>
using namespace std;
#include "string"
class Person{
// 公共权限
public: string name;//姓名
//保护权限
protected: string car;
// 私有权限：
private:int password;
public: void func(){
name="吴邪";
car="奔驰";
password=1231;
cout<<"姓名："<<name<<"汽车品牌："<<car<<"密码："<<password<<endl;
}
};
int main() {
/*
* 访问权限：
*
* 公共：public 成员在类内可以访问 类外也可以访问
* 私有： private 内可以访问 类外不可以访问
* 保护：protected 类内可以访问 类外不可以访问
* */
//实例化属性
Person p;
p.func();//类里面的方法 就可以调用
}
#include <iostream>
using namespace std;
#include "string"
/*
* 结构体和类的区别：就是默认的访问权限不同
* struct 默认权限为公共
* class默认访问权限为私有
*
*
* */
struct test1{
string name;//默认权限为公共
};
class test2{
string name;//默认为私有
};
int main() {
test1 t1;
t1.name;
test2 t2;
// t2.name;//这个就不可以被访问到
cout<<t1.name<<endl;
}
#include <iostream>
using namespace std;
#include "string"
/*
* 成员属性设置为私有：
* 1. 将所有成员属性设置为私有 可以自己控制读写权限
* 2.对写权限 我们可以检测数据的有效性
* */
class Person{
// 姓名
private:
string name;
private:
//年龄
string age;
private:
//工资
string saraly;
public:
void setName(string n){
name=n;
}
public:
void setAge(int Age){
age=Age;
}
public:
void setSalary(int S){
saraly=S;
}
//显示类里面成员的信息
public:
void showInformation(){
cout<<"姓名："<<name<<"年龄："<<age<<"工资："<<saraly<<endl;
}
};
int main() {
Person p;
p.setName("吴邪");
p.setAge(19);
p.setSalary(19000);
p.showInformation();
}
#include <iostream>
using namespace std;
#include "string"
class Cube{
public: double Long;//长
public: double width;//宽
public: double height;//高
//赋值函数
public:
void setLong(double L){
Long=L;
}
void setWidth(double W){
width=W;
}
void setHeight(double h){
height=h;
}
//计算面积的函数
public:
double area(){
return 2*(Long*width+width*height+Long*height);
}
//计算体积的函数
public:
double Volume(){
return Long*height*width;
}
};
int main() {
Cube c;
c.setHeight(12);
c.setLong(230);
c.setWidth(20);
double o=c.area();
double m=c.Volume();
cout<<"面积为："<<o<<endl;
cout<<"体积为："<<m<<endl;
}
扫一扫
2221
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
