Laboratory: Dynamic Strings.

Take a second look at the str = copystring("apple") call! The function call is followed by storing a pointer: str = .... This is the pointer pointing to the new string. It is important to observe that this is not a string assignment behind the "=" operator, the array of letters is not copied, just the pointer pointing to the array of letters is assigned to str.

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

/* Copies the string received as a parameter dynamically, and
   returns the pointer pointing to the copy. The allocated
   memory space must be released by the caller. */
char *copystring(char const *str) {
    /* calculate the length of the string */
    int length = strlen(str);

    /* allocate space, +1 for the terminating zero */
    char *newstr;
    newstr = (char*) malloc((length + 1) * sizeof(char));
    if (newstr == NULL)
        return NULL;    /* :( */

    /* copy the letters of the string, now there is enough space for that */
    strcpy(newstr, str);
    return newstr;
}


int main(void) {
    char *x;

    x = copystring("hello, dynamic word!");
    if (x != NULL) {
        printf("%s\n", x);
        free(x);
    }
    return 0;
}

Why does the function return the address of the resulting concatenated string? Because the concatenated string consumes more memory, a new memory allocation is needed, thus string x is relocated in the memory. The original string x is released (that's why x must be allocated dynamically - we need to be able to free it), and the new location is returned.

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

/* from the previous task */
char *copystring(char const *str) {
    char *newstr = (char*) malloc((strlen(str) + 1) * sizeof(char));
    strcpy(newstr, str);
    return newstr;
}


/*
 * Appends "what" to "target". "target" must be allocated
 * dynamically. Returns with the address of the appended
 * string, and releases the memory behind "target"
 * Usage: x = stringcat(x, ...).
 * The caller is responsible to call free() for the
 * resulting string.
 */
char *stringcat(char *target, char const *what) {
    int newlen = strlen(target) + strlen(what);

    char *newstr = (char*) malloc((newlen + 1) * sizeof(char));
    if (newstr == NULL) return NULL;

    strcpy(newstr, target);
    strcat(newstr, what);

    free(target);
    return newstr;
}

int main(void) {
    char *x;
    x = (char*) malloc((strlen("apple")+1) * sizeof(char));
    strcpy(x, "apple");

    x = stringcat(x, "tree");
    if (x != NULL) {
        printf("%s\n", x);    // appletree
        free(x);
    }
    return 0;
}

For simplicity, the solution below makes use of the memcpy() function. This function copies arbitrary data, in the form of memcpy(target, source, how many bytes). This functoin is useful in the task because the substring to keep does not have a terminating zero, thus strcpy is not able to move the characters to the resulting array. The terminating zero must be added to the resulting string at the end.

Instead of using memcpy(), copying the characters by a loop is just as correct.

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

/*
 * Creates a new string from "orig" consisting of characters
 * between positions start and end. The caller is responsible
 * to release the memory behind the result of the function.
 */
char *substring(char const *orig, int start, int end) {
    int orilen = strlen(orig);
    if (start < 0)
        printf(...);
		return NULL;
    if (end > orilen)
        printf(...);
		return NULL;
    int newlen = end - start;
    char *newstr = (char*) malloc((newlen + 1) * sizeof(char));
    if (newstr == NULL)
        return NULL;

    memcpy(newstr, ori + start, newlen * sizeof(char));
    newstr[newlen] = '\0';
    return newstr;
}

int main(void) {
    char *str = substring("hello, world", 3, 9);
    if (str != NULL) {
        printf("[%s]\n", str);
        free(str);
    }
    return 0;
}

Regarding function memcpy(), see the description of the solution for the previous task.

The principle of the solution is as follows:

• We copy the first part of the string to the new array with the memcpy() function. At the end of this array there is no terminating zero yet.
• Then, continuing from where we have stopped (from position start on) we copy the letters from the end of the string. The original string ends with a terminating zero, thus we can use the strcpy() for this purpose. Using strcpy() has the advanatage that it closes the resulting string with a terminating zero as well.

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

/*
 * Creates a new string containing where a substring delimited by
 * positions "start" and "end" are cut out. The caller is
 * responsible for deleting the returned array from the memory.
 */
char *cutout(char const *orig, int start, int end) {
    int orilen = strlen(orig);
    if (start < 0)
        printf(...);
		return NULL;
    if (end > orilen)
        printf(...);
		return NULL;

    int newlen = orilen - (start - end);
    char *newstr = (char*) malloc((newlen + 1) * sizeof(char));
    if (newstr == NULL)
        return NULL;

    memcpy(newstr, orig, start * sizeof(char));
    strcpy(newstr + start, orig + end);
    return newstr;
}

int main(void) {
    char *str = cutout("hello, world", 4, 8);
    if (str != NULL) {
        printf("[%s]\n", str);
        free(str);
    }
    return 0;
}

We could use the memcpy() function here, too, like in the previous exercises.

This time we provide a different approach, though. The function strncat(target, source, n) concatenates at most n characters of string source to the end of string target, and closes it with a terminating zero. The steps are as follows:

• First we put a terminating zero to the end of the new string, transforming it to an empty string.
• With the strncat() function we copy the first part (index number of characters) of the original string to the target string. The strncat takes care of the terminating zero for us.
• To the resulting string we concatenate the string to insert (called what); terminating zero will automatically be at the end.
• The last strcat() call appends the end of the original string to the end of the tartet string, and terminates it with ''.

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

/*
 * Insters "what" into "target" at position "index"
 * Returs with the dynamically allocated result string
 * The caller has to free the returned string
 */
char *insertstring(char const *orig, int index, char const *what) {
    int newlen = strlen(orig) + strlen(what);

    char *newstr = (char*) malloc((newlen + 1) * sizeof(char));
    if (newstr == NULL)
        return NULL;

    newstr[0] = '\0';
    strncat(newstr, orig, index);
    strcat(newstr, what);
    strcat(newstr, orig + index);
    return newstr;
}

int main(void) {
    char *str = insertstring("hello!", 5, ", world");
    if (str != NULL) {
        printf("[%s]\n", str);
        free(str);
    }
    return 0;
}