Questions about the syntax and workings of C

Question

First I would like to thank everyone for everything they have ever done for me whether they knew it or not. I am a first time poster long time lurker.

I am starting a new class that is based around C and several of its variants. The problem is it assumes you have experience with at least C++, and I unfortunately have only taken a couple semesters of Java and Mips. I am struggling to learn C right now with no book or lesson plan going over it. I have survived this first month using Google. But my question today I just cannot seem to wrap my head around, and while I know it is elementary I would like some help understanding the working of the code in my assignment.

The professor has supplied us with the following code:

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

void encrypt(int offset, char *str) {

    int i,l;

    l=strlen(str);

    printf("\nUnencrypted str = \n%s\n", str);

    for(i=0;i<l;i++)
        if (str[i]!=32)
            str[i] = str[i]+ offset;

    printf("\nEncrypted str = \n%s \nlength = %d\n", str, l);
}   

void decrypt(int offset, char *str) {


}   

void main(void) {

    char str[1024];

    printf ("Please enter a line of text, max %d characters\n", sizeof(str));

    if (fgets(str, sizeof(str), stdin) != NULL)
    {
        encrypt(5, str);    // What is the value of str after calling "encrypt"?

        // add your method call here:
    }
}   

So the questions for the homework are listed in the code, but to make it clear that is not what I am after. I want to understand how this program is working so far.

Specifically:

1. Why write char str[1024]

2. What exactly is if (fgets(str, sizeof(str), stdin) != NULL) doing? I have a decent idea but I don't know the reasoning behind it.

3.And lastly (I hope) in

if (str[i]!=32)
    str[i] = str[i]+ offset;

why are we worried about str[i] not equaling 32?

I am sorry if this is a lot to be asking but I really truly want to understand this.

Also if you know of any fantastic reads for C please let me know because I am rather worried about the rest of this semester at this point.

EDIT:

Just wanted to say thank you very much to everyone who answered me. I am unfortunately not one of those people who immediately likes to continue asking more questions to acknowledge that you helped me. So for those of you who I didn't directly thank or comment back, Thank you very much. I now have a much firmer grasp on some of the very elementary concepts I was nervous about only 30 mins ago.

Answer 1

1. You use char str[1024] because C does not have any concept of a string, only arrays of char terminated by NUL aka 0. It doesn't have any concept of "stretchy" containers that you don't explicitly implement yourself. So if you want to read a string of input without writing a lot of your own input handling you guess at some maximum length (in this case, 1024) and make space for that in advance.
2. fgets reads a string (and when you say "string" in C that means "array of char terminated by 0, as above). You pass in str which is the pointer to the start of the storage and sizeof(str) which is evaluated at compile time to be the number of bytes that str takes up. It means 1024 in this case, with the advantage that it will track the change if you change the char str line. That argument is preventing fgets from writing beyond the allocated space of str. Remember, it's not a stretchy string.
3. ASCII 32 is space. It would have been clearer to write str[i] != ' '

Answer 2

A great start would be Kernighan + Ritchie's book,The C Programming Language.
Amazon: here

Also, see The Definitive C Book Guide and List.

Answer 3

1. this says that str is an array of 1024 chars
2. "fgets() reads in at most one less than size characters from stream and stores them into the buffer pointed to by s. Reading stops after an EOF or a newline. If a newline is read, it is stored into the buffer. A terminating null byte ('\0') is stored after the last character in the buffer."
3. apparently characters with value 32 are not to be "encrypted". Find an ASCII table and see what special character 32 is...

ps. "gets() and fgets() return s on success, and NULL on error or when end of file occurs while no characters have been read."

Answer 4

char str[1024];

declares str as a 1024-element array of char.

fgets(str, sizeof (str), stdin)

reads up to sizeof (str) (1024) characters from stdin (standard input, basically your console) and stores those characters to str. fgets will return NULL if there's an error during the read, so

if (fgets(std, sizeof(str), stdin) != NULL)
{
  encrypt(...);
  ...
}

will execute the body of the if statement only if we successfully read an input string.

32 is the ASCII code for a space (' ') character; for whatever reason, the encryption algorithm leaves space characters in the string as is.

Answer 5

First question:

In Java, you have to new all your arrays, e.g. char[] arr = new char[1024]. In C (and C++), you can opt to either dynamically allocate the array like Java (using malloc in C and new [] in C++), or statically allocate the array using a fixed size (the char str[1024] you see there).

In C, because all memory needs to be manually managed with malloc and free, statically allocated buffers save a bit of hassle since they are automatically freed when the function exits. In Java, you rarely deal with memory allocation because the runtime automatically garbage collects unused objects.

In Java, you have String, which wraps an array of char. In C, you only have arrays of char, typically represented as either an array of char or a pointer to the first character (char *). Note too that the Java char is 16 bits (2 bytes) wide as it handles Unicode; the C char is only 8 bits (1 byte) in size.

Finally, note that in C, all strings are terminated by a null byte '\0'. Strings thus have to be big enough to hold both the content and the terminating null byte -- failing to count that null byte might result in a buffer overflow.

Second question:

In Java, you can use readLine to read a line of text from a file, or from the user's input. In C, you use fgets. However, in Java, the runtime will dynamically allocate a string big enough to hold the input line (however long that line might be); in C, since buffers are typically allocated by the programmer, the function can only read as many characters as the buffer will permit (reading characters past the end of a buffer is called a buffer overflow, a common cause of security vulnerabilities).

fgets therefore takes three parameters: the buffer to read into, the size of that buffer, and the file to read from (here stdin, the console).

Third question:

Strings in C are simply sequences of ASCII characters. So, the code there is encrypting characters (by adding this "offset") only if the character isn't 32 -- a space character. The result is that all non-spaces will be transformed to gibberish, leaving the spaces intact.