A Comprehensive Guide to Getting String Size in Bytes in C

Basic Concepts of String Length and Byte Size

In C programming, strings are character arrays terminated by a null character \0. Obtaining the byte size of a string requires distinguishing between string length and storage buffer size. String length refers to the number of characters from the start of the string to the first null character, while storage buffer size indicates the memory space allocated for storing the string.

Using the strlen Function for String Length

The strlen function is specifically designed in the standard library to obtain the length of null-terminated strings. Its prototype is defined in the <string.h> header:

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

int main() {
    char str[] = "Hello";
    size_t length = strlen(str);
    printf("String length: %zu\n", length);  // Output: 5
    return 0;
}

strlen determines the length by traversing the string until it encounters the null character, with a time complexity of O(n). Note that strlen returns the character count excluding the terminating null character. To calculate the total byte size including the null character, you need to add 1 to the return value.

Application Scenarios of the sizeof Operator

sizeof is a unary operator in C that returns the number of bytes occupied by a data type or object in memory. In string handling, the usage of sizeof depends on how the variable is declared.

Case of Static Arrays

When a string is declared as a static array, sizeof can return the entire array size:

char str[] = "Hello";
printf("Array size: %zu\n", sizeof(str));  // Output: 6 (includes \0)

In this case, sizeof(str) returns the size of the entire character array, including the terminating null character. For the string "Hello", the array size is 6 bytes (5 characters plus 1 null character).

Case of Pointer Variables

When using pointers to reference strings, sizeof behaves completely differently:

char *str_ptr = "Hello";
printf("Pointer size: %zu\n", sizeof(str_ptr));  // Output: 8 (64-bit system)

Here, sizeof(str_ptr) returns the size of the pointer variable itself, not the size of the string. On 64-bit systems, pointers typically occupy 8 bytes.

Special Cases of Dynamic Memory Allocation

For strings allocated with malloc, the situation becomes more complex:

#include <stdlib.h>

char *dynamic_str = malloc(20);
strcpy(dynamic_str, "Dynamic");
printf("Pointer size: %zu\n", sizeof(dynamic_str));  // Output: 8
printf("String length: %zu\n", strlen(dynamic_str));  // Output: 7

For dynamically allocated strings, it's impossible to obtain the actual allocated buffer size using sizeof because the compiler doesn't know how large the memory block pointed to by the pointer is. In such cases, you must manually track the allocated size.

Best Practices in Practical Applications

In actual programming, it's recommended to choose appropriate methods based on specific requirements:

• Use strlen when you need the string length (character count)
• Use sizeof when you need the total size of static arrays
• For dynamically allocated strings, you must manually maintain size information

Performance Considerations and Coding Recommendations

strlen needs to traverse the entire string until it finds the null character, with O(n) time complexity. For frequently used long strings, consider caching the length value to improve performance. Meanwhile, sizeof can determine the size at compile time with no runtime overhead.

When writing cross-platform code, be aware that pointer sizes may vary across different systems. Additionally, for strings containing multi-byte characters (such as UTF-8 encoding), strlen returns the byte count rather than the character count, which requires special attention when handling internationalized strings.