Blog / Home
About
Media Gallery

Welcome
to
Thronic.com

ժʝ_

C Strings


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);



Original Post: Jan 27th, '22 18:53 CET.

C/C++
π