c++入门基础（基础语法）
一个变量相当于输出一个点，一个循环相当于输出一条线，双重循环相当于输出一个平面，三重循环相当于输出一个立体图形。总结：与if语句比，对于多条件判断时，switch的结构清晰，执行效率高，缺点是switch不可以判断区间。表达式3){// 表达式2为真继续循环，否则结束循环。4 变量有特定的类型，类型决定了存储单元的大小和变量值的范围，运算符可应用于变量上。while( 循环条件 ){// 条件为真
·
目录
编写一个C++程序,总共包含4个步骤
- 创建项目
- 创建文件
- 编写代码
- 运行程序
1第一个程序
dev安装
1.1Hello world
#include<iostream> //头文件：输入输出
using namespace std; //使用标准命名空间
int main() { //主函数：程序入口
cout << "Hello world" << endl; //输出： Hello world
return 0; //程序出口
}
1.2运行结果
1.3注释
作用：在代码中加一些说明和解释，方便自己或其他程序员阅读代码
两种格式：
1、单行注释： / / 相关描述
通常放在某行代码的上方，或者某一条语句的末尾，对该行代码说明
2、多行注释： / * 相关描述 * /
通常放在一段代码的上方，对该段代码做整体说明
注：编译器在编译代码时，注释不会执行，会忽略注释的内容
2、数据类型
2.1数据类型
| 类型 | 关键字 | 样例 |
|---|---|---|
| 布尔型 | bool | true、false |
| 字符型 | char | 'a'、‘3’、‘%’ |
| 整型 | int | -5、0、1002 |
| 浮点型 | float | 12.345、3.141 |
| 双精度浮点型 | double | 12.345、3.141 |
| 无类型 | void | / |
| 宽字符型 | wchar_t |
| 类型 | 位（n个字节） | 范围 |
|---|---|---|
| char | 1 | -128 到 127 或者 0 到 255 |
| int | 4 | -21 4748 3648 到 21 4748 3647 |
| float | 4 | 7位有效数字 |
| double | 8 | 15～16位有效数字 |
| unsigned char | 1 | 0 到 255 |
| signed char | 1 | -128 到 127 |
| unsigned int | 4 | 0 到 42 9496 7295 |
| signed int | 4 | -21 4748 3648 到 21 4748 3647 |
| short int | 2 | -3 2768 到 3 2767 |
| unsigned short int | 2 | 0 到 6 5535 |
| signed short int | 2 | -3 2768 到 3 2767 |
| long long | 8 | -9,223,372,036,854,775,808 到 9,223,372,036,854,775,807 |
| signed long int | 8 | -9,223,372,036,854,775,808 到 9,223,372,036,854,775,807 |
| unsigned long int | 8 | 0 到 18,446,744,073,709,551,615 |
| long double | 16 | |
| wchar_t | 2或4 | 1个宽字符 |
一个字节 = 8bit = 8 个位
一些基本类型可以使用一个或多个类型修饰符进行修饰：
- signed 符号型
- unsigned 无符号型
- short 短型
- long 长型
字符型
作用：存单个字符
语法： char ch = '单个字符' ; 如： char ch = 'p' ;
注： 1、用单引号将字符括起来，不要用双引号
2、单引号内只能有一个字符，不可以是字符串
字符串型
作用：存多个字符组成的字符串
语法： string str = "字符串" 如： string str = "abc123";
布尔型（bool）
作用：布尔数据类型代表真或假的值
bool类型只有两个值：
- true -- 真（本质是1）
- false -- 假（本质是0）
2.3标识符命名规则
即变量、常量、函数的命名规则：
- 标识符只能由字母、数字、下划线组成
- 第一个字符必须为字母或下划线，不能是数字
- 标识符中字母区分大小写
- 标识符不能是关键字
正确命名：abc_、a1、c3、_t 、Char 、 int4 等
错误命名：int、4ab、long、"abc" 等
大写字母和小写字母是不同的，因为 C++ 是大小写敏感的。所以Char可以当作变量使用。
2.2变量
变量：
1 变量代表一个有名字的、具有特定属性的一个存储单元；
2 变量用来存放数据，也就是存放变量的值；
3 变量的值可以改变；
4 变量有特定的类型，类型决定了存储单元的大小和变量值的范围，运算符可应用于变量上
语法： 数据类型 变量命 = 初始值 ；
注：每个变量名都是唯一，不能重命名。
2.4常量
作用：用于记录程序中不可更改的数据
两种方式：
1、宏定义：# define 常量名 常量值
- 位于头文件后，主函数前。
2、const修饰的变量： const 数据类型 变量 = 常量值
- 修饰该变量为常量，不可修改。
2.5输入输出流
输出：cout
cout << 变量1;
cout << 变量 1 << 变量2 << 变量3;
cout << "字符串";输入：cin
cin >> 变量1;
cin >> 变量1 >> 变量2 >> 变量3;
2.6关键字
3、运算符
新手主要学习一下三种运算符：
- 算术运算符
- 关系运算符
- 逻辑运算符
- 位运算符（新手不学）
3.1算术运算符
| 符号 | 描述 | 示例（a = 5, b = 2） | 结果 |
|---|---|---|---|
| + | 把两个操作数相加 | a + b | 7 |
| - | 把两个操作数相减 | a - b | 3 |
| * | 把两个操作数相乘 | a * b | 10 |
| / | 把两个操作数相除，取整 | a / b | 2 |
| % | 把两个操作数相除，取余（取模） | a % b | 1 |
| ++ | 自增运算符，整数值增加 1 | a++ 、++a | 5、6 |
| -- | 自减运算符，整数值减少 1 | b--、 --b | 2、1 |
注：
- 只有整型变量可以进行取模运算
- 在除法运算中，除数不能为0
a++：先赋值，后自增
++a：先自增，后赋值
a--、--a 同理
3.2关系运算符
| 符号 | 描述 | 示例（a=5、b=2、c=2） | 结果 |
|---|---|---|---|
| == |
判断两个操作数的值是否相等，如果相等则条件为真。 |
a==b、b==c | 假、真 |
| != |
判断两个操作数的值是否不相等，如果不相等则条件为真。 |
a != b、b != c | 真、假 |
| > | 判断左操作数的值是否大于右操作数的值，如果是则条件为真。 | a>b、b>c | 真、假 |
| < | 判断左操作数的值是否小于右操作数的值，如果是则条件为真 | a<b、b<c | 假、假 |
| >= | 判断左操作数的值是否大于或等于右操作数的值，如果是则条件为真。 | a>=b、b>=c | 真、真 |
| <= | 判断右操作数的值是否大于或等于左操作数的值，如果是则条件为真。 | a<=b、a<=c | 假、假 |
#include<iostream>
using namespace std;
int main(){
int a = 5;
int b = 2;
int c = 2;
if(a==b){
cout<<"a等于b"<<endl;
}else{
cout<<"a不等于b"<<endl;
}
if(a!=b){
cout<<"a不等于b"<<endl;
}else{
cout<<"a等于b"<<endl;
}
if(a>=b){
cout<<"a大于或等于b"<<endl;
}else{
cout<<"a不大于或不等于b"<<endl;
}
return 0;
}
3.3逻辑运算符
| 符号 | 描述 | 示例 | 结果 |
|---|---|---|---|
| && | 与 | a && b | 如果a和b都为真，则结果为真，否则为假。 |
| || | 或 | a || b | 如果a和b有一个为真，则结果为真，二者都为假时，结果为假。 |
| ！ | 非 | !a | 如果a为假，则!a为真； 如果a为真，则!a为假。 |
3.4位运算符
当变量参与位运算时，它们会被转换为二进制形式进行处理，这是因为在计算机内部，所有的数据都是以二进制的形式存储和处理的。
& 按位与：两个相应二进制位都为1，该位结果为1，否则为0
| 按位或：两个相应二进制位中有一个为1，该位结果为1^ 按位异或：A参加运算的两个二进制位值相同则为0，否则为1
~ 取反N：对一个二进制数按位取反，即将0变1，将1变成0左移<<:左移 N 位，就是乘以 2 的 N 次方
右移>>:右移 N 位，就是除以 2 的 N 次方。
例：a=236 b=209
a&b=194 a|b=253 a^b=61 ~a=19
例：a=6 cout<<(a<<2); 等价于：6*2*2=24
例：a=24 cout<<(a>>2); 等价于：24÷2÷2=6
4、程序流程结构
三大基本结构：
- 顺序结构：程序按照顺序一次执行，不发生跳转
- 选择结构：判断条件是否满足，执行相应的程序
- 循环结构：判断条件是否满足，对某段程序重复执行
4.1顺序结构
如上图所示。
4.2选择结构（分支结构）
4.2.1if-else语句
语法1：
if( 条件 ){
执行语句1
}else{
执行语句2
}
语法2：
if( 条件1 ){
执行语句1
}else if( 条件2 ) {
执行语句2
}else{
执行语句n
}#include<iostream>
using namespace std;
int main() {
int a=93,b=45;//a:语文成绩 b:数学成绩
if(a>=60){
cout<<"语文成绩及格"<<endl;
}else{
cout<<"语文成绩不及格"<<endl;
}
if(a<60){
cout<<"语文成绩不及格"<<endl;
}else if(a>=60 && a<70){
cout<<"语文成绩及格"<<endl;
}else if(a>=70 && a<90){
cout<<"语文成绩良"<<endl;
}else{
cout<<"语文成绩优秀"<<endl;
}
return 0;
}
4.2.2switch语句
注意：
- switch语句中表达式数据类型只能是整型或者字符型
- case里如果没有break，那么程序会一直向下执行
总结：与if语句比，对于多条件判断时，switch的结构清晰，执行效率高，缺点是switch不可以判断区间
switch(变量)
{
case 条件1: //条件为：变量的值 整形：1、2、... 字符型：'a'、'f'、...
执行语句1;
break; //执行完这一种情况后不会再执行下面的语句，即跳出switch
case 条件2:
执行语句2;
break;
case 条件3:
执行语句3;
break;
default:执行语句4; //如果上面条件都不满足，就执行语句4
}
#include<iostream>
using namespace std;
int main() {
int a;
cin>>a;
switch(a){
case 1:
cout<<"一技能"<<endl;
break;
case 2:
cout<<"二技能"<<endl;
break;
case 3:
cout<<"三技能"<<endl;
break;
default:
cout<<"输入错误"<<endl;
}
return 0;
}
4.2.3多条件的if分支结构
4.3循环结构
c++中有三种循环，
for循环：一边用于已知循环次数
while循环：未知循环次数
do...while循环：第一次不用进行条件判断
4.3.1for循环
语法：
for(表达式1；表达式2；表达式3){ // 表达式2为真继续循环，否则结束循环
循环体语句；
}
其中：
表达式1：初始条件
表达式2：循环条件
表达式3：初始条件变化
#include<iostream>
using namespace std;
int main() {
int a;
cout<<"请输入：";
cin>>a;
for(int i=1; i<=a; i++){ // i从1开始，i每次循环自增1，当大于a时结束循环
cout<<"第"<<i<<"次"<<endl;
}
return 0;
}
4.3.2while循环
语法：
while( 循环条件 ){ // 条件为真继续循环，否则结束循环
循环体语句
}
#include<iostream>
using namespace std;
int main() {
int a;
cout<<"请输入：";
cin>>a;
while(a>=0){
cout<<"第"<<a<<"次"<<endl;
--a;
}
return 0;
}
3.3.3do...while循环
语法：
do{
循环体语句
}while( 循环条件)；
注：该循环与while循环有区别，这是先循环一次，再进行判断
#include<iostream>
using namespace std;
int main() {
int a;
cout<<"请输入：";
cin>>a;
do{
cout<<a<<endl;
--a;
}while(a>=0);
return 0;
}
3.3.4嵌套循环
在某循环体中再嵌套一层循环。
一个变量相当于输出一个点，一个循环相当于输出一条线，双重循环相当于输出一个平面，三重循环相当于输出一个立体图形
语法：由for、while、do...while循环，其中两个或以上的组合
#include<iostream>
using namespace std;
int main() {
for(int i=1; i<=6; i++){
for(int j=1; j<=6; j++){
cout<<"*"<<" ";
}
cout<<endl;
}
return 0;
}
4.4三目运算符
语法：表达式1 ? 表达式2 ：表达式3
解释：
- 当表达式1的值为真，执行表达式2，并返回表达式2的结果；
- 当表达式1的值为假，执行表达式3，并返回表达式3的结果。
#include<iostream>
using namespace std;
int main() {
int a=10,b=20,c;
c=a>b ? a:b; // a>b为假，所以c=b
cout<<a<<" "<<b<<" "<<c;
return 0;
}
4.5跳转语句
| 符号 | 描述 |
|---|---|
| break |
|
| continue | 不执行下面的语句，回到前面。在循环中时，跳过剩下的程序不再执行，重新开始下一轮循环。 |
| goto | 无条件跳到指定位置。 |
注意：continue并不会终止整个循环，而break会跳出循环
goto语句示例：
#include<iostream>
using namespace std;
int main() {
cout << "aaaaaa" << endl;
goto THIS;
cout << "bbbbbbb" << endl;
cout << "ccccccc" << endl;
THIS:
cout << "VVVVVVV" << endl;
return 0;
}
注意：不建议使用goto语句，容易造成程序流程混乱
5、数组
定义：是一个集合，存放相同数据类型的数据元素。
特点：数组中的每个元素都是相同的数据类型，内存是连续的。
5.1一维数组
语法： 数据类型 数组名称 [ 数组大小 ]
int a[5] = {1, 2, 3, 4,5 }; //全部初始化
int a[5] = { 0 }; // 用0初始化全部数据
int a[ ] = {1, 2, 9, 11 ,78 }; // 不指定数组长度
int a[5] = {12}; //第一个元素为12，其它为0
char ch[3] = {'c', 'e', '%'};注：数组中下标是从0开始索引
#include<iostream>
using namespace std;
int main() {
int a[10];
a[0] = 10;
a[1] = 9;
a[2] = 25;
//根据下标输出
cout << a[0] << endl;
cout << a[1] << endl;
cout << a[2] << endl;
int a2[10] = { 10, 9,8,7,6,5,4,3,2,1 };
//循环输出
for (int i = 0; i < 10; i++)
{
cout << a2[i] << endl;
}
return 0;
}获取数组大小及地址
&：取地址符号
#include<iostream>
using namespace std;
int main() {
int a[10] = { 1,2,3,4,5,6,7,8,9,10 };
cout << "整个数组所占内存空间为： " << sizeof(a) << endl;
cout << "每个元素所占内存空间为： " << sizeof(a[0]) << endl;
cout << "数组的元素个数为： " << sizeof(a) / sizeof(a[0]) << endl;
//以通过数组名获取到数组首地址
cout << "数组首地址为： " << (int *)a << endl;
cout << "数组中第一个元素地址为： " << (int *)&a[0] << endl;
cout << "数组中第二个元素地址为： " << (int *)&a[1] << endl;
return 0;
}
5.2二维数组
语法： 数据类型 数组名[ 行数 ] [ 列数 ]
int a[2][3];
int b[2][3] = { {1,2,3}, {4,5,6 } };
int c[ ][3] = {1,2,3}; //只写列上元素，行自动生成学生成绩 ：
| 姓名 | 语文 | 数学 | 英语 |
|---|---|---|---|
| 张三 | 89 | 95 | 98 |
| 李四 | 79 | 78 | 56 |
| 王五 | 90 | 99 | 93 |
#include<iostream>
using namespace std;
int main() {
int scores[3][3] ={
{89,95,98},
{79,78,56},
{90,99,93},
};
string names[3] = { "张三","李四","王五" };
for (int i=0; i<3;i++){
int sum=0;
for (int j=0; j<3; j++){
sum+=scores[i][j];
}
cout << names[i] << "总分为： " << sum << endl;
}
return 0;
}
初始化只有一列：
#include<iostream>
using namespace std;
int main() {
int arr[2][3] = { 1,2,3 };
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 3; j++) {
cout << arr[i][j] << " ";
}
cout << endl;
}
return 0;
}
// 这两种方法是一样的
char a[6] = {'h', 'e', 'l', 'l', 'O','\0'};
char b[] = "hello";5.3数组增删改查
求字符数组的长度： strlen( 数组名 )
- 按值删除
- 按下标删除
- 某元素，插入某个位置
- 修改某个位置的值
- 查找某个元素的位置
- 找某下标的值
#include<iostream>
#include<cstring>
using namespace std;
int main() {
char arr[10]={'0','d','2','p','t','z','+','7'};
cout<<"初始值（字符）："<<endl;
for(int i=0;i<strlen(arr);i++){
cout<<arr[i]<<" ";
}
cout<<endl<<endl;
//按值删除
char a;
cout<<"需要删除的值：";
cin>>a;
for(int i=0; i<strlen(arr); i++){
if( arr[i]==a){
for(int j=i;j<10-1;j++){
arr[j]=arr[j+1];
}
}
}
cout<<"按值删除后："<<endl;
for(int i=0;i<strlen(arr);i++){
cout<<arr[i]<<" ";
}
cout<<endl<<endl;
//按下标删除
int b;
cout<<"要删除元素的下标：";
cin>>b;
for(int i=b;i<strlen(arr);i++){
arr[i]=arr[i+1];
}
cout<<"按下标删除后："<<endl;
for(int i=0;i<strlen(arr);i++){
cout<<arr[i]<<" ";
}
cout<<endl<<endl;
//增：插入某个位置
int index;
char ch;
cout<<"要插入的位置、值（空格隔开）：";
cin>>index>>ch;
for(int i=strlen(arr);i>=index;i--){
arr[i+1]=arr[i];
}
arr[index]=ch;
for(int i=0;i<strlen(arr);i++){
cout<<arr[i]<<" ";
}
cout<<endl<<endl;
//改：修改某个位置的值
int index2;
char ch2;
cout<<"要改的位置、值（空格隔开）：";
cin>>index2>>ch2;
arr[index2]=ch2;
for(int i=0;i<strlen(arr);i++){
cout<<arr[i]<<" ";
}
cout<<endl<<endl;
//查：查找某个元素的位置
char ch3;
cout<<"要查找的元素：";
cin>>ch3;
for(int i=0;i<strlen(arr);i++){
if(arr[i]==ch3){
cout<<i<<" ";
}
}
cout<<endl<<endl;
//查：查找某下标的值
int index3;
cout<<"某下标的值:";
cin>>index3;
cout<<arr[index3];
cout<<endl<<endl;
return 0;
}
6排序
6.1桶排序
思想：在已知数据范围的情况下，分配相应范围大小的数组空间。遍历所有数据，遇到对应下标时，计数增一。
#include<iostream>
#define N 20 //宏定义，数组最大下标为N-1
using namespace std;
int main() {
int arr[N]={0};
int a,n;
printf("(数据范围0~%d) 数据个数n:",N);
cin>>n;
printf("输入n个数据(空格隔开):");
for(int i=0;i<n;i++){
cin>>a;
++arr[a];
}
int num;
for(int i=N-1;i>=0;i--){ //输出
num=arr[i];
for(int j=num;j>0;j--){ //对于的元素有几个
cout<<i<<" ";
}
}
}
6.2选择排序
思想：
- 在待排序的一组数据中，选出最小（最大）的一个数与第一个位置的数交换。
- 然后在剩下的数中，再找最小（最大）的数与第二个位置的数交换位置。
- 依次类推直到第 n-1 个元素与第 n 个元素交换位置，选择排序结束。
//从小到大排序
#include <iostream>
using namespace std;
int main(){
int arr[5]={7,2,8,3,1};
int min,index;
for(int i=0;i<5-1;i++){
min=arr[i]; //设当前值为最小值
index=i; //设当前下标为最小下标
for(int j=i+1;j<5;j++){ // 从i的下一个开始比较
if(min>arr[j]){
min=arr[j]; //更新最小值
index=j; //更新最新下标
}
}
if(index != i){ //下标不为i，即找到新的最小值
arr[index]=arr[i];
arr[i]=min;
}
}
for(int i=0;i<5;i++){ //输出
cout<<arr[i]<<" ";
}
return 0;
}
6.3冒泡排序
思想：
- 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
- 对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。这一趟比较完后，最后的元素会是最大的数。
- 针对所有的元素重复以上的步骤，除了最后一个。（排好序的数不再进行比较）
- 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
如：气泡在水中上浮时，气泡越来越大
基本解法：
//从小到大
#include <iostream>
using namespace std;
int main(){
int arr[200]={};
int a,n;
cout<<"输入n:";
cin>>n;
for(int i=1;i<=n;i++){ //逐个存入数组
cin>>a;
arr[i]=a;
}
int temp;
for(int i=1;i<=n-1;i++){
for(int j=1;j<=n-i;j++){
if(arr[j]>arr[j+1]){
temp=arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
}
for(int i=1;i<=n;i++){ //输出
cout<<arr[i]<<" ";
}
return 0;
}
优化程序：
//从小到大
#include <iostream>
using namespace std;
int main(){
int arr[200]={};
int a,n;
cout<<"输入n:";
cin>>n;
for(int i=1;i<=n;i++){ //逐个存入数组
cin>>a;
arr[i]=a;
}
int temp,flag;
for(int i=1;i<=n-1;i++){
flag=0; //0:未移动 1：移动
for(int j=0;j<=n-i;j++){
if(arr[j]>arr[j+1]){
flag=1;
temp=arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
if(!flag){ //每一趟没被移动，说明数列有序
break;
}
}
for(int i=1;i<=n;i++){ //输出
cout<<arr[i]<<" ";
}
return 0;
}
7、字符串
区分下列两种字符串存储格式，在处理的时候注意函数的使用。
char a[1000];
strlen(a);7.1c++字符串输入总结
直接输出string类型，须加<string>
分为：cin、getchar和scanf、cin.get()、gets、cin.getline()、getline
1、cin: 接收字符串时，遇“空格”、“TAB”、“回车”都结束
char a[20];
cin>>a;
cout<<a;
//遇到空格、回车键结束2、scanf: 接收字符串时，遇“空格”、“TAB”、“回车”都结束
getchar: 接收一个字符
char ch2[20]; // 字符数组
scanf("%s", ch2);
printf("%s\n", ch2);
getchar(); // 用完 scanf 后，清除缓冲区
/* 注：scanf读取字符时遇到空格和回车符时都会停止读取，
此时输入缓冲区还剩一个\n，如果不清除，会影响下一次的输入*/3、 cin.get(): 接收字符串时, 可以接收空格
#include<iostream>
using namespace std;
int main() {
char ch;
cin.get(ch); //获取一个字符
cout<<ch<<endl;
getchar(); //清除缓存区
char ch2[20];
cin.get(ch2,10); //获取字符串，存入ch2中，限制长度为10-1=9
cout<<ch2;
return 0;
}
4、gets(): 接收字符串时, 可以接收空格
char ch1 [20]; // 字符数组
gets(ch1); // 输入 不能写成ch1=gets();
puts(ch1); // 输出5、cin.getline()：接收字符串时，可以接收空格并输出
#include<iostream>
using namespace std;
int main(){
char m[20];
cin.getline(m,4); //存入m，限制长度为4个字符，第5个位置存\0
cout<<m<<endl;
return 0;
}#include<iostream>
using namespace std;
int main(){
char m2[20];
cin.getline(m2,5,'a'); //存入m，限制长度为4个字符，第5个位置存\0, 遇到字符a停止
cout<<m2<<endl; //当输入123abcde时，输入123
return 0;
}6、getline() : 接收字符串时，可以接收空格并输出
#include<iostream>
using namespace std;
int main(){
string str;
getline(cin, str);//用于string字符串类型，存入带空格的字符串
cout <<"str= "<< str << endl;
char a[10];
cin.getline(a, 6);//用于字符数组类型，存入带空格的字符串
cout <<"a= "<< a;
}7.2 字符串处理函数（char a[100]）
头文件：#iclude<cstring>
strcpy(s1,s2)、strcmp(s1,s2)、strlen(s1)、strcat(s1,s2)、strlwr(s1)、strupr(s1)、find(查找字符)只用于字符数组类型（char s[100]）。
1、strcpy(s1, s2)
说明：把字符串s2拷贝到s1，即s1的数据变成了s2的数据
注意：必须保证s1的内存空间大于或等于s2
#include<iostream>
#include<cstring>
using namespace std;
int main(){
char str1[] = "123";
char str2[] = "abc";
cout<<strcpy(str1,str2);
}
//输出结果：abc2、strcmp(s1, s2)
说明：按照ASCII码顺序，s1和s2中的每个字符进行比较，
注意：当遇到某个字符不等时结束判断
返回值：比较结果。
- 字符串1=字符串2，返回值=0；
- 字符串1>字符串2，返回值>0，即 1；
- 字符串1<字符串2，返回值<0，即 -1。
#include<iostream>
#include<cstring>
using namespace std;
int main(){
char str1[] = "123456";
char str2[] = "123456";
char str3[] = "a23456";
cout<<strcmp(str1,str2)<<" "<<strcmp(str1,str3);
}
//输出结果为： 0 -13、strlen(s1)
作用：求字符数组或字符串的长度
#include<iostream>
#include<cstring>
using namespace std;
int main(){
char str1[] = "123";
char str2[] = "abcabc";
cout<<strlen(str1)<<" "<<strlen(str2);
}
//输出结果：3 64、strcat（s1, s2)
作用：把s2拼接到s1后面
#include<iostream>
#include<cstring>
using namespace std;
int main(){
char s1[] = "123";
char s2[] = "abc";
cout<<strcat(s1,s2);
}
//输出结果：123abc5、strlwr(s1) 大写转小写、strupr(s1) 小写转大写
#include<iostream>
#include<cstring>
using namespace std;
int main(){
char a[100]="abcABC123";
cout<<strlwr(a)<<endl; //输出：abcabc123
cout<<strupr(a)<<endl; //输出：ABCABC123
}6、find() 字符查找
#include<iostream>
using namespace std;
int main(){
string a="abcabc123";
cout<<a.find("bc")<<endl; //输出：1 。因为“bc ”第一次出现在的下标为 1
cout<<a.find('c')<<endl; //输出：2 。因为‘c ’第一次出现在的下标为 2
}7.3 常见字符串处理 (string型)
用于字符串类型（string s1;）
(1)getline(cin,s)：读入一个字符串(直到换行)，可以含空格
(2)cin：读入一个字符串，不能含空格
(3)s.size()：返回字符串s的长度,
(4)s[下标x]：获取字符串的下标x对应的字符
(5)掌握string的+的用法，注意string使用下标常见的错误
(6)find(子串)：查找子字符串第一次出现的下标，没有返回string::npos(注意判断其为-1)
(7)find(子串，x)：在字符串的下标x之后，查找子串
(8)substr(开始位置1，子串长度len)：截取子字符串，当len>字符串长度的时候只取剩余的
(9)substr(开始位置1)：截取子字符串，从下标为1 开始截取到最后
(10)erase(开始下标1，删除长度len)： 删除字符串第1个下标开始的len个字符
(11)erase(开始下标1)：删除字符串第1个下标开始往后的所有字符;
(12)insert(插入下标，插入字符串s)：在字符串下标为1 的位置插入一个字符串 s;
(13)replace(i，len，子串r)：从下标为1开始，替换len个字符为子串r
(14)字符类型判断函数：
isalpha(c)：判既c是否为字母
islower(c)：判断是否为小写isupper(c):判队是否为大写
isdigit(c)：判断是否为数字说明:返回非0表示真，返回0表示假;
(15)字符串和数字转化：
字符串string转数字：stoi(字符串)
数字转字符串string：to_string(数字)
(16)字符类型转化（说明:返回int）：
tolower(c):字符转小写
toupper(c):字符转大写
(17)字符串翻转：reverse(s.begin(),s.end());cout<<s; 该函数返回值类型是void(无返回值)，是直接修改字符串s，所以不能写成cout<<reverse(s.begin(),s.end()); 也不能写成s2=reverse(s.begin(),s.end());
注：第6-13书写格式是：字符串名.函数名 （如：s.erase()） 第14-17书写格式直接写函数名
#include<bits/stdc++.h> //万能头文件
using namespace std;
int main(){
string s1="123",s2="abc";
cout<<"拼接："<<s1+s2<<endl;
s1="abcabcabc",s2="cab";
cout<<"查找字串位置："<<s1.find(s2)<<endl;
s1="abcabcabc",s2="cab";
cout<<"下标3后查找字串位置："<<s1.find(s2,3)<<endl;
s1="abcabcabc";
cout<<"截取从下标2到最后："<<s1.substr(2)<<endl;
s1="abcabcabc";
cout<<"截取从下标2开始，连续3个字符："<<s1.substr(2,3)<<endl;
s1="abcabcabc";
cout<<"删除从下标3到最后："<<s1.erase(3)<<endl;
s1="abcabcabc";
cout<<"删除从下标3开始，连续3个字符："<<s1.erase(3,3)<<endl;
s1="abc";
cout<<"插入："<<s1.insert(3,"efg")<<endl;
s1="abcabcabc";
cout<<"子串替换："<<s1.replace(1,3,"kkkk")<<endl;
//字符类型判断函数
char r='5';
if(isalpha(r)){//是否是字母
}
if(islower(r)){//是否是小写字母
}
if(isupper(r)){//是否是大写字母
}
if(isdigit(r)){//是否是数字
}
s1="123";
int p=1234;
cout<<"string变成数字"<<stoi(s1)<<endl;
cout<<"数字变成string"<<to_string(p)<<endl;
s1="abc123";
reverse(s1.begin(),s1.end());
cout<<"字符串翻转："<<s1<<endl;
}
8、函数
8.1传参
作用： 将一段经常使用的代码封装起来，减少重复代码
返回值类型 函数名 (数据类型 变量1， 数据类型 变量2){
函数体语句;
return 表达式;
}
#include<iostream>
using namespace std;
//1、 无参无返
void test1(){
cout<<"无参无返"<<endl;
}
//2、 有参无返
void test2(int a){
cout<<"有参无返"<<endl;
cout<<"a="<<a<< endl;
}
//3、无参有返
int test3(){
cout<<"无参有返"<<endl;
return 10;
}
//4、有参有返
int test4(int num1, int num2){ //此处num1、num2为形式参数，即形参
cout<<"有参有返 "<<endl;
int sum=num1+num2;
return sum;
}
int main(){
int a=10,b=20;
test1();
test2(a);
cout<<test3()<<endl;
int sum;
sum=test4(a,b); //此处a、b为实际参数，即实参
cout<<sum<<endl;
return 0;
}
- 形参数据改变时，实参不会改变。
- 形参和实参可以同名，也可以不同名
8.2传地址，引用
1、传值
#include<iostream>
using namespace std;
void f(int a){
a=a*2;
}
int main(){
int a=1;
f(a);
f(a);
f(a);
cout<<a<< endl; //输出：1
return 0;
}2、传地址
#include<iostream>
using namespace std;
void f(int &a){
a=a*2;
}
int main(){
int a=1;
f(a);
f(a);
f(a);
cout<<a<< endl; //输出：8
return 0;
}3、引用
#include<iostream>
using namespace std;
void f(int *a){
*a=*a*2;
}
int main(){
int a=1;
f(&a);
f(&a);
f(&a);
cout<<a<< endl; //输出：8
return 0;
}9、指针
语法： 数据类型 * 指针变量
指针所占内存：32位电脑占4字节，64位电脑占8字节。所有数据量类型都一样。
9.1一维指针
示例：
#include<iostream>
using namespace std;
int main() {
int a = 10;
int *p;
p=&a; //a的地址
int *q=&a; //a的值 *q可以改变对应变量的值
cout<<"(地址)a："<<&a<<endl;
cout<<"(地址)p: "<<p<<endl;
cout<<"(值)*p："<<*p<<endl;
cout<<"(值)*q："<<*q<<endl;
//以下是错误案例
int *t;
*t=a;
cout<<"*t"<<*t<<endl;
cout<<"t"<<t<<endl;
return 0;
}
输出时可以简单的理解成：* 号取值，& 号取地址
9.2const修饰
#include<iostream>
using namespace std;
int main() {
int a = 10;
int b = 10;
//const修饰的是指针，指针指向可以改，值不可以更改
const int * p1 = &a;
p1 = &b; //正确
//*p1 = 100; 报错
//const修饰的是常量，指针指向不可以改，值可以更改
int * const p2 = &a;
//p2 = &b; //错误
*p2 = 100; //正确
//const既修饰指针又修饰常量
const int * const p3 = &a;
//p3 = &b; //错误
//*p3 = 100; //错误
return 0;
}
9.3二维数组
9.4指针与数组、函数
指针与数组：
#include<iostream>
using namespace std;
int main()
{
int arr[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
int *p = arr;//指向首元素
for (int i = 0; i < 10; i++)
{
cout << *p<< endl;
p++;
}
return 0;
}指针与函数：
传地址会改变实参的值，穿值不改变
#include<iostream>
using namespace std;
void s1(int a, int b){
int temp=0;
temp = a;
a = b;
b = temp;
}
void s2(int *a, int *b){
int temp = *a;
*a = *b;
*b = temp;
}
int main(){
int a = 10;
int b = 20;
//值传递
s1(a, b);
cout<<"传值后："<<a <<" "<<b<<endl;
//地址传递
s2(&a, &b);
cout<<"传地址后："<<a<<" "<<b<<endl;
return 0;
}
10、结构体
10.1结构体概念与定义
结构体就像excel表格一样，可以存不同类型的元素。数组只能存一种类型的元素。
语法：
struct 结构体名{
结构体成员列表
};
struct是关键字不能省略。
结构体的使用有三种方式：
#include<iostream>
using namespace std;
struct student{
//成员列表
string name; //姓名
int age; //年龄
int math; //数学
int chinese; //语文
}stu3; // stu3是单独定义的一个对象
int main() {
//方法一
struct student stu1; //struct 关键字可以省略
stu1.name = "小码";
stu1.age = 18;
stu1.math = 120;
stu1.chinese=135;
cout<<"姓名："<<stu1.name<<" 年龄："<< stu1.age <<" 数学："<<stu1.math<<" 语文："<<stu1.chinese<<endl;
//方法二
struct student stu2 = { "小明",19,116,129 };
cout<<"姓名："<<stu2.name<<" 年龄："<< stu2.age <<" 数学："<<stu2.math<<" 语文："<<stu2.chinese<<endl;
//方法三
stu3.name = "小花";
stu3.age = 18;
stu3.math = 130;
stu3.chinese=140;
cout<<"姓名："<<stu3.name<<" 年龄："<< stu3.age <<" 数学："<<stu3.math<<" 语文："<<stu3.chinese<<endl;
return 0;
}
10.2结构体数组
#include<iostream>
using namespace std;
struct student{
//成员列表
string name; //姓名
int math; //数学
int chinese; //语文
};
int main() {
struct student arr[3]={
{"张三",146,80},
{"李四",119,90},
{"王五",120,53}
};
for (int i=0;i<3;i++){
cout<<"姓名:"<<arr[i].name
<<" 数学:"<<arr[i].math
<<" 语文:"<<arr[i].chinese
<<endl;
}
return 0;
}
10.3结构体指针
#include<iostream>
using namespace std;
struct student{
string name; //姓名
int math; //数学
int chinese; //语文
};
int main(){
student stu1 = {"周杰伦",132,149}; //一个对象
struct student *p = &stu1;
p->chinese = 80;
cout<<"姓名:"<<p->name
<<" 数学:"<<p->math
<<" 语文:"<<p->chinese
<<endl<<endl;;
student stu2[2] = { //对象数组
{"小明",112,150},
{"小美",123,97,}
};
student (*q)[2]; //结构体数组指针
q=&stu2;
q[1]->math=150;
for (int i=0;i<2;i++){
cout<<"姓名:"<<q[i]->name
<<" 数学:"<<q[i]->math
<<" 语文:"<<q[i]->chinese
<<endl;
}
return 0;
}
10.4结构体嵌套（含数组）
嵌套时也可以使用数组。
#include<iostream>
#define N 40
using namespace std;
struct student{ //学生
string name; //姓名
int math; //数学
int chinese; //语文
};
struct school{ //班
string teacher; //班主任
string grade; //年级
student students[N]; //一个班N个人
};
int main(){
school class1;
class1.grade="二年级三班";
class1.teacher="马冬梅";
class1.students[0].name="小明";
class1.students[0].chinese=98;
class1.students[0].math=130;
class1.students[1].name="小红";
class1.students[1].chinese=118;
class1.students[1].math=123;
for (int i=0;i<2;i++){
cout<<"年级:"<<class1.grade
<<" 班主任:"<<class1.teacher
<<" 姓名:"<<class1.students[i].name
<<" 语文:"<<class1.students[i].chinese
<<" 数学:"<<class1.students[i].math
<<endl;
}
return 0;
}
10.5结构体作函数参数
传值的时候不改变实参的值，穿地址会修改实参的值。
#include<iostream>
using namespace std;
struct student{ //学生
string name; //姓名
int math; //数学
int chinese; //语文
};
//传值 不可修改数据
void s1(student stu){
stu.name="小伦";
cout<<"第一次：";
cout<<"姓名:"<<stu.name
<<" 数学:"<<stu.math
<<" 语文:"<<stu.chinese
<<endl;
}
//传地址 可修改数据
void s2(student *stu){
stu->name="小伦";
}
int main(){
student stu={"小明",98,77};
//传值
s1(stu);
cout<<"第二次：";
cout<<"姓名:"<<stu.name
<<" 数学:"<<stu.math
<<" 语文:"<<stu.chinese
<<endl;
s2(&stu);
cout<<"第三次：";
cout<<"姓名:"<<stu.name
<<" 数学:"<<stu.math
<<" 语文:"<<stu.chinese
<<endl;
return 0;
}
11、查找
1、二分查找
#include<iostream>
using namespace std;
int main(){
int arr[]={1,2,4,6,8,9,13,15};
int left=0;
int right=7;
int mid,flag=0,a;
cout<<"输入需要查找的值:";
cin>>a;
while (left<=right){
mid=(left+right)/2;
if (arr[mid]>a){
right=mid-1;
}else if(arr[mid]<a){
left=mid+1;
}else{
cout<<"索引:"<< mid<<endl;
flag=1;
break;
}
}
if(flag==0){
cout<<"查无此数！"<<endl;
}
return 0;
}12、进制转化
12.1 十进制转换成二进制、八进制、十六进制
1、十进制转换成二进制
除以2，直到商为0终止，反向取余数。
例：十进制数：39 ---> 二进制数：100111
2、十进制转换成八进制
除以8，直到商为0终止，反向取余数。
例：十进制数：147 ---> 八进制数：223
3、十进制转换成十六进制
除以16，直到商为0终止，反向取余数。
例：十进制数：5247 ---> 十六进制数：147F
12.2 二进制、八进制、十六进制转换成十进制转换
十进制-->十进制
二进制-->十进制
八进制-->十进制
十六进制-->十进制
12.3 二进制转换成八进制、十六进制
二进制转八进制，每3位二进制为一组，最高位不够就补0
二进制转十六进制，每4位二进制为一组，最高位不够就补0
12.4 八进制、十六进制转换成二进制
八进制转二进制
例：八进制：265 --> 二进制：10110101
十六进制转二进制
例：十六进制：2C9 --> 二进制：1011001001
12.5 小数部分转换
12.6八进制转换成十六进制
不能直接转，先变成十进制再变成十六进制，或者先变成二进制在变成十六进制
12.7代码实操
12.7.1十进制转换成二进制（八进制）
十进制转换成二进制和八进制是一样的
#include<bits/stdc++.h>
using namespace std;
int main(){
int n,a[100],num=0;
cin>>n; //输入十进制整数
while(n>0){
num++;
a[num]=n%2;
n=n%2;
}
for(int i=num;i>=1;i--){
cout<<a[i]<<" "; //反向输出
}
}
12.7.2 二进制（八进制）转换成十进制
二进制和八进制转换成十进制是一样的
#include<bits/stdc++.h>
using namespace std;
int main(){
string s;
cin>>s;
int t=0,k=1; //t:累加每一项 k:每位的权值
for(int i=s.size()-1;i>=0;i--){
t=t+(s[i]-'0')*k;
k=k*2; //下一位的权值
}
cout<<t;
}
12.7.3十进制转十六进制
十六进制比较特殊，有数字又有字母，所以在取余数后要判断处理。
#include<bits/stdc++.h>
using namespace std;
int main(){
int n;
cin>>n;
string s;
while(n>0){
int k=n%16;
if(k>=0 && k<=9){ //余数是小于10
s=s+char(k+'0'); //在s后面拼接
}else{//余数大于等于10 要转换成大写字母
s=s+char(k-10+'A');
}
n=n/16;
}
reverse(s.begin(),s.end()); //字符串翻转
cout<<s;
}
12.7.4 十六进制转十进制
判断当前位是数字还是字母，再累加计算。
#include<bits/stdc++.h> //万能头文件
using namespace std;
int main(){
string s;
cin>>s;
reverse(s.begin(),s.end()); //翻转字符串，让最右边的数排在下标0位置
long long sum=0; //累加
int len=s.length(); //求长度
for(int i=0;i<len;i++){
if(s[i]>='0' && s[i]<='9'){ //如果是数字
sum+=(s[i]-'0')*pow(16,i);
}else{ //如果是字母
sum=sum+(s[i]-'A'+10)*pow(16,i);
}
}
cout<<sum;
}
12.7.5二进制转八进制
#include<bits/stdc++.h> //万能头文件
using namespace std;
int main(){
string str,endstr;
cin>>str;
int u=3-str.length()%3; //没三位构成一组，求最后一组差几位
if(u<3){
for(int i=1;i<=u;i++)
str='0'+str; //在前面补0
}
reverse(str.begin(),str.end());//翻转字符串 ，让最低位换到最前面
for(int i=0;i<str.length();i=i+3){ //每3个字符一组，所以i=i+3
char a=(str[i]-'0')+(str[i+1]-'0')*2+(str[i+2]-'0')*4+'0'; //计算出来后加‘0’，变回数字字符
endstr=a+endstr; //拼接在最前面
}
cout<<endstr; //输出新字符串
}
12.7.6八进制转二进制
#include<bits/stdc++.h> //万能头文件
using namespace std;
//因为八进制转二进制有八种可能，都把他们列出来
//因为最高位转换后不能0开头，所以给最高位单独编辑一份
string a[8]={"000","001","010","011","100","101","110","111"};
string b[8]={"0","1","10","11","100","101","110","111"};
int main(){
string str;
cin>>str;
cout<<b[str[0]-'0'];//先处理最高位
for(int i=1;i<str.length();i++){ //处理剩下值
cout<<a[str[i]-'0'];
}
}
12.7.7 二进制转十六进制
#include<bits/stdc++.h> //万能头文件
using namespace std;
int main(){
string str,endstr;
cin>>str;
int u=4-str.length()%4; //每四位构成一组，求最后一组差几位
if(u<4){
for(int i=1;i<=u;i++)str='0'+str;//在前面补0
}
reverse(str.begin(),str.end()); //翻转字符串 ，让最低位换到最前面
for(int i=0;i<str.length();i=i+4){ //每四个字符一组，所以i=i+4
//计算出十进制大小 ，从低位到高位，二进制权值是1，2，4，8
int a=(str[i]-'0')*1+(str[i+1]-'0')*2+(str[i+2]-'0')*4+(str[i+3]-'0')*8;
if(a>=10)endstr=char(a-10+'A')+endstr; //超过10 用字母表示，拼接在新字符串最前面
else endstr=char(a+'0')+endstr; //小于10，用数字字符表示
}
cout<<endstr; //输出新字符串
}
12.7.8十六进制转二进制
和八进制转二进制类似
#include<bits/stdc++.h> //万能头文件
using namespace std;
//因为十六进制转二进制有十六种可能，都把他们列出来
//因为最高位转换后不能0开头，所以给最高位单独编辑一份
string a[16]={"0000","0001","0010","0011","0100","0101","0110","0111","1000","1001","1010","1011","1100","1101","1110","1111"};
string b[16]={"0","1","10","11","100","101","110","111","1000","1001","1010","1011","1100","1101","1110","1111"};
int main(){
string str;
cin>>str;
//先处理最高位
if(str[0]>='A' && str[0]<='F') cout<<b[str[0]-'A'+10]; // 字母的情况
else cout<<b[str[0]-'0']; // 数字字符的情况
for(int i=1;i<str.length();i++){ //处理剩下值
if(str[i]>='A' && str[i]<='F') cout<<a[str[i]-'A'+10]; // 字母的情况
else cout<<a[str[i]-'0']; // 数字字符的情况
}
}
12.7.9八进制转十六进制 （考查比较少）
不能直接转，先变成十进制再变成十六进制，或者先变成二进制在变成十六进制
例：八进制-->二进制-->十六进制
#include<bits/stdc++.h> //万能头文件
using namespace std;
//因为八进制转二进制有八种可能，都把他们列出来
//因为最高位转换后不能0开头，所以给最高位单独编辑一份
string a[8]={"000","001","010","011","100","101","110","111"};
string b[8]={"0","1","10","11","100","101","110","111"};
int main(){
string str;
cin>>str;
//八进制转二进制
string s2;
s2=b[str[0]-'0'];//先处理最高位
for(int i=1;i<str.length();i++){ //处理剩下值
s2=s2+a[str[i]-'0'];
}
//二进制转十六进制
string endstr;
int u=4-s2.length()%4; //每四位构成一组，求最后一组差几位
if(u<4){
for(int i=1;i<=u;i++)s2='0'+s2;//在前面补0
}
reverse(s2.begin(),s2.end()); //翻转字符串 ，让最低位换到最前面
for(int i=0;i<s2.length();i=i+4){ //每四个字符一组，所以i=i+4
//计算出十进制大小 ，从低位到高位，二进制权值是1，2，4，8
int a=(s2[i]-'0')*1+(s2[i+1]-'0')*2+(s2[i+2]-'0')*4+(s2[i+3]-'0')*8;
if(a>=10)endstr=char(a-10+'A')+endstr; //超过10 用字母表示，拼接在新字符串最前面
else endstr=char(a+'0')+endstr; //小于10，用数字字符表示
}
cout<<endstr; //输出新字符串
}
欢迎加入西安开发者社区！我们致力于为西安地区的开发者提供学习、合作和成长的机会。参与我们的活动，与专家分享最新技术趋势，解决挑战，探索创新。加入我们，共同打造技术社区！
更多推荐
225
0- 0
已为社区贡献1条内容
所有评论(0)