C语言详解(三) - 数组

已于 2022-05-03 09:55:58 修改
阅读量1.5k 收藏 14
点赞数 1
分类专栏： C语言学习之路 文章标签： c语言
于 2022-05-02 17:29:19 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_64904163/article/details/124543478
版权

数组

1. 一维数组

1.1 一维数组的创建(定义)

格式： 数据类型 数组名[元素个数];
元素个数一般表示是一个常量表达式，不能是任何变量及表达式。
但c99标准支持了变长数组创建，数组创建中元素个数可以是变量，但变长数组一旦创建数组长度(元素个数)便是确定的。变长数组不能在创建时初始化。
例如：

//含有10个字符元素的数组
char arr1[10];
//含有10个整型元素的数组
int arr2[10];
//含有20个浮点型元素的数组
double arr3[20];

1.2 一维数组的初始化

与创建变量时相同，不对数组中的元素进行初始化，数组中元素均是随机值(垃圾值)，所以要为数组元素赋上一些合理的初始值。

  • 在创建时初始化。
  • 先创建再初始化。

在创建时初始化。

完全初始化：数组中的元素均被初始化。

int arr1[5] = {1,2,3,4,5};

初始化时可以不指定数组的元素个数，那么数组的元素个数是初始化时元素的个数。

int arr2[] = {1,2,3};

sizeof计算数组的长度，字节为单位。
image.png

不完全初始化：只对数组中部分元素进行初始化，其余未初始化的元素自动被初始化为0。

int arr3[5] = {1,0,3};
int arr4[5] = {0};

实际运行：
image.png

  • 先创建再初始化。
//先创建再初始化。
int arr[5];
arr[0] = 1;
arr[1] = 2;
arr[2] = 3;
arr[3] = 4;
arr[4] = 5;

有些特殊的字符数组和字符串：

  • 字符数组：不以\0结尾。
  • 字符串：用双引号括起来的所有字符，以\0结尾。
char arr1[] = {'a', 'b', 'c', 'd'};
char arr2[4] = {'a', 'b', 'c', 'd'};
char arr3[] = "abcd";
char arr4[5] = {'a', 'b', 'c'，'d', '\0'};

printf("arr1[ ]	%d\n", sizeof(arr1));
printf("arr2[4] %d\n", sizeof(arr2));
printf("arr3[ ] %d\n", sizeof(arr3));
printf("arr4[5] %d\n", sizeof(arr4));

表面上看由相同的字符组成的字符数组和字符串，实际上有着不同：

  • 字符数组由于不以\0结尾，所以字符数组的元素个数比字符串少1，故字符数组的长度比字符串少1个字节。
  • 可能带来的影响是，使用%s格式打印时，字符串能正确打印，在'\0'处停止打印。但字符数组则不一定能正确打印，原因在于%s打印需要在'\0'处停止，但字符数组不含'\0'，所以字符数组自身的内容打印完之后会继续打印字符数组之后的内容，直到遇到'\0'时才停止打印。

例如一个运行实例：
image.png

1.3 一维数组的使用

数组通过下标引用操作符[]实现对数组元素的单独使用。操作符[]内是数组的下标。
n个数组元素，第一个元素的下标是0，最后一个元素的下标是n-1。

