In C++, strings can be managed in different ways depending on the use case, and there are several types of strings available. The two main types are C-style strings (inherited from C) and std::string (from the C++ Standard Library).

What is a literal string & char array in C? - Stack Overflow

C-Style Strings (Null-Terminated Character Array)

In C++, a C-style string is essentially an array of characters, terminated by a null character ('\0'). This null character signifies the end of the string and is crucial for various string manipulation functions to determine the string's length.

It is contiguous sequence of characters terminated by null character.

Unlike std::string in C++, C-style strings are simple arrays and do not automatically manage their size or memory. They require explicit handling when working with them.

• These are inherited from the C programming language and are simply arrays of characters terminated by a null character ('\0'). They are usually used in performance-critical applications, but managing them manually can be error-prone.

#include <iostream>

int main() {
    // Declaration and initialization of a C-style string
    char classicString[] = "Hello, C-Style String!";
    
    // Printing the string
    std::cout << classicString << std::endl;

    return 0;
}

// Output
Hello, C-Style String!

In this example, classicString is a C-style string, initialized with the content “Hello, C-Style String!” The compiler automatically appends the null character at the end.

Declaring and Initializing C-Style String:

There are different methods of initializing a string in C.

1️⃣ Character-by-Character Initialization

1 Character-by-Character Initialization with Size:

When you initialize a character array character by character, you explicitly specify the size of the array. This approach gives you complete control over the memory allocation and the initial values of each element.

Example:

#include <stdio.h>

int main() {
    char str[6] = {'H', 'e', 'l', 'l', 'o', '\0'};  // Size is explicitly defined

    printf("String: %s\n", str);  // Output: Hello

    return 0;
}

Explanation:

• The array str is explicitly sized to 6, which includes space for 5 characters plus the null terminator '\0'.
• Each character and the null terminator are manually set, ensuring that the string is correctly null-terminated.

Key Points:

• Size Management: You have control over the array size and must ensure it is sufficient to hold the characters and the null terminator.
• Explicit Null Termination: The null terminator must be manually added to indicate the end of the string.
• Flexibility: You can initialize part of the array and leave the rest for future use, but you need to manage the size carefully.

More Example:

#include <stdio.h>

int main() {
    char str[10] = {'H', 'e', 'l', 'l', 'o', '\0'};  // Size explicitly set to 10

    printf("String: %s\n", str);  // Output: Hello
    
    // Additional characters in the array (index 6 to 9) will be uninitialized or zero.
    return 0;
}

// Output
String: Hello

• Control: You have control over the total size of the array.
• Flexibility: You can reserve extra space for future use.

2 Character-by-Character Initialization without Size:

When initializing a character array character by character without specifying the size, the compiler automatically determines the size based on the number of initialized characters plus the null terminator.

Example:

#include <stdio.h>

int main() {
    char str[] = {'H', 'e', 'l', 'l', 'o', '\0'};  // Size is automatically determined

    printf("String: %s\n", str);  // Output: Hello

    return 0;
}

Explanation:

• The array str is initialized with exactly 6 characters, including the null terminator.
• The size of the array is automatically set to 6 by the compiler based on the initializer.

Key Points:

• Automatic Size Calculation: The size of the array is determined automatically by the compiler based on the number of elements in the initializer.
• Simpler Syntax: You don't need to specify the size of the array manually, which simplifies initialization.
• Exact Size: The array size matches exactly the number of initialized elements plus the null terminator.

More Example:

#include <stdio.h>

int main() {
    char str[] = {'H', 'e', 'l', 'l', 'o', '\0'};  // Size automatically determined

    printf("String: %s\n", str);  // Output: Hello
    
    return 0;
}

// Output
String: Hello

• Simplicity: Size management is handled by the compiler.
• Exact Fit: The array size fits exactly the characters you initialize plus the null terminator.

Comparison of the Two Methods:

What would happen if we omit the null character in character array?

The declaration char str[] = {'h', 'e', 'l', 'l', 'o'}; is technically valid, but it doesn't include the null terminator '\0' at the end. Without the null terminator, the array str is not considered a C-style string. So, if you try to treat str as a string and use it with functions that expect null-terminated strings, you may encounter undefined behavior.

