C 使用少量字符串操作和<；标准h>；只有

我试图只使用一个库，但遇到了一些问题。此程序应执行以下操作：

• 它应该有一个加密函数和另一个用于解密的函数
• 字符串必须是8个大写字母或数字（

  A-Z 0-9

  ）
• 这个过程应该是这样的：
  • A: 将给定字符串向后移动2个字符
    之前：

    abcdefg

    
    之后：

    cdefgab

  • B:反转函数的结果
    之前：

    cdefgab

    
    之后：

    bagfedc

  • C：将字符与未配对的字符交换配对。
    之前：

    ereaeedf

    
    之后：

    reaeeefd

  • D:正在检查加密表。
    两个数组

    [原始]

    和

    [加密]

    
    获取字符串并将其划分为字符表中的每个字符，获取其原始位置（A=1、B=2、C=3等），然后转到[Encrypted]数组并获取位于相同位置的字符

    array[Original] = {"A","B","C","D","D","F");
    array[Encrypted]= {"%","a","h","k","c","^");
    

    之前：

    FACD

    
    之后：

    ^%hk

我现在的问题是

Enc_Table

无法按预期工作。 我不知道为什么。我试过一些东西，但都没解决

我的代码来源：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#define charsize 8

bool isStringEncrypted(char[]);
void Encryption();
char* Rotate_R(char str[]);
char* Reverse(char str[]);
char* Swap(char str[]);
char* Enc_Table(char str[]);
int getPos(const char *array, size_t size, char c);

void main() {

    int choose = 0;
    while (choose != 3){
        printf("Menu: \n\n  Please choose an option: \n\n 1 - Encrypt \n 2 - Decrypt [Not Implemented Yet] \n 3 - Exit \n\nYour selection ? :");
        scanf("%d", &choose);
        switch (choose)                                
        {

            case 1:
                Encryption();
                break;

            case  2:
                //Decryption();
                break;

            case 3:
                break;

            default:
                printf("Wrong choice, try again!\n");

        }

    }
}


void Encryption(){

    char str[charsize];
    char result[charsize];
    do {
        printf("please enter the string with 8 characters\n =>");
        scanf("%s", str);
        printf("\n Variable Str Value  = %s \n", str);
    } while (isStringEncrypted(str) == false);


    printf("Swap = %s \n", Swap(str));
    printf("Rotate_R =  %s \n", Rotate_R(str));
    printf("Reverse = %s \n", Reverse(str));
    printf("Enc_Table = %s \n", Enc_Table(str));
    printf("\nEncrypted String : %s \n", Enc_Table(Reverse(Rotate_R(Swap(str)))));
    scanf("%s", result);
}


bool isStringEncrypted(char str[])
{
    int i = 0;
    int Letters = 0;
    int Numbers = 0;


    unsigned int len = 0;
    while (*(str + len)) len++;

    if (len != charsize)
    {
        printf(" \n %d = len != %d = Size \n", len, charsize);
        return false;
    }


    while (str[i] != NULL && i < charsize) {
        if (str[i] >= 'A' && str[i] <= 'Z' || str[i] >= '0' && str[i] <= '9') {

            if (str[i] >= 'A' && str[i] <= 'Z')
                Letters++;
            if (str[i] >= '0' && str[i] <= '9')
                Numbers++;
        }

        i++;
    }

    if (i == charsize && (Letters >= 2) && (Numbers >= 2))
        return true;
    else return true;
}

char* Rotate_R(char str[])
{
    char x, y;
    int i;
    x = str[7];
    y = str[6];

    for (i = 5; i>-1; i--)
    {
        str[i + 2] = str[i];
    }
    str[0] = y;
    str[1] = x;

    return str;
}

char* Swap(char str[])
{
    int i;
    char Temp;

    for (i = 0; i < charsize; i += 2)
    {
        Temp = str[i];
        str[i] = str[i + 1];
        str[i + 1] = Temp;
    }

    return str;
}

char* Reverse(char str[])
{
    unsigned int lens = 0;
    while (*(str + lens)) lens++;
    char temp;
    size_t len = lens - 1;
    size_t i;
    size_t k = len;

    for (i = 0; i < len; i++)
    {
        temp = str[k];
        str[k] = str[i];
        str[i] = temp;
        k--;
        if (k == (len / 2))
        {
            break;
        }
    }

    return str;
}

char* Enc_Table(char str[])
{

    int i;
    unsigned int lens = 0;
    while (*(str + lens)) lens++;

    char dec[38] = { 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '\0' };
    char enc[38] = { 'S', '5', 'P', 'W', 'A', 'R', '8', 'Q', 'I', 'V', 'B', '0', 'D', 'Z', '3', 'C', '2', 'H', '4', '1', 'K', '7', 'G', 'Y', '6', 'O', 'J', 'E', 'U', 'N', 'F', '9', 'M', 'L', 'T', 'X', '\0' };

    for (i = 0; i < charsize; i++)
    {
        int index = getPos(dec, sizeof(dec), str[i]);
        str[i] = enc[index];
        i++;
    }

    return str;
}

