Convert String to Array

Convert String To Array in C++ (5 Programs)

IntermediateTopic: String Conversion Programs
Back

C++ Convert String to Array Program

This program helps you to learn the fundamental structure and syntax of C++ programming.

Try This Code
#include <iostream>
#include <string>
#include <vector>
#include <cstring>
using namespace std;

int main() {
    string str = "Hello";
    
    // Method 1: Using c_str() and copying
    char arr1[10];
    strcpy(arr1, str.c_str());
    
    // Method 2: Using vector of chars
    vector<char> arr2(str.begin(), str.end());
    
    // Method 3: Manual copying
    char arr3[10];
    for (int i = 0; i < str.length(); i++) {
        arr3[i] = str[i];
    }
    arr3[str.length()] = '\0';
    
    cout << "String: " << str << endl;
    cout << "Array (method 1): " << arr1 << endl;
    
    return 0;
}
Output
String: Hello
Array (method 1): Hello

Understanding Convert String to Array

This program teaches you how to convert a C++ string into a character array (C-style string) in C++. This conversion is necessary when you need to work with C functions, legacy code, or when you require the fixed-size array format. Understanding different conversion methods helps you choose the appropriate approach based on your specific needs and safety requirements.

---

1. What This Program Does

The program converts a C++ string (like "Hello") into a character array (like {'H', 'e', 'l', 'l', 'o', '\0'}). C++ strings are dynamic and managed, while character arrays are fixed-size and require manual memory management. This conversion bridges the gap between modern C++ strings and C-style character arrays.

Example:

•Input string: "Hello"
•Output array: char array containing "Hello" with null terminator

---

2. Header Files Used

1.#include <iostream>
•Provides cout and cin for input/output operations.
2.#include <string>
•Essential for using the string data type.
3.#include <vector>
•Provides vector container for dynamic arrays.
4.#include <cstring>
•Provides C-style string functions like strcpy().

---

3. Declaring Variables

The program declares:

string str = "Hello";

•string is the C++ string type that stores "Hello".
•The string contains 5 characters: 'H', 'e', 'l', 'l', 'o'.
•C++ strings automatically manage memory and include length information.

---

4. Method 1: Using c_str() and strcpy()

char arr1[10];

strcpy(arr1, str.c_str());

This is a common C-style method:

•c_str() converts C++ string to C-style string (const char*).
•strcpy() copies the C-style string into the character array.
•Requires pre-allocated array with sufficient size.

How it works:

1.str.c_str() returns a pointer to a null-terminated character array.
2.strcpy(destination, source) copies the string including the null terminator.
3.The array must be large enough to hold the string plus null terminator.

Advantages:

•Simple and familiar (C-style approach)
•Direct array access
•Compatible with C functions

Disadvantages:

•Requires manual size management
•Risk of buffer overflow if array is too small
•No automatic bounds checking
Important: The array size (10) must be at least str.length() + 1 to accommodate the null terminator.

---

5. Method 2: Using Vector

vector<char> arr2(str.begin(), str.end());

This method uses a C++ vector:

•vector is a dynamic array that automatically manages memory.
•str.begin() and str.end() are iterators pointing to the start and end of the string.
•Creates a vector containing all characters from the string.

How it works:

1.str.begin() returns iterator to first character.
2.str.end() returns iterator past the last character.
3.vector constructor copies all characters from the iterators.

Advantages:

•Automatic memory management
•Dynamic size - no need to specify size beforehand
•Safe - no buffer overflow risk
•Modern C++ approach

Disadvantages:

•Slightly more overhead than fixed arrays
•Not a true C-style array (but can access with .data())

Example:

vector<char> vec(str.begin(), str.end());

---

// Access: vec[0], vec[1], etc.
// Size: vec.size()

6. Method 3: Manual Copying

char arr3[10];

for (int i = 0; i < str.length(); i++) {

arr3[i] = str[i];

}

arr3[str.length()] = '\0';

This method manually copies each character:

•Uses a loop to copy characters one by one.
•Manually adds the null terminator at the end.
•Full control over the copying process.

How it works:

1.Loop through each character in the string.
2.Copy each character to the corresponding array position.
3.Add null terminator ('\0') at the end to make it a valid C-string.

Advantages:

•Full control over the process
•Educational - shows how copying works
•Can add custom logic during copying

Disadvantages:

•More code to write
•Easy to forget the null terminator
•Manual bounds checking required

---

7. Other Methods (Mentioned but not shown in code)