Example:

#include <iostream>

int main() {
    char strWithNullChar[] = {'h', 'e', 'l', 'l', 'o', '\0'};
    char strWithoutNullChar[] = {'h', 'e', 'l', 'l', 'o'};
    std::cout << "Str with null character = "<< strWithNullChar<< std::endl;
    std::cout << "Str without null character = "<< strWithoutNullChar<< std::endl;
    return 0;
}

// Output
Str with null character = hello
Str without null character = hellohello

In this example, we're attempting to output the character array strWithoutNullChar as a string using std::cout. However, since strWithoutNullChar doesn't have a null terminator, std::cout will continue reading memory beyond the last character, searching for the null terminator to determine the end of the string. This behavior leads to undefined behavior and may cause the program to crash or produce unexpected output.

• Prints the content of strWithNullChar using std::cout. Since strWithNullChar contains a null terminator, std::cout will print the entire string "hello" correctly.
• Prints the content of strWithoutNullChar using std::cout. However, since strWithoutNullChar lacks a null terminator, std::cout may continue reading characters from memory until it encounters a null terminator elsewhere in memory, leading to unexpected output or undefined behavior.

Solution:

To solve this we can do two things:

1 Add a Null Terminator:  Ensure that the character array is null-terminated by adding a '\0' at the end of the array explicitly.

char strWithoutNullChar[] = {'h', 'e', 'l', 'l', 'o', '\0'};

2 Specify Array Size Explicitly: Declare the size of the character array with an extra space for the null terminator.

char strWithoutNullChar[6] = {'h', 'e', 'l', 'l', 'o'};

2️⃣ String Literal Initialization

The simplest way to initialize a string is by using a string literal. This method adds the null terminator ('\0') automatically.

1 String Literal without Size:

When you initialize a string literal without specifying the size, the compiler automatically calculates the size of the array based on the length of the string, plus one for the null terminator. This approach is simpler and eliminates the need to manage array size manually.

char str[] = "Hello";

• str is a C-style string stored as an array of characters in modifiable memory.
• Here, you can modify the contents of str since it's stored in writable memory.
• The compiler automatically determines the size of the array based on the length of the string (in this case, 6 including the null character).
• This is concise and avoids explicitly adding the null terminator.

Example:

#include <stdio.h>

int main() {
    char str[] = "Hello";  // Size automatically determined as 6 (5 + 1 for '\0')

    printf("String: %s\n", str);  // Output: Hello
    
    return 0;
}

• Explanation:
  • The size of the array str is automatically set to 6 because the string "Hello" has 5 characters, and the null terminator '\0' is automatically added as the 6th element.
  • You don’t need to manually manage the size, and the string fits exactly in the allocated array.

Under the Hood:

char str[] = "Hello";

Internally, this string is represented as:

{'H', 'e', 'l', 'l', 'o', '\0'}

Here, '\0' is the null character that marks the end of the string.

2 String Literal with Size:

When you declare a character array with an explicitly defined size and assign a string literal to it, the size of the array must be large enough to hold the string, including the null terminator ('\0'). If the specified size is larger than the string, the remaining elements are filled with undefined (or garbage) values. If the size is smaller than the string (or exactly the same), any extra characters will be discarded, and the result may be undefined behavior.

char str[6] = "Hello";

Explanation:

• The size of the array str is explicitly set to 6.
• The string "Hello" is 5 characters long, and the 6th character is the null terminator '\0', which is automatically added.
• If you try to initialize a longer string (e.g., "Hello!") in this array, it will result in buffer overflow.

Example:

#include <stdio.h>

int main() {
    char str[10] = "Hello";  // Size explicitly set to 10

    printf("String: %s\n", str);  // Output: Hello
    
    // Index 5 contains the '\0' null terminator
    // The remaining elements in the array (index 6 to 9) are uninitialized.
    return 0;
}

• Explanation:
  • The size of the array str is explicitly set to 10, but the string "Hello" is only 5 characters long.
  • The null terminator '\0' is automatically added by the compiler at index 5.
  • The remaining positions in the array (index 6 to 9) are uninitialized and could contain garbage values unless explicitly initialized.

