Caesar : Extra random characters at the end of a char ciphertext array

Question

I'm having a problem with an output. Sometimes output adds an extra characters, different each time the code runs. For example, when I use key "1" and write "a", it displays "bç" or "bv" or anything else weird.

I know that the problem may be fixed by adding "+1" in a loop here for (int i = 0; i < text_length; i++). Also I know that the problem is because at the end of the string is '\0' character.

But the things is that plaintext length = ciphertext length. So even in the loop there should be NO problems.

So I don't understand why it's fixed by adding +1 in a loop and I don't understand why it needs to add +1.

Please, explain this to me.

debug50 and variable tracking hasn't helped.

Here's what I found so far on this issue: Pset2 Caesar: extra letter printed at the end of ciphertext

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

int main(int argc, string argv[])
{
    // check if there's only one argument provided
    if (argc != 2)
    {
        printf("Usage: ./caesar key\n");
        return 1;
    }

    // check if argument is digit
    string string_key = argv[1];
    for (int i = 0, n = strlen(string_key); i < n; i++)
    {
        if (isdigit(string_key[i]) == false)
        {
            printf("Usage: ./caesar key\n");
            return 1;
        }
    }

    // convert string_key to int
    int key = atoi(string_key);

    // prompt user for a string to encipher
    string plaintext;
    do
    {
        plaintext = get_string("plaintext: ");
    }
    while (plaintext[0] == '\0');


    int UPPERCASE_DIFFERENCE = 65;
    int LOWERCASE_DIFFERENCE = 97;

    // get length of plaintext
    int text_length = strlen(plaintext);

    // create ciphertext array with length of plaintext
    char ciphertext[text_length];

    // loop through plaintext
    char character;
    for (int i = 0; i < text_length; i++)
    {
        character = plaintext[i];
        // check if character is a letter
        if (isalpha(character))
        {
            // check if character is an uppercase
            if (isupper(character))
            {
                // convert to alphabetical numbers, shift to key, convert back to ascii
                character = character - UPPERCASE_DIFFERENCE;
                character = (character + key) % 26;
                character = character + UPPERCASE_DIFFERENCE;
                // add to ciphertext
                ciphertext[i] = character;
            }
            else
            {
                // convert to alphabetical numbers, shift to key, convert back to ascii
                character = character - LOWERCASE_DIFFERENCE;
                character = (character + key) % 26;
                character = character + LOWERCASE_DIFFERENCE;
                // add to ciphertext
                ciphertext[i] = character;
            }
        }
        else
        {
            ciphertext[i] = character;
        }
    }
    // print ciphertext

    printf("ciphertext: %s\n", ciphertext);
}

Answer 1

You have to understand how printf and strlen work. Both of them (and several other functions) depend on the existence of the end of string marker, \0 at the end of the target string. If the EOS marker isn't there, they will keep reading data from memory until they find some random data byte that looks like the EOS marker, or 0x00.

Next, you need to understand that strlen() returns the number of chars in a string, excluding the EOS marker. BUT, when declared, a string needs to have 1 added to a strlen() result to allow space for the EOS marker. Your code doesn't allow for this when ciphertext is declared.

More importantly, during processing, the code inserts characters into ciphertext one at a time, BUT IT DOESN'T ADD AN EOS MARKER AT THE END! Even if it did, there's no room for it. We'll come back to the impact of that.

So, because there's no EOS marker at the end of ciphertext, the printf statement will read whatever physical data follows in memory because it thinks it's part of the string, treating it as ASCII codes, until it hits a 0x00 byte. That's why it prints random printable and unprintable characters at the end.

Now, there's another issue or two here. First, let's consider this code:

// prompt user for a string to encipher
    string plaintext;
    do
    {
        plaintext = get_string("plaintext: ");

This is going to cause problems. You have to understand what happens when a string (or later, a char array) is declared and how space for it is allocated. When a string is declared, the space for the string has to be allocated somehow. Once declared, a string is immutable. That means that the space allocated for it cannot be changed. It doesn't matter if you're using it for something shorter, but anything longer can possibly lead to data corruption.

So how does that happen here? Consider the declaration, string plaintext;. This declares a string of length 0. It doesn't initialize the string at the same time, so no space is allocated to it. But, C will allow data to be assigned to it later anyways. The problem with that is that C will overwrite the physical memory that follows with whatever the code says to write to plaintext. So, in this code, if the code reads a 20 char string with getstring(), it would overwrite the next 20 bytes in memory, whatever they're being used for, corrupting that data.

The code needs to both declare plaintext and initialize it with getstring in the same statement.

Don't worry about checking that something is written into it. That's handled inside getstring. Also, if your code encodes correctly, it'll handle no data correctly too. (It's too early in the course to worry about that all the time anyways.)

The declaration of ciphertext has a similar problem. ciphertext doesn't allow space for the EOS marker. Because of this, if the code tries to write the EOS marker, it'll corrupt the first byte following the string. That's why the +1 char when ciphertext is allocated.

Any questions? ;-)

If this answers your question, please click on the check mark to accept. Let's keep up on forum maintenance. ;-) \0

Answer 2

My friend developer has explained it to me too.

All your memory is like a long array. For example, you declared two strings — one of them has strlen of 0. When you assign data to that first string and if the data you assign is more than 0 characters — you will overwrite the part of 2nd string (if those two strings are adjacent). Length of overwritten space will equal the length of assigned data of 1st string.

A lot of errors in C are because C handles memory on a low-level.