Method 4: Using copy() Algorithm

char arr4[10];

copy(str.begin(), str.end(), arr4);

arr4[str.length()] = '\0';

•Uses STL copy() algorithm.
•Copies from string iterators to array.
•Still need to add null terminator manually.
#include <algorithm>

Method 5: Using string data() Method

char* arr5 = new char[str.length() + 1];

strcpy(arr5, str.data());

•data() returns pointer to string's internal array.
•Requires dynamic allocation.
•Must manually manage memory (delete[]).

---

// Remember to delete[] arr5 when done

8. Displaying Results

The program prints:

Output:

String: Hello
Array (method 1): Hello

The array is printed as a C-string, which automatically stops at the null terminator.

---

cout << "String: " << str << endl;
cout << "Array (method 1): " << arr1 << endl;

9. Important Considerations

Null Terminator

:

•C-style strings must end with '\0' (null terminator).
•Without it, string functions won't know where the string ends.
•Always ensure array size is at least length + 1.

Buffer Size

:

•Array must be large enough: size >= string.length() + 1.
•Buffer overflow occurs if array is too small.
•Use str.length() + 1 to calculate required size.

Memory Management

:

•Fixed arrays: Automatic (stack-allocated).
•Dynamic arrays: Manual (must delete[]).
•Vectors: Automatic (handled by vector).

---

10. When to Use Each Method

-

c_str() + strcpy()

: When you need a fixed-size C-style array and know the maximum size.

-

Vector

: When you need dynamic size or want automatic memory management (recommended).

-

Manual Copying

: When you need custom logic during copying or want to understand the process.

-

copy() Algorithm

: When you prefer STL algorithms and want clean code.

-

data() Method

: When you need direct access to string's internal buffer (advanced use).

Best Practice

: Use vector for most cases - it's safe and modern. Use fixed arrays only when size is known and fixed.

---

11. Safety Considerations

Buffer Overflow Prevention

:

•Always check string length before copying.
•Ensure array size is sufficient.
•Consider using strncpy() with size limit for safer copying.

Example with Safety Check

:

const int MAX_SIZE = 10;

if (str.length() < MAX_SIZE) {

strcpy(arr, str.c_str());

} else {

}

    // Handle error - string too long

Modern Alternative

:

•Prefer vector or use strncpy() with size limits.
•Consider using string instead of char arrays when possible.

---

12. Accessing Array Elements

After conversion, access characters like a normal array:

char arr[10];

strcpy(arr, str.c_str());

char first = arr[0]; // 'H'

char second = arr[1]; // 'e'

// Iterate through array

for (int i = 0; arr[i] != '\0'; i++) {

cout << arr[i];

}

---

// Access individual characters

13. return 0;

This ends the program successfully.

---

Summary

•Converting strings to character arrays bridges C++ strings and C-style strings.
•c_str() + strcpy() is the traditional C-style method - simple but requires size management.
•Vector provides modern, safe alternative with automatic memory management.
•Manual copying gives full control but requires more code and careful null terminator handling.
•Always ensure sufficient array size (length + 1) to prevent buffer overflow.
•Consider using vector for safety, or fixed arrays when size is known and performance is critical.
•Null terminator is essential for C-style strings to work correctly.

This program is essential for beginners learning how to work with both C++ strings and C-style character arrays, understanding memory management, and choosing the right approach for different scenarios in C++ programs.

Let us now understand every line and the components of the above program.

Note: To write and run C++ programs, you need to set up the local environment on your computer. Refer to the complete article Setting up C++ Development Environment. If you do not want to set up the local environment on your computer, you can also use online IDE to write and run your C++ programs.

Practical Learning Notes for Convert String to Array

This C++ program is part of the "String Conversion Programs" topic and is designed to help you build real problem-solving confidence, not just memorize syntax. Start by understanding the goal of the program in plain language, then trace the logic line by line with a custom input of your own. Once you can predict the output before running the code, your understanding becomes much stronger.

A reliable practice pattern is to run the original version first, then modify only one condition or variable at a time. Observe how that single change affects control flow and output. This deliberate style helps you understand loops, conditions, and data movement much faster than copying full solutions repeatedly.

For interview preparation, explain this solution in three layers: the high-level approach, the step-by-step execution, and the time-space tradeoff. If you can teach these three layers clearly, you are ready to solve close variations of this problem under time pressure.

Next
Convert Array to String
Previous
Convert Double to Int
Next
Convert Array to String

Table of Contents