Key Differences Between the Two Methods

3️⃣ Using a Pointer to a String Literal

You can declare a pointer to a string literal. However, string literals are stored in a read-only section of memory, so modifying the string through the pointer can lead to undefined behavior.

Example:

char *str = "Hello";

• str points to the memory location of the string "Hello", which is stored in read-only memory.
• You should not modify the string through the pointer. For example, doing str[0] = 'h'; may cause a segmentation fault.

Pointer to a character points to the memory address where a character or a sequence of characters is stored.

There are two prevalent ways for it:

1. char* str = "hello";:
   1. Declares a non-const pointer str to a string literal "hello".
      The string literal "hello" resides in read-only memory, and attempting to modify it through str results in undefined behavior.
   2. However, you can modify str itself to point to another memory location.
2. const char* str = "hello";:
   1. Declares a pointer str to a string literal "hello" with the const qualifier.
   2. The const qualifier indicates that the data pointed to by str is constant and cannot be modified.
   3. While you cannot modify the string data through str, you can modify str itself to point to another memory location.
   4. This declaration is preferable when you do not intend to modify the string data and want to enforce const-correctness.

Why char* str = “hello” is read-only?

When you declare char* str = "hello";, the string literal "hello" is typically stored in a read-only section of memory, often referred to as the "text" or "code" segment. This segment contains the executable code as well as static data, such as string literals.

Here's how it works:

1. String Literal Storage:
   1. When you write "hello", it creates a null-terminated character array containing the characters 'h', 'e', 'l', 'l', 'o', and the null character '\0'.
   2. This character array is stored in a read-only section of memory by the compiler.
   3. The exact location and mechanism of storage depend on the compiler and linker settings, but it's typically in a section of memory that's not writable at runtime.
2. Pointer Assignment:
   1. The pointer str is then assigned to point to the memory address where the string literal "hello" is stored.
   2. Since str is a non-const pointer (char*), it can be used to modify the characters it points to, but attempting to modify the characters of a string literal is undefined behavior.
   3. Since the pointer points to read-only memory, any attempt to modify the string (e.g., str[0] = 'h';) results in undefined behavior. Typically, this will cause a segmentation fault or access violation, depending on the system, because the program is trying to write to a memory location that is marked as non-writable.

   4. // Example of invalid modification:
      
      char *str = "Hello";
      str[0] = 'h';  // Undefined behavior, likely to cause a segmentation fault

3. Const Qualifier:

   1. To make this clearer to the programmer and prevent accidental modifications, the string literal should ideally be declared with the const keyword.

      const char *str = "Hello";
      

   2. This ensures that the compiler will throw an error if you try to modify the string, making it clear that the string is read-only.
   3. Without const, the compiler allows the code but does not prevent runtime errors like segmentation faults. Thus, const is a best practice for safety when working with string literals.
4. Arrays vs Pointers:

   1. In contrast, if you declare a character array and initialize it with a string literal, the array is stored in writable memory (usually the stack or heap). You can modify the contents of the array, but this is not the case with pointers to string literals.

      Example of a writable string:

      char str[] = "Hello";
      str[0] = 'h';  // Valid modification since str is an array and stored in writable memory
      

5. Memory Layout:
   1. At runtime, the program's memory layout typically consists of several sections, including the text (code) segment, data segment, heap, and stack.
   2. The string literal "hello" resides in the text segment, which is read-only, while the pointer variable str itself resides in either the data segment (if it's a global variable) or the stack (if it's a local variable).

Text Segment:
-------------------
|  "hello\0"      |   <-- Stored as a string literal, read-only
-------------------

Data Segment:
-------------------
|   str (pointer) |   <-- Pointer variable pointing to the string literal
-------------------

Stack (if `str` is a local variable):
-------------------
|       ...       |   
|   str (pointer)|   <-- Pointer variable resides on the stack
|       ...       |
-------------------

const char*  over char*:

