如何将字符串返回到主函数？

Question

目标实际上是将字符串中的字符替换为ciphertext。用户使用命令行参数输入键，其中包含26个字母的键输入。

我运行程序时遇到了问题，它有分割故障（Core dustmed）。在调试期间，代码停止在功能线上工作。我的问题是发生了什么以及如何解决此问题，以便我可以创建一串键？

这是我的代码行：

#include <cs50.h>
#include <stdio.h>
#include <string.h>
#include <ctype.h>

// Declare crypting function
string encrypt(string text, string key_upper, string key_lower);
string valid_key_upper(string key);
string valid_key_lower(string key);

int main(int argc, string argv[])
{
    // Must contain an argument
    if (argc > 2 || argc < 2)
    {
        printf("Usage: ./substitution KEY\n");
        return 1;
    }

    // take the input from the commandline and validate them.
    string key_before = argv[1];
    int key_length = strlen(key_before);

    // evaluate the key length
    if (key_length != 26)
    {
        printf("Key must contain 26 characters.\n");
        return 1;
    }


    // Create initial key container
    char key[26];
    int evaluated_key = 0;

    for (int i = 0; i < key_length; i++)
    {
        // Validate so that only letters
        if (key_before[i] < 65|| key_before[i] > 122 || (key_before[i] > 90 && key_before[i] < 97))
        {
            printf("Must only contain letters!\n");
            return 1;
        }
        // Compare the current evaluated key to the existing key in the memory
        else
        {
            for (int n = 1; n < evaluated_key; n++)
            {
                if (key_before[i] == key[n])
                {
                    printf("Must not contain duplicate!\n");
                    return 1;
                }
            }
            // copy valid key to the key container
            key[i] = key_before[i];
            evaluated_key = evaluated_key + 1;
        }
    }

    // Make lower-case and upper-case function container
    string key_upper = valid_key_upper(key);
    string key_lower = valid_key_lower(key);

    // get user input of plaintext
    string plaintext = get_string("Plaintext: ");

    // function for ciphering
    string ciphertext = encrypt(plaintext, key_upper, key_lower);

    // print out the ciphered text
    printf("Ciphertext = %s\n", ciphertext);

}

string valid_key_upper(string key)
{
    // Declare variable container
    string key_upper = NULL;

    // Take the key and evaluate each character
    for (int i = 0; i < 26; i++) // evaluate for 26 characters
    {
        if (key[i] >= 65 && key[i] <= 90)
        {
            key_upper[i] = key[i];
        }
        else if (key[i] >= 97 && key[i] <= 122)
        {
            key_upper[i] = toupper(key[i]);
        }
    }
    key_upper[26] = '\0';
    return key_upper;
}

Answer 1

您的问题是key_upper in 有效_key_upper;没有为字符串分配空间，然后将其初始化为null，因此当将值分配给key_upper [i]时，您就会丢弃堆栈。您必须malloc key_upper才能为其分配字符串元素。

Answer 2

您正在使用空指针来访问内存。

例如，在函数中，有效_key_upper指针key_upper设置为null，

string key_upper = NULL;

然后在下面的循环中，您正在尝试取消

// Take the key and evaluate each character
for (int i = 0; i < 26; i++) // evaluate for 26 characters
{
    if (key[i] >= 65 && key[i] <= 90)
    {
        key_upper[i] = key[i];
        //...

导致不确定行为的指针。

无需创建这样的字符串。当字符串加密时，您可以将当前字符转换为上部或下情况。

通常，您的代码可以简化。例如，如果语句

if (argc > 2 || argc < 2)
{
    printf("Usage: ./substitution KEY\n");
    return 1;
}

可以编写，

if (argc !=  2)
{
    printf("Usage: ./substitution KEY\n");
    return 1;
}

而是使用65和122之类的魔术数字是一个坏主意。而是使用整数字符常数。这使代码更加清晰。

Answer 3

感谢您的答案，因此我在key_upper变量中使用了malloc并解决了问题。在变量中分配了27个字节。另外，我简化了功能。

string valid_key_upper(string key)
{
    // Declare variable container
    string key_upper = malloc(27);

    // Take the key and evaluate each character
    for (int i = 0; i < 26; i++) // evaluate for 26 characters
    {
         key_upper[i] = toupper(key[I]);
    }
    return key_upper;
}