int main() {
    //数组初始化
    int arr[10] = { 0 };
    int i = 0;
    //循环输出每个元素的值
    for (i = 0; i < 10; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");

    //循环输入每个整型数组元素的值
    for (i = 0; i < 10; i++) {
        scanf("%d", &arr[i]);
    }
    //循环输出每个元素的值
    for (i = 0; i < 10; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");

    return 0;
}

运行结果：
image.png

计算一个一维数组的大小：

#include <stdio.h>

int main() {
    int arr[] = { 1,2,3,4,5,6,7,8,9,0 };
    int a = sizeof(arr);
    int b = sizeof(arr[0]);
    int c = sizeof(arr) / sizeof(arr[0]);
    printf("sizeof(arr) = %d\n", a);
    printf("sizeof(arr[0]) = %d\n", b);
    printf("sizeof(arr) / sizeof(arr[0]) = %d\n", c);

    return 0;
}

运行结果：
image.png

1.4 一维数组在内存中的储存

一维数组中的元素在内存中是连续存放的，具体表现为相邻元素的地址均相差一个类型所占的字节。

int arr[10] = {1,2,3,4,5,6,7,8,9,0};
一维数组在内存中的存储.png

#include <stdio.h>

int main(){
    int arr[10] = {0};
    int i = 0;
    for(i = 0; i < 10; i++){
        //%p表示将打印的是变量的地址
        printf("&arr[%d] = %p\n", i, &arr[i]);
    }
    
    return 0;
}

运行结果：不看每个元素具体的地址，因为每次运行时同一元素的地址也可能不相同，只看相邻元素地址的差值。
image.png

2. 二维数组

二维数组：数组元素是一维数组的一维数组。

2.1 二维数组的创建(定义)

格式：数据类型 数组名[row][column];

row是二维数组的行数，column是二维数组的列数。
先定义二维数组中元素的数据类型。数组名与变量名的定义相同。

//创建3行4列的字符数组，含有12个字符
char arr1[3][4];
//创建3行4列的整型数组，含有12个整数
int arr2[3][4];
//创建5行5列的浮点型数组，含有25个浮点数
double arr3[5][5]；

三维数组创建：

int a[3][4][5];

2.2 二维数组的初始化

  • 先定义在初始化
  • 在定义时初始化

先定义再初始化

int arr[3][4];
int i = 0;
for (i = 0; i < 3; i++) {
        int j = 0;
        for (j = 0; j < 4; j++) {
            scanf("%d", &arr[i][j]);
        } 
    }
for (i = 0; i < 3; i++) {
    int j = 0;
    for (j = 0; j < 4; j++) {
        printf("%d ", arr[i][j]);
    }
    printf("\n");
}

image.png

定义时初始化

int arr1[3][4] = {1,2,3,4,5,6,7,8,9,10,11,12};
int arr2[3][4] = {{1,2,3},{5,6,7,8},{9,10}};
int arr3[3][4] = {1,2,3,4};

二维数组初始化时可以省略行，但不能省略列，省略的行可以通过计算得到。

int arr4[][4] = {1,2,3,4，5,6,7,8,9,10,11,12};

image.png

2.3 二维数组的使用

二维数组也通过下标[]使用二维数组的元素。
分为行下标和列下标。
行下标范围为0~row-1，列下标范围为0~column-1。

#include <stdio.h>

int main(){
    //二维数组元素初始化为0
    int arr[3][4] = {0};
    int i = 0;
    int j = 0;
    //双重循环输入数组的各个元素
    for(i = 0; i < 3; i++){
        for(j = 0; j < 4; j++){
            scanf("%d", &arr[i][j]);
        }
    }
    //双重循环输出数组的各个元素
    for(i = 0; i < 3; i++){
        for(j = 0; j < 4; j++){
            printf("%d ", arr[i][j]);
        }
    }
    return 0;
}

运行结果：
image.png

2.4 二维数组在内存中的储存

二维数组理解上是多行多列的，但实际在内存中储存时是以一维数组的形式依次存放的。
也就是说，二维数组是元素为一维数组的一维数组。
一个简图：

int arr[3][4] = {1,2,3,4,5,6,7,8,9,10,11,12};

二维数组在内存中的存储.png

#include <stdio.h>

int main() {
    int arr[3][4] = { 0 };
    int i = 0;
    int j = 0;
    for (i = 0; i < 3; i++) {
        for (j = 0; j < 4; j++) {
            printf("&a[%d][%d] = %p\n", i, j a[i][j]);
        }
    }
    return 0;
}

image.png

3. 数组越界

对数组的粗心使用可能会导致数组越界的情况。

  • 数组创建之后便有了确定的元素个数，使用下标对数组元素进行使用时需要知道数组使用时下标的有效范围。
  • 例如，对于具有十个元素的一维数组int arr[10];下标的有效范围为09。对于具有n个元素的一维数组，下标的有效范围是0n-1。
  • C语言本身不对数组越界进行检查，数组越界时编译器也不一定会报错，所以一旦越界可能会导致严重的错误。所以需要我们在写代码时自己有意识的去检查。
  • 二维数组的行和列用下标使用时也有有效范围，例如二维数组int arr[3][4];行下标有效范围是02，列下标有效范围是03。
  • 三维数组的下标也有着相似的下标有效范围。

4. 数组作为函数参数

数组时常作为函数的参数。

4.1 数组名是什么

int arr[10] = { 0 };
例如数组名arr
一般情况下数组名是数组首元素的地址。
特殊情况：

  1. 数组名单独作为sizeof的操作数，数组名代表的是整个数组，sizeof求的是所占内存的大小，所以sizeof(数组名)的结果是整个数组的大小，而不是数组首个元素(arr[0])的大小。
#include <stdio.h>

int main(){
    int arr[10] = { 0 };
    printf("sizeof(arr) = %d\n", sizeof(arr));
    printf("sizeof(arr[0])%d\n", sizeof(arr[0]));
    
    return 0;
}

image.png

  1. 取地址操作符&的操作数为数组名，即&数组名时，数组名代表的是整个数组，所以取出的也是整个数组的地址，而不是数组首元素的地址。也就是说整个数组的地址与数组首元素的地址只在数值上相同，但二者有着本质上的不同。

数组名的特例之&.png

#include <stdio.h>

int main(){
    int arr[10] = {1,2,3,4,5,6,7,8,9,0};
    
    printf("&arr = %p", &arr);
    printf("&arr+1 = %p", &arr + 1);
    printf("&arr[0] = %p", &arr[0]);
    printf("&arr[0]+1 = %p", &arr[0] + 1);
    
    return 0;
}

运行结果：
image.png

可以看到整个数组的地址&arr与数组首元素的地址&arr[0]数值上相同，但整个数组的地址+1&arr+1后跳过了整个数组的大小，数组首元素+1&arr[0]+1跳过了一个数组元素的大小。

4.2 数组名作为函数参数

一维数组作为函数参数

  • 一维数组传递给函数的是数组名，也就是数组首元素的地址，对应函数参数为一维数组，本质为一级指针，故一维数组作为函数参数时[]内写不写数组的元素个数效果都一样，一般都写上，有助于理解。
  • 所以在函数内sizeof(数组名)不能求整个数组的长度，求的是一个指针的大小，也就是一个地址的大小。
  • 地址的大小在32(位)bit操作系统下是4字节，在64(位)bit操作系统下是8字节。
#include <stdio.h>

int Add(int arr[], int sz);

int main() {
    int arr[5] = { 1,2,3,4,5 };
    printf("main sizeof(arr) = %d\n", sizeof(arr));
    int sz = sizeof(arr) / sizeof(arr[0]);
    int ret = 0;
    ret = Add(arr, sz);

    printf("ret = %d", ret);
    return 0;
}
//求一维数组中所有元素之和
//具有相同效果的不同写法
//int Add(int *arr, int sz)
//int Add(int arr[5], int sz)
int Add(int arr[], int sz) {
    printf("Add sizeof(arr) = %d\n", sizeof(arr));
    int i = 0;
    int sum = 0;
    for (i = 0; i < sz; i++) {
        sum += arr[i];
    }
    return sum;
}

image.png

#include <stdio.h>
//对有sz个元素的一维数组降序排列
void cmp_sort(int arr[], int sz);

int main() {
    //一维数组初始化
    int arr[] = { 1,2,3,4,5,6,7,8,9,0 };
    //求一维数组元素的个数
    int sz = sizeof(arr) / sizeof(arr[0]);
    int i = 0;
    //输出一维数组的所有元素
    for (i = 0; i < sz; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");
    //对有sz个元素的一维数组降序排列
    cmp_sort(arr, sz);
    for (i = 0; i < sz; i++) {
        printf("%d ", arr[i]);
    }
    return 0;
}
//对有sz个元素的一维数组降序排列
void cmp_sort(int arr[], int sz) {
    int i = 0;
    for (i = 0; i < sz; i++) {
        int j = 0;
        for (j = i + 1; j < sz; j++) {
            if (arr[i] < arr[j]) {
                int tmp = arr[i];
                arr[i] = arr[j];
                arr[j] = tmp;
            }
        }
    }
}

运行结果：
image.png

二维数组作为函数的参数

  • 二维数组传递给函数的是二维数组的数组名，而二维数组的数组名是二维数组首元素的地址，二维数组的首元素实际上是第一个一维数组，故二维数组的数组名是一维数组的地址(指针)，对应函数参数是二维数组，本质为指向一维数组的指针(数组指针)，如指向含有4个整型元素的数组的指针int (*p)[4]。

对指针数组 int (*p)[4]的解释：首先是一个指针，指向一个数组，数组中有4个元素，每个元素都是int。

#include <stdio.h>
//计算二维数组所有元素之和
int Add(int arr[3][4], int row, int column);

int main() {
    int arr[3][4] = { 1,2,3,4,5,6,7,8,9,10,11,12 };
    int ret = Add(arr, 3, 4);

    printf("ret = %d", ret);
    return 0;
}
//计算二维数组所有元素之和
//具有相同效果的二维数组作为参数的定义方式
//int Add(int arr[][4], int row, int column)
//int Add(int (*p)[4], int row, int column)
int Add(int arr[3][4], int row, int column) {

    int sum = 0;
    int i = 0;
    for (i = 0; i < row; i++) {
        int j = 0;
        for (j = 0; j < column; j++) {
            sum += arr[i][j];
        }
    }
    return sum;

}

二维数组作为函数参数时行数可以省略，但列数不能省略，因为本质为数组指针。

运行结果：
image.png

对二维数组作函数参数的进一步理解：

#include <stdio.h>

int Add(int arr[3][4], int row, int column);

int main() {
    int arr[3][4] = {1,2,3,4,5,6,7,8,9,10,11,12};
    printf("main sizeof(arr) = %d\n", sizeof(arr));

    printf("main sizeof(int(*)[4]) = %d\n", sizeof(int(*)[4]));

    printf("main sizeof(arr[0]) = %d\n", sizeof(arr[0]));
    printf("main sizeof(*(arr+0)) = %d\n", sizeof(*(arr + 0)));

    printf("main sizeof(arr[0][0]) = %d\n", sizeof(arr[0][0]));
    printf("main sizeof(*(*(arr+0)+0)) = %d\n", sizeof(sizeof(*(*(arr + 0) + 0))));
    int ret = Add(arr, 3, 4);
    printf("ret = %d", ret);

    return 0;
}
//具有相同效果的二维数组作为参数的定义方式
//int Add(int arr[][4], int row, int column)
//int Add(int (*p)[4], int row, int column)
int Add(int arr[3][4], int row, int column) {
    //这里的arr实际上是数组指针，sizeof算出的是地址的大小
    printf("Add sizeof(arr) = %d\n", sizeof(arr));
    //这里算的是数组指针的大小，是一个指针，sizeof算出的是地址的大小
    printf("Add sizeof(int(*)[4]) = %d\n", sizeof(int(*)[4]));
    //这里的arr[0]是二维数组的首元素，是一个一维数组名。而数组名单独作为
    // sizeof的操作数时数组名代表整个一维数组，求出的是整个一维数组的大小。
    //函数参数二维数组定义为3行4列，即每一个一维数组是四个整型元素
    printf("Add sizeof(arr[0]) = %d\n", sizeof(arr[0]));
    //arr本质是指针数组(int(*)[4]),指向一个一维数组。
    //(arr+0)解引用则是通过指针数组访问了其指向的一维数组，
    //故*(arr+0)相当于*arr相当于arr[0],是一维数组名。
    printf("Add sizeof(*(arr+0)) = %d\n", sizeof(*(arr + 0)));
    
    //arr[0][0]是二维数组中第一个一维数组中的的一个整型元素的值
    printf("Add sizeof(arr[0][0]) = %d\n", sizeof(arr[0][0]));
    //*(arr+0)是一维数组的数组名，*(arr+0)+0解引用则是通过一维数组名
    //访问一维数组的第一个元素，*(*(arr+0)+0)相当于*(arr[0]+0)相当于arr[0][0]
    printf("Add sizeof(*(*(arr+0)+0)) = %d\n", sizeof(sizeof( *(*(arr+0)+0) )));

    int sum = 0;
    int i = 0;
    for (i = 0; i < row; i++) {
        int j = 0;
        for (j = 0; j < column; j++) {
            sum += arr[i][j];
        }
    }
    return sum;

}

运行结果：
运行结果：
观察到main函数与Add函数中计算sizeof(arr)的本质不同。
二维数组作函数参数程序运行截图.png

5. 回顾：

本文主要写了有关C语言数组的内容。首先先了解了一维数组的创建，初始化，使用和在内存中的储存；然后就是二维数组的创建，初始化，使用和在内存中的储存。在对数组的使用中要预防数组的越界，知道数组越界可能会造成严重的影响。数组名也经常用作为函数传参，因此需要熟悉一维数组传参和二维数组传参的本质是什么。

END

re怠惰的未禾
关注
  • 1
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
c语言-数组详解(建议收藏)
10-20
c语言—数组详解(建议收藏)
C语言学习（3）第三章 数组
mopM2的博客
12-18 246
数组，一维数组，二维数组，数组初始化，数组练习
C语言复习第三章:数组
qq_44004011的博客
06-21 105
1.数组名(特殊的常量指针) int test01() { /* 1. sizeof 2.数组名取地址&a 除了以上两种情况 数组名都表示指向首元素的地址 */ int a[4] = {1,2,3,4}; printf("sizeof(a):%d\n",sizeof(a));//16 printf("&a:%d\n",&a);//04 printf("&a+1:%d\n",&a+1);//20
C语言基础三（数组）
liuliuliut的博客
11-29 266
数组
C语言学习3
m0_57957886的博客
03-22 1842
二维数组：类型说明符 数组名[行数][列数]; int a[3][4];/*定义一个整形二维数组a，有3行4列共12个元素分别为: a[0][0] a[0][1] a[0][2] a[0][3] a[1][0] a[1][1] a[1][2] a[1][3] a[2][0] a[2][1] a[2][2] a[2][3] */ char arry[10][10];//定义一个字符型二维数组arry，有10行10列，依次为arry[0][0]~arry[9][9]共100个元素 二维数组初始化...
C语言之三维数组
热门推荐
十三阿哥的博客
07-20 4万+
前言： 之前学习C语言的时候仅仅是掌握了二维数组，但是并没有对三维数组进行研究，今天的代码提前搞完了，摸摸鱼，对去年研究的三维数组的相关知识发布一下，期待能够帮助到有缘人！实际上，当你阅读此篇文章时，我假设你已经对C语言的二维数组非常熟悉了，并且非常熟悉数组与指针之间的关系，如果没有达到此要求，那直接翻篇，不要看，等待基础掌握扎实后再来学习此篇文章！ 一，看图说话，一眼看三维数组 二，首先看下三维数组的遍历 #include "stdio.h" void main(){ //三维数组 .
c语言指针数组-·详解数组指针与指针数组
04-25
·详解数组指针与指针数组 ·数组指针 ⾸先我们需要了解什么是数组指针以及什么是指针数组，如下图： int *p[5]; int (*p)[5]; 数组指针的意思即为通过指针引⽤数组，p先和*结合，说明了p是⼀个指针变量，指向⼀个...
C语言--指针详解
01-27
C语言里，变量存放在内存中，而内存其实就是一组有序字节组成的数组，每个字节有唯一的内存地址。CPU 通过内存寻址对存储在内存中的某个指定数据对象的地址进行定位。这里，数据对象是指存储在内存中的一个指定数据...
C语言数组详解ppt课件.ppt
11-13
C语言数组详解ppt课件.ppt
详解C语言中的字符串数组
01-21
在C语言当中，字符串数组可以使用： char a[] [10]; 或者 char *a[]; 表示 第一种表示方式固定了每个字符串的最大大小。第二种没有字符串的大小限制。 #include #include //该程序的功能是 输入阿拉伯数字的...
求矩阵对角线元素之和（C语言）
m0_67184754的博客
05-01 119
【代码】求矩阵对角线元素之和（C语言）
c语言开发图书管理系统项目源码+数据+可运行程序
05-01
c语言开发图书管理系统项目源码+数据+可运行程序 主要功能有：1、以管理员或读者不同身份注册账户。2、登录、找回密码、修改密码。3、管理员：图书入库，清除库存，统计书籍数量，统计读者借书情况，在馆书籍排序，读者排序。4、读者：查看个人借阅信息，借书，还书，按书名、作者、出版社检索图书，查询全部在馆图书。
基于transformer的多模态脑肿瘤分割.zip
05-01
本项目旨在利用Transformer模型实现多模态脑肿瘤分割。多模态脑肿瘤分割对于脑肿瘤的诊断和治疗具有重要意义。 我们采用Transformer模型，通过分析脑部MRI、CT、PET等不同模态的医学影像数据，实现对脑肿瘤区域的自动分割。项目使用的数据集包括公开的脑肿瘤影像数据集，如BRATS、Medical Segmentation Decathlon等，并进行了预处理，包括图像增强、分割和特征提取等。 在运行环境方面，我们使用Python编程语言，基于TensorFlow、PyTorch等深度学习框架进行开发。为了提高计算效率，我们还使用了GPU加速计算。此外，我们还采用了Docker容器技术，确保实验结果的可重复性。 项目完成后，将实现对多模态脑肿瘤的快速、准确分割，为脑肿瘤的诊断和治疗提供有力支持。同时，项目成果也可应用于其他医学影像分析领域。
马尔文高浓度池说明书 High Concentration Cell (ZEN1010)
05-01
马尔文高浓度池说明书 High Concentration Cell (ZEN1010)
如何提高APP商业变现能力.docx
05-01
如何提高APP商业变现能力.docx
node-v12.20.0-darwin-x64.tar.xz
05-01
Node.js，简称Node，是一个开源且跨平台的JavaScript运行时环境，它允许在浏览器外运行JavaScript代码。Node.js于2009年由Ryan Dahl创立，旨在创建高性能的Web服务器和网络应用程序。它基于Google Chrome的V8 JavaScript引擎，可以在Windows、Linux、Unix、Mac OS X等操作系统上运行。 Node.js的特点之一是事件驱动和非阻塞I/O模型，这使得它非常适合处理大量并发连接，从而在构建实时应用程序如在线游戏、聊天应用以及实时通讯服务时表现卓越。此外，Node.js使用了模块化的架构，通过npm（Node package manager，Node包管理器）,社区成员可以共享和复用代码，极大地促进了Node.js生态系统的发展和扩张。 Node.js不仅用于服务器端开发。随着技术的发展，它也被用于构建工具链、开发桌面应用程序、物联网设备等。Node.js能够处理文件系统、操作数据库、处理网络请求等，因此，开发者可以用JavaScript编写全栈应用程序，这一点大大提高了开发效率和便捷性。 在实践中，许多大型企业和组织已经采用Node.js作为其Web应用程序的开发平台，如Netflix、PayPal和Walmart等。它们利用Node.js提高了应用性能，简化了开发流程，并且能更快地响应市场需求。
R语言绘制SCI科研生存ROC曲线源代码.zip
最新发布
05-01
把input里面的数据替换成自己的数据，打开R，点Run，可以直接出图！文件适合有R语言基础的同学。
高电压技术(第三版)课后习题答案
05-01
高电压技术(第三版)课后习题答案
Linux线程同步：深入理解与实践.pdf
05-01
linux之线程同步一。 本文深入探讨了Linux线程同步的几种常见机制，并提供了代码示例。希望这些信息能够帮助你更好地理解和应用线程同步技术。在编写多线程程序时，请务必谨慎，确保线程安全。
凯撒密码c语言详解数组
11-09
撒密码是一种简单的加密算法，它通过将明文中的每个字母按照一定的偏移量进行替换来实现加密。在C语言中，我们可以使用数组来实现凯撒密码的加密和解密过程。 具体实现步骤如下： 1. 定义一个字符数组来存储明文和密文。 2. 通过循环遍历明文中的每个字符，将其按照一定的偏移量进行替换，并将替换后的字符存储到密文数组中。 3. 最后输出密文数组即可。 下面是一个简单的凯撒密码C语言实现示例： ```c #include <stdio.h> #include <string.h> int main() { char plaintext[100], ciphertext[100]; int i, key; printf("请输入明文："); scanf("%s", plaintext); printf("请输入偏移量："); scanf("%d", &key); // 加密过程 for (i = 0; i < strlen(plaintext); i++) { if (plaintext[i] >= 'a' && plaintext[i] <= 'z') { ciphertext[i] = 'a' + (plaintext[i] - 'a' + key) % 26; } else if (plaintext[i] >= 'A' && plaintext[i] <= 'Z') { ciphertext[i] = 'A' + (plaintext[i] - 'A' + key) % 26; } else { ciphertext[i] = plaintext[i]; } } ciphertext[i] = '\0'; printf("加密后的密文为：%s\n", ciphertext); return 0; } ```

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

re怠惰的未禾

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值