1. Prevents Modification of String Literals: String literals like "hello" are stored in read-only memory. Declaring a pointer as const char* ensures that you cannot inadvertently modify the contents of the string literal through that pointer. Attempting to modify a string literal through a const char* pointer will result in a compilation error, preventing potential runtime errors and undefined behavior.
2. Expresses Intent: Using const char* communicates to other programmers that the data being pointed to should not be modified. It makes the code more self-documenting and helps prevent accidental modifications by enforcing immutability.
3. Safety: By preventing modification of string literals, const char* pointers enhance code safety and prevent subtle bugs that can arise from inadvertently modifying immutable data.
4. Enforces Good Practices: Using const char* encourages good programming practices by discouraging direct manipulation of string literals, which can lead to hard-to-find bugs and maintenance issues.

4️⃣ Dynamic Memory Allocation

You can allocate memory for a string dynamically using functions like malloc() or calloc(). This allows you to determine the size of the string at runtime.

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

int main() {
    char *str = (char *)malloc(6 * sizeof(char));  // Allocate memory for 6 characters
    strcpy(str, "Hello");  // Copy "Hello" to the dynamically allocated memory
    
    printf("%s\n", str);  // Output: Hello
    
    free(str);  // Free the dynamically allocated memory
    return 0;
}

• malloc() allocates memory dynamically, and you must explicitly copy the string into the allocated memory using strcpy().
• You must free the allocated memory after use to prevent memory leaks.

Characteristics of C-Style Strings

1. Null-Terminated

• Definition: C-style strings are terminated with a special null character ('\0'), which marks the end of the string.
• Implication: The null terminator is required for functions that operate on C-style strings to know where the string ends.

char str[] = "Hello";  // str contains {'H', 'e', 'l', 'l', 'o', '\0'}

The null character ('\0') is a sentinel value indicating the end of the string. It allows functions to traverse the string until the null character is encountered.

2. Array of Characters

• Definition: A C-style string is essentially an array of char elements, where each element stores one character.
• Implication: You can access and manipulate each character individually using array indexing or pointer arithmetic.

char str[] = {'H', 'e', 'l', 'l', 'o', '\0'};
printf("%c\n", str[0]);  // Outputs 'H'

3 Fixed Size (For Arrays):

• Definition: C-style strings, when declared as arrays, have a fixed size defined at compile-time. If the string exceeds this size, you risk buffer overflows.
• Implication: You need to ensure that the array is large enough to store the string and the null terminator, and handle the size manually.

char str[6] = "Hello";  // Correct (size includes null terminator)

C-Style strings have a fixed size determined by the length of the character array. This characteristics require careful consideration to avoid buffer overflows.

4. Manual Memory Management

• Definition: Memory for C-style strings must be managed manually, especially when allocated dynamically using malloc(), calloc(), or realloc().
• Implication: You must ensure that memory is properly allocated and freed to avoid memory leaks or corruption.

char *str = (char *)malloc(20 * sizeof(char));  // Dynamically allocated string
strcpy(str, "Hello");
free(str);  // Free allocated memory

5. Prone to Buffer Overflow

• Definition: Since C-style strings are simple arrays of characters, there is no automatic bounds checking. Writing beyond the allocated array size leads to buffer overflows.
• Implication: You must take care when copying or manipulating strings to avoid writing past the allocated memory.

char str[5];
strcpy(str, "Hello, World!");  // Buffer overflow (string exceeds allocated size)

6. No Built-in Length Information:

• Definition: C-style strings do not store their length. You must compute the length using functions like strlen().
• Implication: Calculating the length requires iterating through the string until the null terminator is found, adding overhead in some operations.

int len = strlen("Hello");  // Returns 5 (number of characters before '\0')

You can also create your own strlen function, just iterate through the character array till you encounter the \0 (null terminator) and in each iteration increment the length variable.

7. No Automatic Resizing

• Definition: C-style strings do not automatically grow in size if you attempt to append more data than they can hold.
• Implication: You must manually reallocate memory when necessary to accommodate longer strings.

char *str = (char *)malloc(5 * sizeof(char));  // Allocate memory for 5 characters
strcpy(str, "Hello");
str = (char *)realloc(str, 10 * sizeof(char));  // Reallocate memory for a longer string

8. Standard Library Functions

