Code360 powered by Coding Ninjas X Code360 powered by Coding Ninjas X
Table of contents
Char*: The Raw Character Array
Std::string: The String Class
Char[]: Fixed Size Character Array
Frequently Asked Questions 
What is char[] in C++?
When should I use char*?
Which one is more memory-efficient, std::string or char[]?
Last Updated: Mar 27, 2024

Differences Between C++ Char*, std:string, and Char[]

Author Arya Singh
0 upvote
Master Python: Predicting weather forecasts
Ashwin Goyal
Product Manager @


Understanding the distinctions among char, std::string, and char arrays in C++ is pivotal for crafting efficient code. Char* is a pointer to characters, often utilized in legacy scenarios. Meanwhile, std::string, a library class, offers safer manipulation, automatic memory handling, and versatile functions. 

Differences Between Cpp Char*, std:string, and Char[]

On the other hand, char arrays (char[]) are primary character sequences requiring manual memory management. Discerning their merits and use cases allows you to optimize your C++ code for improved clarity and performance, ensuring a seamless coding experience. This article provides a comparison and examples to help you write cleaner, more efficient C++ code. 

Char*: The Raw Character Array

Char* is a pointer to a single character. It points to the raw character array, meaning the character data is stored sequentially in memory.

To declare a Char*, you use:

char *ptr;

This creates a pointer ptr that points to a character. To point it to an actual string, you do the following:

char str[100] = "Hello";

ptr = str;


After setting up the pointer `ptr` to the start of the `str` string, you can access individual characters using `ptr[0]`, `ptr[1]`, and so forth. But since it's a basic array, there's no automatic check for length. If you go beyond the string's end, you'll read incorrect memory, leading to program errors.
For finding the length of a `char*` string, employ the `strlen()` function. This helps you avoid overstepping the string's boundaries and causing problems in your program.

int length = strength (ptr)

Char* is useful when you need manual control over memory allocation. But for most purposes, you'll want to use the std::string class instead, which handles length checking and memory allocation for you automatically.

Std::string is a C++ string class in the standard library. It stores a sequence of characters and handles memory allocation internally.
To declare a std::string, use:

std::string str = "Hello";

std::strings offer safety and ease of use compared to Char* strings, allowing for character access, length, and manipulation in C++, allowing focus on code.

Get the tech career you deserve, faster!
Connect with our expert counsellors to understand how to hack your way to success
User rating 4.7/5
1:1 doubt support
95% placement record
Akash Pal
Senior Software Engineer
326% Hike After Job Bootcamp
Himanshu Gusain
Programmer Analyst
32 LPA After Job Bootcamp
After Job

Std::string: The String Class

The std::string class is one of the most useful tools in C++. Unlike C-style strings that use char arrays, std::string is a string class that handles your memory allocation and sizing.

Say you want to store someone's name in a variable. With a char array, you'd do something like:

char name[50];


But what if the name is longer than 50 characters? Your program would crash! With std::string, you don't have to worry about that. You can create a string like this:

std::string name;

And the size will automatically adjust as you add more characters.

You can add to a string with the += operator:

  • C++



using namespace std;

int main(){

   string name="";

   name += "Coding ";

   name += "Ninjas";


   // Or by using the .append() method:

   name.append(" Coding ");



   // To get the length of a string, use .length() or .size():

   int length = name.length(); // length is the length of string


   // You can access individual characters using bracket notation:

   name[0] = 'J';

   // And you can find substrings with .find():





std::string is crucial for C++ text storage, replacing char arrays.

Char[]: Fixed Size Character Array

Char[] is a fixed-size character array in C++. Unlike std::string, the size of a Char[] cannot change once it has been declared. You define a Char[] by stating the data type, name, and size in square brackets:

char name[10];

This creates an array called `name` that can hold 10 characters.

You access elements of a Char[] using bracket notation and the index number:

name[0] = 'R';
name[1] = 'o';
name[2] = 'h';
name[3] = 'a';
name[4] = 'n';

This assigns the first five characters of the name array to "Rohan".

However, if you try to access an element outside the size of the array, your program will crash with a buffer overflow error:

name[10] = '!'; // Error! Array only has 10 elements

Using `char[]` is ideal when you have a precise idea of the data size you'll use. It's memory-efficient due to its fixed size but inflexible – you can't change its size after setting it. Going beyond its size leads to problems.

Conversely, `std::string` adapts to data volume with its dynamic size. It's flexible, but this flexibility can slow things down a bit compared to `char[]`.

In summary, choose Char[] when:

  • You know the exact size needed.
  • You want maximum efficiency.

Choose std::string when: 

  • The size is unknown or may change.
  • Flexibility is more important than efficiency.

This helps explain the difference between these C++ character data types! Let me know if you have any other questions.

Feature char* std::string char[]
Memory Management Manual Automatic Manual (Fixed Size)
Null-terminated Yes Yes Yes
Size flexibility Can be resized Can be resized Fixed-size
Standard Library No Yes No
String Functions Limited Extensive Basic
Error-proneness High (Memory leaks) Low (RAII) High (Buffer overflows)


A Char _is a pointer to a character array. It's useful when you need a dynamic character array whose size can change. However, Char_ has some downsides. It has no built-in bounds checking, so it's easy to overwrite memory accidentally. It also has no built-in functions like length(), making it tedious to work with.


Std::string is a string class in the C++ standard library. It's a more robust option than Char _and has many valuable functions built-in, like length(), find(), and substr(). Std::string handles memory allocation for you, so there's no risk of overwriting memory. However, this convenience comes at a slight performance cost. Std::string is a bit slower than a Char_ due to additional overhead.


A Char[] is a static character array with a fixed size that you define. It has the performance benefits of a Char* with the bounds checking of Std::string. However, once you define the size, it cannot change. This can lead to unused memory allocation or stack overflow if you underestimate the size. Char[] requires manual memory management, so you must handle allocation and deallocations yourself.

  • Use Char* when you need a dynamic character array and are very performance conscious, being extremely careful to avoid memory issues.
  • Use Std::string as a general-purpose, convenient, and safe string class.
  • Only use Char[] if you need a character array of a size you know in advance and want maximum performance, properly handling memory yourself.

Also see, Abstract Data Types in C++

Frequently Asked Questions 

What is char[] in C++?

char[] is an array of characters. It's often used to represent strings, similar to char*. However, unlike std::string, char[] lacks built-in string manipulation functions and doesn't automatically manage memory. It's susceptible to buffer overflows if not carefully handled.

When should I use char*?

Use char* when working with legacy C-style APIs that expect null-terminated strings or when interfacing with external libraries that use char*. Avoid using it for string manipulation within modern C++ programs due to potential memory management issues.

Which one is more memory-efficient, std::string or char[]?

char[] can be more memory-efficient in some cases, as it only stores the characters without overhead. However, std::string provides more features and safety, which often justifies the slight memory overhead it may have.


This article has explained the differences between char, std::string, and char array data types in C++, their usage, and their advantages. It provided a comparison and examples to help you write cleaner, more efficient C++ code. 

We hope this blog has helped you enhance your knowledge of C++ Char* , String, and char[ ]. If you want to learn more, then check out our articles.


You may refer to our Guided Path on Code Studios for enhancing your skill set on DSACompetitive ProgrammingSystem Design, etc. Check out essential interview questions, practice our available mock tests, look at the interview bundle for interview preparations, and so much more!

Happy Learning!

Previous article
C++ String c_str() Function
Next article
C++ tmpfile()
Live masterclass