C Strings

By Dag, on December 30th, 2016

My notes about using C-type strings.

Static Character Arrays

/*
* The most common way of creating a string. This declaration will create a
* static sized buffer that may contain up to 50 characters, but not more.
*/
// Declaration
char szString[50];
// Initialization
/*
* This initialization will fill the array with nulls. This is only necessary
* if the array will be fed a string without a null character. A null character
* (or null terminator) is just an escaped zero '\0'. A char array does by
* default contain garbage data, which will be printed with the string unless
* it's null terminated.
*/
memset(szString, 0, sizeof(szString));

String Literals / String Constants

/*
* Another common way of creating a string. This one is static, and cannot
* be changed. The program will create this string somewhere in read-only
* memory, and only give the starting address to the pointer variable. The
* string will automatically be created with a null character at the end.
* The pointer can be given a new string at any time, but the old one will
* keep floating around in memory, and a dynamicly sized array (malloc) or
* a static char array will be best suited for strings that will change a
* lot.
*/
// Declaration and initialization
char* szString[] = "This is a string literal. "
"Also known as a string constant.";
/*
* This way of creating a string is good for when it's needed to create a
* constant string that's not going to change, like a #define, only being
* able to create it later during the program life span, conditionally.
*/

Dynamic Character Arrays

/*
* Just like static character arrays, only with dynamic sizes. Good for
* perfectionists that don't want to waste a single byte! The array will
* be declared with the function malloc(), and can be freed with free().
* Then it can be declared again, with a new size.
*/
// Declaration
char *szString;
szString = (char *)malloc(50 * sizeof(char));
// Initialization
memset(szString, 0, sizeof(szString));
// Applying a string, that you can manage like with a normal array.
strcpy(szString, "Hello world."); // Careful with buffer overruns.
// Replacing the period.
szString[11] = '!';
// Freeing memory and pointer for new use.
free(szString);