• Definition: Many functions are available in the C Standard Library (from <string.h> in C or <cstring> in C++) to manipulate C-style strings.
• Implication: You can perform operations such as copying, concatenating, comparing, and finding the length of strings using these functions (strcpy, strcat, strcmp, strlen, etc.).

char str1[20] = "Hello";
char str2[] = " World";
strcat(str1, str2);  // Concatenates str2 onto str1

9. Immutable String Literals

• Definition: C-style string literals are stored in read-only memory and cannot be modified. Attempting to modify a string literal leads to undefined behavior.
• Implication: While you can assign string literals to const char*, modifying them is not allowed.

const char *str = "Hello";
// str[0] = 'h';  // This would result in undefined behavior

10. Supports Pointers for Flexibility

• Definition: C-style strings can be handled using pointers, which provides flexibility in manipulating strings via pointer arithmetic.
• Implication: You can pass C-style strings to functions using pointers, and pointers make it easier to iterate through strings and perform advanced operations.

void printString(char *str) {
    while (*str != '\0') {
        printf("%c", *str);
        str++;  // Move pointer to the next character
    }
}

11. No Rich String Features

• Definition: C-style strings do not support high-level operations like string concatenation, trimming, or searching without additional functions or libraries.
• Implication: String manipulation is often done manually or using library functions, which makes C-style strings less convenient for complex string operations compared to modern C++ strings (std::string).

String Manipulation with C-Style Strings

strlen: String Length

The strlen function calculates the length of a C-style string by counting characters until the null character is encountered. It excludes the null character while counting.

#include <cstring>
#include <iostream>

int main() {
    const char classicString[] = "Hello, C-Style String!";
    
    // Calculate the length of the string
    size_t length = strlen(classicString);

    // Printing the length
    std::cout << "Length of the string: " << length << std::endl;

    return 0;
}

// Output
Length of the string: 22

strcpy and strcat: Copying and Concatenation

The strcpy function copies one C-style string to another while strcat concatenates (appends) two strings.

#include <cstring>

int main() {
    const char source[] = "Hello, ";
    const char destination[20];  // Ensure sufficient space
    
    // Copy one string to another
    strcpy(destination, source);

    // Concatenate two strings
    strcat(destination, "World!");

    // Printing the result
    std::cout << destination << std::endl;

    return 0;
}

strncpy and strncat: Bounded Copy and Concatenation

To mitigate the risk of buffer overflows, C provides functions like strncpy and strncat that allows you to specify the maximum number of characters to copy or concatenate.

#include <iostream>
#include <cstring>

int main() {
    const char source[] = "Hello, ";
    const char destination[20];  // Ensure sufficient space
    
    // Copy a limited number of characters
    strncpy(destination, source, sizeof(destination) - 1);
    destination[sizeof(destination) - 1] = '\0';  // Ensure null termination

    // Concatenate a limited number of characters
    strncat(destination, "World!", sizeof(destination) - strlen(destination) - 1);

    // Printing the result
    std::cout << destination << std::endl;

    return 0;
}

strcmp: String Comparison

The strcmp function compares two C-style strings lexicographically.

#include <cstring>

int main() {
    const char string1[] = "apple";
    const char string2[] = "banana";

    // Compare two strings
    int result = strcmp(string1, string2);

    // Printing the result
    std::cout << "Comparison result: " << result << std::endl;

    return 0;
}

// Output
Comparison result: -1

strncmp - String Compare (with Limit)

Compares a specified number of characters of two C-style string.

#include <iostream>
#include <cstring>

int main() {
    const char string1[] = "apple";
    const char string2[] = "applet";

    // Compare first 4 characters of two strings
    int result = strncmp(string1, string2, 4);

    // Printing the result
    std::cout << "Comparison result: " << result << std::endl;

    return 0;
}

// Output
Comparison result = 0

strstr String Search

Locates the first occurrence of a substring within a C-style string.

#include <iostream>
#include <cstring>