int getPos(const char *array, size_t size, char c)
{
    for (size_t i = 0; i < size; i++)
    {
        if (array[i] == c)
            return (int)i;
    }
    return -1;
}

\define\u CRT\u SECURE\u NO\u警告
#包括
#定义字符大小8
bool-isStringEncrypted（char[]）；
无效加密（）；
char*Rotate_R（char str[]）；
字符*反向（字符str[]）；
字符*交换（字符str[]）；
char*Enc_表（char str[]）；
int getPos（常量字符*数组，大小\u t大小，字符c）；
void main（）{
int=0；
while（选择！=3）{
printf（“菜单：\n\n请选择一个选项：\n\n 1-加密\n 2-解密[尚未实现]\n 3-退出\n\n您的选择？：”；
scanf（“%d”，选择（&C））；
开关（选择）
{
案例1：
加密（）；
打破
案例2：
//解密（）；
打破
案例3：
打破
违约：
printf（“选择错误，请重试！\n”）；
}
}
}
无效加密（）{
charstr[charsize]；
字符结果[字符大小]；
做{
printf（“请输入包含8个字符的字符串\n=>”；
scanf（“%s”，str）；
printf（“\n变量Str值=%s\n”，Str）；
}while（isStringEncrypted（str）=false）；
printf（“Swap=%s\n”，Swap（str））；
printf（“Rotate_R=%s\n”，Rotate_R（str））；
printf（“Reverse=%s\n”，Reverse（str））；
printf（“Enc_Table=%s\n”，Enc_Table（str））；
printf（“\n加密字符串：%s\n”，Enc_表（反向（旋转（交换（str '））））；
扫描频率（“%s”，结果）；
}
bool IsStringCrypted（字符str[]）
{
int i=0；
整数字母=0；
整数=0；
无符号整数len=0；
而（*（str+len））len++；
if（len！=字符大小）
{
printf（“\n%d=len！=%d=Size\n”，len，charsize）；
返回false；
}
while（str[i]！=NULL&&i='A'&&str[i]='0'&&str[i]='A'&&str[i]='0'&&str[i]=2）&&（数字>=2））
返回true；
否则返回true；
}
char*Rotate_R（char str[]）
{
字符x，y；
int i；
x=str[7]；
y=str[6]；
对于（i=5；i>-1；i--）
{
str[i+2]=str[i]；
}
str[0]=y；
str[1]=x；
返回str；
}
字符*交换（字符str[]）
{
int i；
焦炭温度；
对于（i=0；i

加密表的工作原理如下：

void table(char *str, int forward)
{
    const char dec[36] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
    const char enc[36] = "S5PWAR8QIVB0DZ3C2H41K7GY6OJEUNF9MLTX";

    const char *from = forward ? dec : enc;
    const char *to   = forward ? enc : dec;

    for (int i = 0, len = strlen(str); i < len; i++)
    {
        for (int n = 0; n < 36; n++)
        {
            if (str[i] == from[n])
            {
                str[i] = to[n];
                break;
            }
        }
    }
}

int main()
{
    char s[100];
    strcpy(s, "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789");

    table(s, 1);// encryption
    printf("%s\n", s);
    table(s, 0);// decryption
    printf("%s\n", s);
    return 0;
}

---

一个主要问题是，您要求用户输入八个字符，但随后

scanf

将向目标数组写入九个字符。这是因为它还写入字符串终止符。写入超出分配内存的范围当然会导致整个程序格式错误。我也尝试将其更改为9然后在我检查大小的地方，我只做大小-1..，但仍然不起作用..不知何故，数组将保持无序和有问题..我仍然会遇到异常..任何人都可以帮助我，代码更新-现在的问题是Enc_Table函数。您似乎在调试输出中交换了两次，一次，然后在调用加密它时。还使用fgets而不是scanf为了更好地控制键盘输入，如果用户写入的字符串长度超过8，那么您的程序很可能会崩溃。您的缓冲区至少需要9个字符长才能保存\0（fgets也添加\n）。我怀疑您可以使用

strcspn（）

而不是inne

void table(char *str, int forward)
{
    const char *dec = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
    const char *enc = "S5PWAR8QIVB0DZ3C2H41K7GY6OJEUNF9MLTX";

    const char *from = forward ? dec : enc;
    const char *to   = forward ? enc : dec;

    char buf[2] = { 0 };
    for (int i = 0, len = strlen(str); i < len; i++)
    {
        buf[0] = str[i];
        int pos = strcspn(from, buf);
        if (pos < 36)
            str[i] = to[pos];
    }
}

void rotate(char *str, int rotate, int direction /*1=rotate-right, 0=rotate-left*/)
{
    int length = strlen(str);
    if (!rotate || rotate >= length)
        return;

    int offset = direction ? (length - rotate) : rotate;

    char *left  = _strdup(str);
    char *right = _strdup(str + offset);

    //swap left and right to finish rotate 
    strcpy(str, right);
    strncat(str, left, offset);

    free(left);
    free(right);
}