目录
前言部分功能、开发环境与项目构造主函数设计statistics 头文件以及源文件
encryption 头文件以及源文件
前言
耗时一天一夜写了一个简易的《英文统计和加密系统》，实际上就是对字符数组的根本操作的各种使用，其中也牵扯到简单的读写文件，把构造体存入文本文件等知识。总体来说，只要在编写前搭建好一个思维框架，逐个实现功能就轻松的多了。
部分功能、开发环境与项目构造
部分功能展示：
开发环境：
我使用的开发环境是 Visual Stduio 2022(2019版本应该更好)。
项目构造：
包含两个头文件和对应的源文件， main.c，以及三个文本文件：
主函数设计
// 英文统计和加密系统
// statistics 统计
// encryption 加密(构造体相关功能也在此处)
#include"statistics.h"
#include"encryption.h"
int main() {
char buf[BUFSIZE];
memset(buf, '0', sizeof(buf)); // 给字符数组初始化为 '0'
showInfo(buf);
printf("当前字母数：%d\n",countCharacter(buf));
printf("当前单词数：%d\n",countWord(buf));
printf("第12个字母为：");
show_i(buf, 12);
printf("与字母 'b'相比，小于，等于，大于的字母个数分别为：");
classify_c(buf, 'b');
int x = count_appear(buf, 'y');
printf("字母y(不区分大小写)呈现的次数为：%d\n", x);
printf("所有y呈现的下标为：");
int* A = (int*)malloc(sizeof(int) * x +1);
int *n = location_index(buf, A, 'y');
for (int i = 0; i < x; i++) {
printf("%3d", n);
}
printf("\n");
encryption(buf, 3);
/*puts(buf);*/
printf("将26个英文字母打包成一个构造体，附加对应次数\n");
alphabet chars;
Initialize(&chars);
printf("计算字母呈现次数并存入文本文件中：\n");
count_letters(buf, &chars);
encrypt en = maxTimes(chars);
encrypt minEn = minTimes(chars);
printf("呈现最多的字母为：%c，对应次数为：%d\n", en.data, en.num);
printf("呈现最少的字母为：%c，对应次数为：%d\n", minEn.data, minEn.num);
printf("字母平均呈现次数：%.2f\n", averageNum(chars));
int k = 8;
char* list = list_k(chars,k);
printf("前%d名字母序列为：", k);
for (int i = 0; i < k; i++) {
printf("%2c", list);
}
select_sort(chars);
//setText(&chars); // 需要更新构造体文本文件时使用
}主函数完全可以使用 循环+switch-case来做一个菜单，反复使用功能。
实现效果已经在上文中展示，后序不再展示。
statistics 头文件以及源文件
statistics.h
#pragma once // 防止反复包含头文件
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define BUFSIZE 512
// 获取原文长度
int get_length(char* buf);
// 获取文本的原文内容
void getText(char *buf);
// 得到原文内容
void showInfo(char *buf);
// 统计原文字母个数
int countCharacter(char* buf);
// 统计原文单词个数
int countWord(char* buf);
// 显示原文第i个单词
void show_i(char* buf,int i);
// 根据字符c的大小，分为三部分
void classify_c(char* buf, char c);
// 定位值为c的下标
int* location_index(char* buf, int* index,char c);
// 字符c的呈现次数
int count_appear(char* buf, char c);
statistics.c
#include"statistics.h"
// 获取原文有效长度
int get_length(char* buf) {
int len = 0;
for (int i = 0; i < BUFSIZE && buf != '0'; i++) {
len++;
}
return len;
}
//用子函数实现从文本文件读取原文的操作
void getText(char *buf) {
FILE* file;
file = fopen("myfile.txt", "r");
if (file == NULL) {
printf("翻开文件失败!");
exit(-1);
}
char arr[BUFSIZE];
memset(arr, '0', sizeof(arr));
fgets(arr, sizeof(arr), file);
fclose(file);
strcpy(buf, arr);
}
//1.定义一字符数组word，用户输入原文或从一文本文件读入（调用子函数）原文（一段英文），
// 输出显示该原文，以及其总长度。
void showInfo(char* buf) {
printf("1.输入原文：\n");
printf("2.读取原文\n");
int choice = 0;
scanf("%d", &choice);
rewind(stdin); // 清空缓冲区
if (choice == 1) {
char arr[BUFSIZE];
memset(arr, '0', sizeof(arr));
fgets(arr, sizeof(arr), stdin);
strcpy(buf, arr);
}
else if (choice == 2) {
getText(buf);
}
else {
printf("请正确选择获取原文方式！"); exit(-1);
}
int sum = get_length(buf);
if (choice==2) printf("总长度为：%d\n", --sum); // 去掉自带的 .
else printf("总长度为：%d\n", sum-2); // fgets会多读一个字符
printf("原文：%s\n", buf);
}
//3.用子函数实现统计原文中的字母个数。
int countCharacter(char* buf) {
int i;
int count = 0;
for (i = 0; i < BUFSIZE&&buf!= '0'; i++) {
if (buf >= 'a' && buf <= 'z' || buf >= 'A' && buf <= 'Z') {
count++;
}
}
return count;
}
//4.用子函数实现统计原文中的单词个数。
int countWord(char* buf) {
int i;
int count = 0;
for (i = 1; i < BUFSIZE&&buf!='0'; i++) {
if (buf == ' ' &&(buf[i - 1] >= 'a' && buf[i - 1] <= 'z' || buf[i - 1] >= 'A' && buf[i - 1] <= 'Z'))
count++;
}
if (buf[i - 1] >= 'a' && buf[i - 1] <= 'z' || buf[i - 1] >= 'A' && buf[i - 1] <= 'Z')
count++;
return count;
}
//5.定义一子函数，输入任一下标值i，检查i的输入合法性，
// 合法输出显示word的第i个字母，否则输出“输入i不合法”。
void show_i(char* buf,int i) {
int len = countCharacter(buf);
if (i<1 || i>len) {
printf("输入i不合法\n");
exit(-1);
}
int index = 0; // 记录当前字母位序
for (int j = 0; j < BUFSIZE && buf[j] != '0'; j++) {
if (buf[j] >= 'a' && buf[j] <= 'z' || buf[j] >= 'A' && buf[j] <= 'Z') {
++index;
if (index == i) {
printf("%c\n", buf[j]);
return;
}
}
}
}
//6.定义一子函数，输入一字母c, 分别输出word中大于字母c的个数和小于字母c的个数，
// 以及等于字母c的个数。
void classify_c(char* buf, char c) {
char arr[BUFSIZE];
memset(arr, '0', sizeof(arr));
int index = 0; // 记录当前字母位序
for (int j = 0; j < BUFSIZE && buf[j] != '0'; j++) {
if (buf[j] >= 'a' && buf[j] <= 'z' || buf[j] >= 'A' && buf[j] <= 'Z') {
arr[index++] = buf[j];
}
}
// 冒泡排序(升序)
for (int i = 0; i < index; i++) {
char flag = 'f';// 标志位
for (int j = index-1; j > i; j--) {
if (arr[j] < arr[j - 1]) {
flag = 't';
char ch = arr[j];
arr[j]=arr[j-1];
arr[j - 1] = ch;
}
}
if (flag == 'f') break;
}
int l, h, e,i;
for (l = 0, h = 0, e = 0, i = 0; i < index; i++) {
if (arr < c) l++;
else if (arr == c) e++;
else break;
}
h = index - l - e;
printf("little:%d equal:%d high:%d\n", l, e, h);
}
//7.定义一子函数，实现字符查找功能：断定该字母是否存在，
// 是则返回每一个呈现位置的下标（或者首次呈现的下标位置），否则返回 - 1。
int* location_index(char* buf, int *index,char c) {
int i;
int in = 0;
char flag = 'f';// 假设最终还是f，说明找不到该字母
for (i = 0; i < BUFSIZE && buf != '0'; i++) {
if (buf == c||c == buf+32||c==buf-32) index[in++] = i;
flag = 't';
}
if (flag == 'f') return -1;
return index;
}
//8.定义一子函数，实现输入一字母，统计原文中该字母的呈现次数(字母不区分大小写, 实现合并计数)
// 并返回。函数中需要有对输入的字母是否输入异常断定和捕获操作，并在主程序中停止输入错误提示。
int count_appear(char* buf, char c) {
if (!(c >= 'a' && c <= 'z' || c >= 'A' && c <= 'Z')) {
printf("当前字符为%c，请输入正确字母\n", c);
exit(-1);
}
int i;
int count = 0;
for (i = 0; i < BUFSIZE && buf != '0'; i++) {
if (c == buf || c == buf + 32 || c == buf - 32) count++;
}
return count;
}
encryption 头文件以及源文件
encryption.h
#pragma once
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
// 字母以及呈现次数的构造体
typedef struct {
char data; // 显示字母
int num; // 呈现次数
}encrypt;
typedef struct {
encrypt letters[26];
}alphabet;
// 初始化字母表
void Initialize(alphabet *chars);
// 计算各个字母的呈现次数
void count_letters(char* buf, alphabet* chars);
// 存入构造体文本文件
void setText(alphabet *chars);
// 返回呈现次数最多的字母
encrypt maxTimes(alphabet chars);
// 返回呈现次数最少的字母
encrypt minTimes(alphabet chars);
// 计算字母呈现的平均次数
float averageNum(alphabet chars);
// 呈现前k名的字母序列
char* list_k(alphabet chars, int k);
// 选择升序或者降序排序
void select_sort(alphabet chars);
// 加密算法，根据n的位置循环后移
void encryption(char* buf, int n);
// 存入加密的文本文件
void setEncryptText(char* buff);
encryption.c
#include"encryption.h"
#include"statistics.h"
//9.将26个英文字母和其对应的呈现次数打包定义为一个构造体类型来存储。
// 初始化构造体数组
void Initialize(alphabet* chars) {
int k = 0;
char c = 'a';
for (int i = 0; i < 26; i++) {
chars->letters.num = k;
chars->letters.data = c + i;
}
}
//10.设计实现一新的子函数，针对读入的原文，统计出26个英文字母在单词中呈现的次数，
//并统一存储到9定义的构造体数组中，然后完成11到16的操作。
void count_letters(char* buf, alphabet* chars) {
printf("1.输入原文：\n");
printf("2.读取原文\n");
int choice = 0;
int sum = 0;
scanf("%d", &choice);
rewind(stdin); // 清空缓冲区
if (choice == 1) {
char arr[BUFSIZE];
memset(arr, '0', sizeof(arr));
fgets(arr, sizeof(arr), stdin);
strcpy(buf, arr);
}
else if (choice == 2) {
getText(buf);
}
else {
printf("请正确选择获取原文方式！"); exit(-1);
}
char arr[BUFSIZE]; // 最终转化为全部字母
memset(arr, '0', sizeof(arr));
int index = 0; // 记录当前字母位序
for (int j = 0; j < BUFSIZE && buf[j] != '0'; j++) {
if (buf[j] >= 'a' && buf[j] <= 'z' || buf[j] >= 'A' && buf[j] <= 'Z') {
arr[index++] = buf[j];
}
}
for (int i = 0; i < index; i++) {
for (int j = 0; j < 26; j++) {
if (arr == chars->letters[j].data || arr + 32 == chars->letters[j].data)
chars->letters[j].num++;
}
}
}
//11.将构造体数组结果存储到一文本文件。
void setText(alphabet* chars) {
FILE* fp;
fopen_s(&fp, "struct.txt", "wt+"); //翻开文件
for (int i = 0; i < 26; i++) //将N条信息存储进去
{
fprintf(fp, "%d %d\n", chars->letters.data, chars->letters.num);
}
fclose(fp); //关闭文件
//encrypt buff[26];
//FILE* fpp;
//fopen_s(&fpp, "struct.txt", "rb");
//fread(buff, sizeof(encrypt), 26, fpp); // 将N条消息全部从文件中读取出来
//fclose(fpp);
}
//12.设计一子函数：返回呈现次数最多的字母和对应次数。
encrypt maxTimes(alphabet chars) {
int max = chars.letters[0].num;
int i, index;
for (i = 1, index = 0; i < 26; i++) {
if (max < chars.letters.num) {
max = chars.letters.num;
index = i;
}
}
return chars.letters[index];
}
//13.设计一子函数：返回呈现次数最少的字母和对应次数。
encrypt minTimes(alphabet chars) {
int min = chars.letters[0].num;
int i, index;
for (i = 1, index = 0; i < 26; i++) {
if (min > chars.letters.num) {
min = chars.letters.num;
index = i;
}
}
return chars.letters[index];
}
//14.设计一子函数：返回26个字母的平均呈现次数。
float averageNum(alphabet chars) {
float avg = 0.0;
for (int i = 0; i < 26; i++) {
avg += chars.letters.num;
}
avg /= 26;
return avg;
}
//15. 设计一子函数：输入数字k，返回呈现次数前k名的字母序列
char* list_k(alphabet chars, int k) {
if (k < 1 || k>26) exit(-1);
char* list = (char*)malloc(sizeof(char) * k);
// 冒泡排序
for (int i = 0; i < 26; i++) {
char flag = 'f';
for (int j = 25; j > i; j--) {
if (chars.letters[j].num > chars.letters[j - 1].num) {
flag = 't';
encrypt temp = chars.letters[j];
chars.letters[j] = chars.letters[j - 1];
chars.letters[j - 1] = temp;
}
}
if (flag == 'f') break;
}
for (int i = 0; i < k; i++) {
list = chars.letters.data;
}
return list;
}
//16.定义一排序子函数，实现对构造体数组结果依照呈现次数停止升序或降序排列
//（由用户在运行时选择排序方式）, 输出排序结果以及对应的字母。
void select_sort(alphabet chars) {
printf("\n1.升序排列\n2.降序排列\n");
int choice = 0;
scanf("%d", &choice);
if (choice == 2) {
for (int i = 0; i < 26; i++) {
char flag = 'f';
for (int j = 25; j > i; j--) {
if (chars.letters[j].num > chars.letters[j - 1].num) {
flag = 't';
encrypt temp = chars.letters[j];
chars.letters[j] = chars.letters[j - 1];
chars.letters[j - 1] = temp;
}
}
if (flag == 'f') break;
}
}
else if (choice == 1)
{
for (int i = 0; i < 26; i++) {
char flag = 'f';
for (int j = 25; j > i; j--) {
if (chars.letters[j].num < chars.letters[j - 1].num) {
flag = 't';
encrypt temp = chars.letters[j];
chars.letters[j] = chars.letters[j - 1];
chars.letters[j - 1] = temp;
}
}
if (flag == 'f') break;
}
}
else {
printf("请正确选择排序规则！");
exit(-1);
}
printf("排序结果为：");
for (int i = 0; i < 26; i++) {
printf("%2c", chars.letters.data);
}
}
//17.用子函数实现将读取的原文按规则加密后存入另一字符数组中。
//电文加密 : 问题描绘：为使电文失密，常按一定规律将其转换成密文后发送，
//收报人再按约定的规律将其译回原文。设定加密规则为：
//每个字母变成其后的第n(n由用户输入指定)个字母，如A变成其后第n个字母….。
//说明 : 只对原文中的英文字母加密, 其他非英文字母要原样保留。
void encryption(char* buf, int n) {
n %= 26; // 确保英文字母加密后还是英文字母
int i;
int len = get_length(buf);
char* arr = (char*)malloc(len * sizeof(char));
memset(arr, '0', sizeof(arr));// 初始化
for (i = 0; i < len; i++) {
if (buf >= 'a' && buf <= 'z' || buf >= 'A' && buf <= 'Z') {
if (buf + n > 'z') {
arr = buf + n - 26;
}
else if (buf <= 'Z' && buf + n > 'Z') {
arr = buf + n - 'Z' + 'A'-1;
}
else {
arr = buf + n;
}
}
else {
arr = buf;
}
}
printf("加密后：%s\n", arr);
setEncryptText(arr);
}
//18.用子函数实现将密文存入密文文本文件中。
void setEncryptText(char* buff) {
FILE* fp;
fp = fopen("encryption.txt", "wt+");
if (fp == NULL) {
printf("翻开文件失败!");
exit(-1);
}
fputs(buff, fp);
fclose(fp);
}myfile.txt文件中可自行输入密文（26个英文字母大小写，各种符号，数字等等）；
struct.txt文件有26行，对应着原文中26个英文字母呈现的次数以及ASCII码值；
encryption.txt文件是myfile.txt文件中的字母通过循环后移 n 位得到，其中的难点在于大写字母后移超越Z时的处置方法，这点大家可以在encryption.c文件中的encryption函数中获得灵感。
到此这篇关于基于C语言编写简易的英文统计和加密系统的文章就介绍到这了,更多相关C语言英文统计和加密系统内容请搜索网站以前的文章或继续阅读下面的相关文章希望大家以后多多支持网站！ |