int main() {
    const char haystack[] = "Find the needle in the haystack.";
    const char needle[] = "needle";

    // Using strstr to find a substring
    const char* result = strstr(haystack, needle);

    // Printing the result
    if (result) {
        std::cout << "Found at position: " << result - haystack << std::endl;
    } else {
        std::cout << "Not found." << std::endl;
    }

    return 0;
}

Tokenization with strtok

The strtok function allows you to tokenize a C-style string by splitting it into substrings based on a specified delimiter.

#include <iostream>
#include <cstring>

int main() {
    char sentence[] = "This is a sample sentence.";

    // Tokenize the sentence
    char* token = strtok(sentence, " ");

    // Print each token
    while (token != nullptr) {
        std::cout << token << std::endl;
        token = strtok(nullptr, " ");
    }

    return 0;
}

// output
This
is
a
sample
sentence.

String Conversion with atoi and atof

When dealing with C-style strings representing numeric values, the atoi (ASCII to Integer) and atof (ASCII to Floating-Point) functions come in handy for conversion.

#include <iostream>
#include <cstdlib>

int main() {
    const char* numericString = "123";
    
    // Convert C-style string to integer
    int intValue = atoi(numericString);

    // Convert C-style string to floating-point
    double doubleValue = atof(numericString);

    // Printing the results
    std::cout << "Integer Value: " << intValue << std::endl;
    std::cout << "Double Value: " << doubleValue << std::endl;

    return 0;
}

// Output
Integer Value: 123
Double Value: 123

Pros of C-Style Strings:

1. Efficiency and Low-Level Control

• Direct Memory Access: C-style strings give you direct control over memory, which can be useful in systems programming or embedded applications where every byte counts.
• No Overhead: C-style strings are just arrays of characters. There's no extra overhead from dynamic memory management, object encapsulation, or additional metadata.
• Performance: Since there's no added complexity, C-style strings can be faster in certain contexts, especially when handling small, fixed-size strings. Functions like strlen() and strcpy() work directly on the memory without additional layers of abstraction.

2. Compatibility with Legacy Code

• Widely Supported: C-style strings are the standard string representation in C, so they are universally supported by legacy C code and many libraries.
• Interoperability: They can be easily used with APIs and libraries that expect C-style strings, especially in lower-level programming or cross-platform projects.

3. Fine-Grained Control Over Memory

• Static or Dynamic Allocation: C-style strings allow you to allocate memory either statically (at compile time) or dynamically (at runtime) using malloc() or calloc(). You can precisely control the size and layout of memory, making it useful for memory-constrained environments.

4. Simple and Minimal

• No Added Complexity: C-style strings are minimal and don't have complex methods or internal states, making them straightforward in simple cases. You just work with arrays and pointers.

Cons of C-Style Strings:

1. Manual Memory Management

• Error-Prone: Memory management is manual, so you need to carefully allocate, deallocate, and ensure strings are properly null-terminated. Forgetting to free memory allocated by malloc() leads to memory leaks.

• Buffer Overflow Risks: C-style strings are prone to buffer overflows if you write beyond the bounds of the allocated array. For example, copying a string longer than the destination array can corrupt memory and cause security vulnerabilities.

  Example of unsafe code leading to buffer overflow:

  char str[5];
  strcpy(str, "Hello");  // Buffer overflow, "Hello" requires 6 bytes (including '\0')
  

2. Lack of Built-In Safety

• No Automatic Bounds Checking: There is no bounds checking when working with C-style strings. Functions like strcpy and strcat can easily cause buffer overflows if the destination array is not large enough.

• No Automatic Memory Management: Unlike modern C++ strings (std::string), C-style strings don’t automatically grow in size or release memory when they go out of scope, leading to potential memory leaks or dangling pointers if not handled properly.

  Example:

  char *str = (char *)malloc(20 * sizeof(char));
  strcpy(str, "Hello");
  free(str);  // Must be manually freed to avoid memory leaks
  

3. Lack of Modern Features

• No Rich Functionality: C-style strings lack the rich methods available in higher-level string classes like std::string, such as concatenation, comparison, searching, and manipulation. All of these must be done manually or by using C library functions like strcat, strcmp, etc.

  Example of tedious string concatenation:

  char str1[20] = "Hello";
  char str2[] = ", World!";
  strcat(str1, str2);  // Requires manual concatenation
  

