Print ASCII table

Task 1: Print out the basic ASCII table. That is, for each integer from 1 to 127, print both the integer representation (like 65) and the character representation (like 'A'). You can work in hello.c for this task.

You can print the table by representing the same value/variable as both an int and a char in printf (use both the %d and %c directives in the string but use the same value for each). Here's a brief example that uses printf:

char *name = "Joe Schmoe";
char letter = 'T';
int age = 4;
printf("Hi! My name is %s and I am %d years old! My favorite letter is %c \n",
       name, age, letter);

With the output:

Hi! My name is Joe Schmoe and I am 4 years old! My favorite letter is T

Working with pointers and strings

Strings in C are an interesting example because they can be viewed as arrays of characters or pointers to characters (variables that hold the location, address in memory, of a character). In our first example we're going to create a function that computes the length of a string. Note that there are no native operations in C that handle entire string objects as a whole, all operations must be built out of smaller operations on individual characters. There is no string class/type in C. When we say "string", we mean a pointer to an array of characters with a specific format.

char *str = "Hello";

The variable str will store a single pointer (memory address), that points only to the first character 'H':

        +----+----+---+---+---+---+---+----+----+----+
Memory: | .. | .. | H | e | l | l | o | \0 | .. | .. |
        +----+----+---+---+---+---+---+----+----+----+
                    ^
                   str

Notice the '\0' after the 'o'. This character, which is called the NUL terminator, is used to mark the end of the string. Functions that work on strings use the NUL terminator to know when to stop.

Strings in C can be viewed both as pointers to characters, which makes sense given the type, and as arrays of characters. The expressions for reading a character from a string are different depending on which way you want to think about it.

Let's look at the pointer version first. Given the variable str declared above, the expression *str will return the value 'H', because the value of str is the address of the first character of the string and the * operator, which expects an address as an operand, returns the value stored at that address. To get the ith element of str, you can use the expression *(str+i). The expression (str+i) takes the value of str, which is an address, and adds enough bytes to get the address of the ith character. Once we have that address, applying the * operator yields its contents, that is, the ith character.

The array version is, in some ways, more straightforward. Given the variable str, the expression str[0] will yield the first character in the string and the expression str[i] will yield the ith character.

Let's combine these ideas to compute the length of a string. Here is a version of mystrlen that uses the array notation:

int mystrlen(char *s) {
    int i = 0;
    int len = 0;
    while (s[i] != '\0') {
      len++;
      i++;
    }
    return len;
}

Here is a pointer version that is a direct translation of the array version:

int mystrlen(char *s) {
    int i = 0;
    int len = 0;
    while (*(s+i) != '\0') {
      len++;
      i++;
    }
    return len;
}

Notice that the only difference between the two is in the way s is used in the loop test. Finally, here is a version that a practiced C programmer would likely write:

int mystrlen(char *s) {
    int len = 0;
    while (*s != '\0') {
      len++;
      s++;
    }
    return len;
}

This version eliminates the use of the index variable i in favor of incrementing s by one character for each iteration of the loop. Note that by incrementing s, we no longer have access to the start of the string in mystrlen, which is fine in this case, but can cause problems in others.

Malloc

In the next task, you will need to allocate space for a new string. The library function malloc is used to allocate space. It takes a number of bytes as an argument, allocates the requested number of bytes, and returns a pointer of type void * (a generic pointer) to the first byte. Here is an example call:

char *s = (char *) malloc(sizeof(char) * N);

This statement calls malloc to allocate enough space for N characters, where N is some variable, casts the resulting pointer from the generic void * to the desired char *, and initializes s to refer to the allocated space.

Follow the pattern above when you need to allocate space for this lab.

String concatenation

Task 2: Your task in this section is to create a function that concatenates/adds two strings together. It should have the following header:

char *mystrcat(char *A, char *B) // strcat for string concatenation

It takes in two string inputs, and returns the concatenation of those same strings. The call mystrcat("Hello", "World") should return "HelloWorld". Note that the naive solution:

char *output = A + B; // This code does not work

does not work. This statement will only create a third pointer to some bizarre location in memory that is the addition of the two locations A and B (pointers are just numeric locations in memory).

Instead you need to recognize that A and B point to locations in memory, as illustrated above for str. You will need to allocate space to hold the new string.

In this particular case you would need to allocate space for 5+5+1 == 11 characters and fill that space with:

{'H', 'e', 'l', 'l', 'o', 'W', 'o', 'r', 'l', 'd', '\0'}

You will need to transfer each letter individually, add a terminator at the end and then finally return the pointer to the beginning 'H'.

First you will need to determine the length of the two strings. Then, you will need to allocate enough space to hold the addition of the two strings plus a terminating character (using malloc). Then, copy the characters in the first string. Then copy the characters in the second string. Then you will need to write a terminator character '\0' and finally return the pointer to the beginning of the result string.

Including the header file, string.h, will get you access to a library of string functions. For your purposes today, the function strlen, which takes a string and returns the number of characters in the string, will be useful. For example, strlen("Hello") will return 5. Note that the representation for the string "Hello" actually takes 6 characters: five for the characters of Hello and one for the NUL terminator. A very common bug is to forget to allocate space for the NUL terminator in the string.

The file mystrcat.c contains a skeleton for your implementation of mystrcat along with some test code.

Caesar Cipher

Task 3: Your task in this section is to write functions implementing a Caesar Cipher. The Caesar Cipher is a rudimentary encryption scheme whereby each letter is shifted by a constant up or down. For example we could move the word "Hop" up by one to "Ipq" H->I, o->p, p->q. This method was invented (they say) by Julius Caesar and was used in communication with his generals. It is not recommended for use today as it is very easy to crack.

To write this easily we'll take advantage of characters' numerical representation in the ASCII format, 'A' = 65, 'B' = 66, 'C' = 67, etc. Because characters are the same as one-byteintegers we can abuse the type system and type 'A'+2 to obtain 'C'.

We have included a file caesar.c in lab4 that contains skeletons for some of the functions you will write in this part of the lab along with some test code.

bool is_upper(char c)
bool is_lower(char c)

bool is_letter(char c) {
    return is_upper(c) || is_lower(c);
}

char *teststring = "Testing both UPPER and lower case letters, as well as punctuation.\n";

teststring = strdup(teststring); // duplicate teststring dynamically

char *message = strdup("Hello World!");
printf("message    : %s\n", message);
encryptinplace(message, 5); // this changes message
printf("ciphertext : %s\n", message);

char *message = strdup("Hello World!");
printf("message    : %s\n", message);
char *ciphertext = encryptnewmemory(message, 5);
printf("ciphertext : %s\n", ciphertext);

int length = 10;
double *A = (double *)malloc(length * sizeof(double));

// do stuff with A
A[0] = 10.5;
A[1] = 0.124;

// finished with A
free(A);