4. Unsafe Modifications

• Modifying String Literals: C-style strings can be declared as pointers to string literals. However, modifying string literals is undefined behavior because they are stored in read-only memory.

  Example:

  char *str = "Hello";
  str[0] = 'h';  // Undefined behavior, potential crash
  

5. Complex Handling of Dynamic Strings

• Dynamic Resizing is Difficult: Changing the size of a dynamically allocated C-style string requires manual memory reallocation and copying the contents to the new memory block.

  Example:

  char *str = (char *)malloc(5 * sizeof(char));  // Initially allocated memory
  strcpy(str, "Hello");
  str = (char *)realloc(str, 10 * sizeof(char));  // Manually reallocating memory
  strcat(str, " World");
  

• Manual String Manipulation: Tasks like concatenation, copying, or appending require manual memory management and function calls (strcpy, strcat, etc.), increasing the chance for bugs or errors.

6. Limited Internationalization Support

• No Native Unicode Handling: C-style strings, being simple arrays of char, do not natively support wide characters (Unicode) or multibyte character encodings. If internationalization is needed, you would have to manually deal with wchar_t, UTF-8, or multibyte characters.

7. Less Readable and Less Expressive

• Tedious to Work With: Operations such as copying, comparing, or concatenating strings are more verbose and error-prone than modern C++ string methods. Managing C-style strings often leads to lower code readability, and the programmer has to be more cautious about memory.

Dynamic Memory Allocation

While C-style strings have a fixed size, dynamic memory allocation can be used to create strings of variable length. This involves using functions like malloc and free for memory management.

#include <iostream>
#include <cstring>
#include <cstdlib>

int main() {
    const char* source = "Dynamic C-Style String";
    
    // Allocate memory for the string
    char* dynamicString = (char*)malloc(strlen(source) + 1);

    // Copy the source string to the dynamically allocated memory
    strcpy(dynamicString, source);

    // Printing the result
    std::cout << dynamicString << std::endl;

    // Free the allocated memory
    free(dynamicString);

    return 0;
}

Standard String vs C-Style String (Character Array)

Although both help us store data in text form, strings, and character arrays have a lot of differences. Both of them have different use cases. C++ strings are more commonly used because they can be used with standard operators while character arrays can not. Let us see the other differences between the two.

Passing C-Style Strings to Functions:

You can pass C-style strings to functions using pointers to characters (char*) or array of characters.

1️⃣ Passing C-Style Strings as Pointers

Since a C-style string is essentially a pointer to the first character in a character array, you can pass a C-style string to a function by passing a pointer to the string.

Example:

#include <stdio.h>

void printString(char *str) {
    while (*str != '\0') {  // Loop until null terminator is reached
        printf("%c", *str);
        str++;  // Move pointer to the next character
    }
    printf("\n");
}

int main() {
    char message[] = "Hello, World!";
    printString(message);  // Pass the C-style string to the function
    return 0;
}

Explanation:

• The function printString accepts a char* (pointer to a character), which points to the first character of the string.
• Inside the function, the pointer is incremented to traverse the string until the null terminator ('\0') is encountered.

2️⃣ Passing C-Style Strings as Arrays

C-style strings can also be passed as arrays. Since arrays decay into pointers when passed to functions, this is functionally equivalent to passing a pointer.

Example:

#include <stdio.h>

void printString(char str[]) {
    int i = 0;
    while (str[i] != '\0') {  // Loop until null terminator is reached
        printf("%c", str[i]);
        i++;
    }
    printf("\n");
}

int main() {
    char message[] = "Hello, World!";
    printString(message);  // Pass the array to the function
    return 0;
}

Explanation:

• The array char str[] in the function signature is treated as a pointer to the first element of the array.
• When you pass an array, you're still passing the address of the first element, just like with pointers.

OR

#include <stdio.h>

void printString(char str[]) {
    while (*str != '\0') {  // Loop until null terminator is reached
        printf("%c", *str);
        str++;
    }
    printf("\n");
}

int main() {
    char message[] = "Hello, World!";
    printString(message);  // Pass the array to the function
    return 0;
}

3️⃣ Passing Constant C-Style Strings

If you want to ensure that the string passed to a function cannot be modified, you can declare the parameter as a pointer to a const char.

Example:

#include <stdio.h>

void printString(const char *str) {  // 'const' ensures the string cannot be modified
    while (*str != '\0') {
        printf("%c", *str);
        str++;
    }
    printf("\n");
}

int main() {
    const char *message = "Hello, World!";
    printString(message);  // Pass a constant C-style string
    return 0;
}

Explanation:

• const char * ensures that the function cannot modify the string that is passed in.
• This is useful for passing string literals or ensuring immutability within the function.

If we try to modify the string, the compiler will give the error and not compile the program.

#include <stdio.h>

void printString(const char *str) {  // 'const' ensures the string cannot be modified
    while (*str != '\0') {
        *str = 'a';         // Modifying the string.
        printf("%c", *str);
        str++;
    }
    printf("\n");
}

int main() {
    const char *message = "Hello, World!";
    printString(message);  // Pass a constant C-style string
    return 0;
}

// Output

Could not execute the program
Compiler returned: 1
Compiler stderr
<source>: In function 'void printString(const char*)':
<source>:5:14: error: assignment of read-only location '* str'
    5 |         *str = 'a';
      |         ~~~~~^~~~~

4️⃣ Modifying a C-Style String in a Function

You can modify a C-style string by passing it as a pointer to char. Since the function operates on the original memory location, the changes are reflected outside the function.

Example:

#include <stdio.h>

void toUpperCase(char *str) {
    while (*str != '\0') {
        if (*str >= 'a' && *str <= 'z') {
            *str = *str - 32;  // Convert lowercase to uppercase
        }
        str++;
    }
}

int main() {
    char message[] = "Hello, World!";
    toUpperCase(message);  // Modify the original string
    printf("%s\n", message);  // Output the modified string
    return 0;
}

Explanation:

• Since C-style strings are arrays (which decay into pointers), modifications made inside the function affect the original string.
• The function toUpperCase converts lowercase characters to uppercase by modifying the string directly.

OR

#include <iostream>
#include <cstring>

void modifyString(char* str) {
    strcat(str, " Modified!");
}

int main() {
    char myString[20] = "Original";
    
    // Passing the string to a function
    modifyString(myString);

    // Printing the modified string
    std::cout << myString << std::endl;

    return 0;
}

// Output
Original Modified

Representations of C-Style Strings

1. Array of Characters:

The most basic form of a C-style string is an array of characters.

char myString[] = "Hello, C++!";

• This creates a character array with a size implicitly determined by the length of the string literal.
• The compiler automatically allocates space for 12 characters.
• You don't have to worry about adding the null terminator manually.

2. Pointer to a Constant Character:

A pointer to a constant character is often used to point to a string literal.

const char* pointerToString = "Hello, Pointer";

This is a pointer that points to the first character of a null-terminated string.

3. Pointer to a Mutable Character:

A pointer to a mutable character allows modification of the string.

char* mutablePointerToString = new char[20];  // Allocate memory
strcpy(mutablePointerToString, "Hello, Dynamic!");
// Don't forget to deallocate the memory when done:
// delete[] mutablePointerToString;

This involves dynamic memory allocation and manual management.

4. Raw String Literals:

C++11 introduced raw string literals, which makes it easier to represent string with escape characters.

const char* rawString = R"(This is a raw string literal
It can span multiple lines
without escape characters)";

This is useful for representing strings with a lot of special characters without having to escape them.

Random Examples:

#include <iostream>

using namespace std;

int main()
{
    char str[] = "hello";

    int size = sizeof(str)/sizeof(str[0]);

    cout<<"string size = "<< size<<endl;
    //using range loop
    cout<< "Print string using range based loop"<<endl;
    for(char character:str){
        cout<<character<<endl;
    }

    cout<<"Print string using for loop"<<endl;
    for(int i = 0; i< size; i++){
        cout<<str[i]<<endl;
    }
}

// Output
string size = 6
Print string using range based loop
h
e
l
l
o
Print string using for loop
h
e
l
l
o