{"id":20152,"date":"2024-02-01T21:18:59","date_gmt":"2024-02-01T21:18:59","guid":{"rendered":"https:\/\/wolles-elektronikkiste.de\/?p=20152"},"modified":"2025-10-30T20:08:16","modified_gmt":"2025-10-30T20:08:16","slug":"character-arrays-vs-strings","status":"publish","type":"post","link":"https:\/\/wolles-elektronikkiste.de\/en\/character-arrays-vs-strings","title":{"rendered":"Character Arrays vs. Strings"},"content":{"rendered":"\n

About this Post<\/h2>\n\n

If you work with character sequences in your programs, you can use character arrays and String objects. Beginners in particular tend to use String objects because they are more convenient than character arrays. However, character arrays are more resource-efficient and should therefore be preferred.<\/p>\n

In this article, I will discuss and compare the essential operations that you can apply to character arrays and String objects. You will see that character arrays are in no way inferior to string objects in terms of functionality.<\/p>\n

We will look at the following operations in detail:<\/p>\n\n

Operation<\/th>Function (Character Arrays)<\/th>Function (String objects) <\/th><\/tr><\/thead>
Determine size \/ length<\/a><\/td>sizeof() \/ strlen()<\/td>sizeof() \/ length()<\/td><\/tr>
Concatenate<\/a><\/td>strcat() \/ strncat()<\/td>Operator \u2032+=\u2032<\/td><\/tr>
Duplicate<\/a><\/td>strdup()<\/td>Operator \u2032=\u2032<\/td><\/tr>
Convert to upper\/lower case letters <\/a><\/td>strupr() \/ strlwr()<\/td>toUpperCase() \/ toLowerCase()<\/td><\/tr>
Read characters by index<\/a><\/td>charArray[index]<\/td>charAt()<\/td><\/tr>
Replace \/ delete characters<\/a><\/td>charArray[index] <\/td>setCharAt() \/ remove()<\/td><\/tr>
Create substrings<\/a><\/td>memcpy() \/ strchr() \/ strrchr()<\/td>substring()<\/td><\/tr>
Split by character<\/a><\/td>strtok()<\/td>substring() & indexOf()<\/td><\/tr>
Search characters<\/a><\/td>strchr() \/ strrchr() \/ strstr()<\/td>indexOf() \/ lastIndexOf()<\/td><\/tr>
Compare<\/a><\/td>strcmp()<\/td>equals() \/ equalsIgnoreCase() \/compareTo() \/ Operator \u2032==\u2032<\/td><\/tr>
Conversion Char Arrays \u2194 Strings<\/a><\/td>to String: Operator \u2032=\u2032<\/td>to Char Array: toCharArray() \/ c_str()<\/td><\/tr>
Create from numbers<\/a><\/td>dtostrf() \/ sprintf()<\/td>String()<\/td><\/tr>
Convert into numbers<\/a> <\/td>atof() \/ atoI() \/ atol()<\/td>toInt() \/ toFloat()<\/td><\/tr>
Read in via serial<\/a><\/td>readBytes() \/ readBytesUntil()<\/td>readString() \/ readStringUntil()<\/td><\/tr>
Transfer to functions<\/a><\/td>–<\/td><\/td><\/tr><\/tbody><\/table>
Functions covered in the article<\/figcaption><\/figure>\n\n

Nomenclature<\/h2>\n\n

When I talk about character arrays in this article, I am referring to arrays of the data type char<\/code> that end with the NULL character '\\0'<\/code> (also known as the NULL terminator). You can also create non-NULL-terminated character arrays. However, these are pure arrays, to which you cannot apply most of the functions discussed here. In this respect, the term “character array” is ambiguous, but I don’t want to add “NULL terminated” every time.<\/p>\n

I refer to the instances of the String class that you create with String myString = \"....\"<\/code> or String myString = String (....)<\/code> as String objects. String objects are usually simply called strings. However, this designation is even more ambiguous than the character arrays just discussed. The term “string” could simply be the generic term for String objects and character arrays. Or take a look at the Arduino reference here<\/a>, where character arrays are dealt with under the heading “string”.<\/p>\n

To complete the confusion, there is a class called std::string in the C++ standard library, which is similar to the String class developed specifically for the Arduino environment. For these reasons, I will consistently use the term “String object” (with capital “S”) in this article. That is a bit unwieldy, but hopefully clear.<\/p>\n\n

Length and Size – or: The Difference between Character Arrays and String Objects<\/h2>\n\n

In the first sketch, we define a character array and a String object. The length, i.e. the number of characters, and the size, i.e. the memory space occupied in bytes, are then determined.<\/p>\n

You can find out the length of a character array with:<\/p>\n

size_t length = strlen( myCharArray );<\/code><\/p>\n

You can find out the length of a String object with :<\/p>\n

size_t length = myString.length();<\/code><\/p>\n

You can determine the size of a character array or a string object as follows:<\/p>\n

size_t sizeInBytes = sizeof( myCharArrayOrMyString );<\/code><\/p>\n

For the less experienced: The nice thing about the data type size_t<\/code> is that you don’t have to worry about the actual size of the return value. You are on the safe side, regardless of the microcontroller used.<\/p>\n

Now to the sketch:<\/p>\n<\/p>\n

\n
void setup(){\n    Serial.begin(9600);\n    char myCharArray[] = \"Hello, I am a character array\";\n    \/\/ char myCharArray[50] = \"Hello, I am a character array\";\n    \/\/ char myCharArray[] = {'H','e','l','l','o',',',' ','I',' ','a','m',' ','a',' ','c','h','a','r','a','c','t','e','r',' ','a','r','r','a','y','\\0'};\n    String myString = \"Hi all, I am a string\";\n\n    Serial.println(myCharArray);\n    Serial.print(\"Size of myCharArray: \");\n    size_t charSize = sizeof(myCharArray);\n    Serial.println(charSize);\n\n    Serial.print(\"Length of myCharArray: \");\n    size_t charLength = strlen(myCharArray); \n    Serial.println(charLength);\n    Serial.println();\n\n    Serial.println(myString);\n    Serial.print(\"Size of myString: \");\n    size_t stringSize = sizeof(myString);\n    Serial.println(stringSize);\n    \n    Serial.print(\"Length of myString: \");\n    size_t stringLength = myString.length();\n    Serial.println(stringLength);\n }\n\n void loop(){}<\/pre>\n
\u00a0<\/p>\n<\/div>\n
\n\n
And here is the output I got using an Arduino Nano (ATmega328P):<\/p>\n\n
\"Output<\/a>
Output of length_vs_size.ino<\/figcaption><\/figure>\n\n
Conclusions on the Character Array<\/h4>\n\n
As you can see, the length of the character array is 29. If you count, this is actually the number of characters. However, the size is 30 bytes, as the invisible NULL terminator '\\0'<\/code> is appended at the end. The NULL terminator signals the end of the character array.<\/p>\n
If you swap the comment line 3 and uncomment line 4, the length of the character array remains the same, but the size changes to 50 bytes.<\/p>\n
The alternative definition of myCharArray<\/code> in line 5 more complex, but makes it clearer that it is an array. With this notation, you must append the NULL terminator yourself. Or you can define the length explicitly and leave space for the NULL terminator, e.g.:<\/p>\n
char charArray[6] = {'H','e','l','l','o'};<\/code><\/p>\n\n
Conclusions on the String Object<\/h4>\n\n
Things get strange with the String object. The length correctly indicates the number of characters. But why is the size of the string object 6 bytes? Well, this is because the String object is stored in two parts. The actual character string (“string buffer”) is located in the heap. The 6 bytes in the stack are only a kind of table of contents. The pointer to the heap address of the string buffer, the capacity of the String object and its length are stored there.<\/p>\n
When using other microcontrollers, things may be different. For example, with an ESP32, a string buffer is only stored in the heap if the length of the character string exceeds 13 characters. The size of the Atring object in the stack is always 16 bytes.<\/p>\n
If you would like to know more about string objects in the stack and heap, you could read my post about SRAM management<\/a>. There I also discuss the notorious heap fragmentation, which is often cited as an argument against the use of String objects.<\/p>\n\n
Concatenating Character Arrays and String Objects<\/h2>\n\n
Concatenating Character Arrays<\/h4>\n\n
This is how you concatenate two character arrays:<\/p>\n
strcat( char* destination, char* source );<\/code><\/p>\n
The “source” character array is appended to the “destination” array. You must ensure that “destination” is large enough to accommodate “source”. If this is not the case, there is a risk that you will overwrite memory locations that could contain other variables. The consequences are unpredictable. The problem is that there is no error message when compiling. <\/p>\n
Alternatively, you can append the first x characters of “source” to “destination”:<\/p>\n
strncat( char* destination, char* source, size_t x);<\/code><\/p>\n\n
Why do we pass “char* charArray”?<\/h4>\n\n
The name of an array represents the pointer to the beginning of the array. So if you define a character array as follows:  char myCharArray[] = \"....\"<\/code>, then myCharArray<\/code> is a pointer of the data type char<\/code>. When passing to a function, only the pointer is passed and not the entire array. I will discuss the passing of character arrays and String objects in detail later.<\/p>\n\n
Concatenating String Objects<\/h4>\n\n
String objects are simply concatenated using the “+” operator:<\/p>\n
String destination += String source;<\/code><\/p>\n
The undeniably pleasant thing about String objects is that you (supposedly) don’t have to worry about their length. However, the extension of String objects can lead to heap fragmentation<\/a>. To prevent this, you can reserve memory space for the string object:<\/p>\n
myString.reserve( unigned int size );<\/code><\/p>\n
Where size<\/code> is the expected maximum length of your string object.<\/p>\n
Here is a small example sketch on the subject of concatenation:<\/p>\n<\/p>\n
void setup(){\n   Serial.begin(9600);\n   char myCharArray1[13] = \"Hello\";\n   char myCharArray2[] = \" World!\";\n\n   strcat(myCharArray1, myCharArray2);\n   \/\/ strncat(myCharArray1, myCharArray2, 5);  \/\/ add the first 5 chars\n   Serial.println(myCharArray1);\n\n   String myString1 = \"Hello\";\n   String myString2 = \" Earth!\";\n\n   myString1 += myString2;\n\n   Serial.println(myString1);\n}\n\nvoid loop(){}<\/pre>\n
\n\n
The unsurprising output is:<\/p>\n\n
\"Output<\/a>
Output of concatenate.ino<\/figcaption><\/figure>\n\n
Duplicate<\/h2>\n\n
You can create a copy of a character array as follows:<\/p>\n
char* copy = strdup( const char* original );<\/code><\/p>\n
It is even easier with String objects:<\/p>\n
String copy = String original;<\/code><\/p>\n
Here is an example:<\/p>\n<\/p>\n
void setup(){\n    Serial.begin(9600);\n    \n    char myCharArray[] = \"Hello, I am a character array\";\n    Serial.print(\"Original: \");\n    Serial.println(myCharArray);\n\n    char* myCharArrayCopy = strdup(myCharArray);\n    Serial.print(\"Copy: \");\n    Serial.println(myCharArrayCopy);\n    Serial.println();\n\n    String myString = \"Hi all, I am a string\";\n    Serial.print(\"Original: \");\n    Serial.println(myString);\n\n    String myStringCopy = myString;\n    Serial.print(\"Copy: \");\n    Serial.println(myStringCopy);    \n}\n\nvoid loop(){}<\/pre>\n
\n\n
And here, for the sake of completeness, the output:<\/p>\n\n
\"Output<\/a>
Output duplicate.ino<\/figcaption><\/figure>\n\n
Converting to Upper or Lower Case Letters<\/h2>\n\n
There are also very convenient functions for converting character arrays and String objects into upper or lower case letters.<\/p>\n
You can convert a character array as follows:<\/p>\n
strupr( char* charArray );<\/code> \/\/ Upper case letters<\/p>\n
strlwr( char* charArray );<\/code> \/\/ Lower case letters<\/p>\n
Use the following functions for String objects:<\/p>\n
myString.toUpperCase();<\/code> or myString.toLowerCase();<\/code><\/p>\n<\/p>\n
\n
void setup(){\n    Serial.begin(9600);\n    \n    char myCharArray[] = \"Hello, I am a character array\";\n    Serial.print(\"Original: \");\n    Serial.println(myCharArray);\n   \n    Serial.print(\"Upper Case: \");\n    strupr(myCharArray);\n    Serial.println(myCharArray);\n   \n    Serial.print(\"Lower Case: \");\n    strlwr(myCharArray);\n    Serial.println(myCharArray);\n    \n    Serial.println();\n\n    String myString = \"Hi all, I am a string\";\n    Serial.print(\"Original: \");\n    Serial.println(myString);\n\n    Serial.print(\"Upper Case: \");\n    myString.toUpperCase();\n    Serial.println(myString);\n    \n    Serial.print(\"Lower Case: \");\n    myString.toLowerCase();\n    Serial.println(myString);\n}\n\nvoid loop(){}<\/pre>\n
\u00a0<\/p>\n<\/div>\n
\n\n
The output is:<\/p>\n\n
\"Output<\/a>
Output upper_lower_case.ino<\/figcaption><\/figure>\n\n
Reading a character by index<\/h2>\n\n
I don’t really need to explain how to read a character at a specific position in the character array:<\/p>\n
char charAtIndexI = charArray[i];<\/code><\/p>\n
There is a separate function for String objects for this purpose:<\/p>\n
char charAtIndexI = myString.charAt(i);<\/code><\/p>\n
Here’s an example:<\/p>\n<\/p>\n
void setup(){\n    Serial.begin(9600);\n    char myCharArray[] = \"Hello, I am a character array!\";\n\n    Serial.print(\"Tenth character: \");\n    char charAtIndex10 = myCharArray[10];\n    Serial.println(charAtIndex10);\n\n    String myString = \"Hi all, I am a string\";\n    \n    Serial.print(\"Tenth character: \");\n    charAtIndex10 = myString.charAt(10);\n    Serial.println(charAtIndex10);\n }\n\n void loop(){}<\/pre>\n
\n\n
The sketch gives the following output:<\/p>\n\n
\"Output<\/a>
Output read_char_at_index_i.ino<\/figcaption><\/figure>\n\n
Replacing and Deleting Characters<\/h2>\n\n
In a character array, you replace characters by accessing them via the index:<\/p>\n
charArray[index] = 'x'; \/\/ replace x by any other character<\/code><\/p>\n
To delete characters, you have to “tinker” a little. You let the remaining characters move to the left after the characters to be deleted, and then attach the NULL terminator.<\/p>\n
String objects have their own functions for replacing and deleting characters:<\/p>\n
myString.setCharAt[index] = 'x';<\/code><\/p>\n
myString.remove( index, length );<\/code><\/p>\n
Example sketch:<\/p>\n<\/p>\n
\n
void setup(){\n    Serial.begin(9600);\n    \n    char myCharArray[] = \"abcdefghijklm\";\n    Serial.print(\"Original: \");\n    Serial.println(myCharArray);\n\n    myCharArray[3] = 'c';\n    Serial.print(\"\\\"d\\\" replaced by \\\"c\\\": \");\n    Serial.println(myCharArray);\n\n    remove(myCharArray, sizeof(myCharArray), 3, 5);\n    Serial.print(\"Removed 5 chars from index 3: \");\n    Serial.println(myCharArray);\n    Serial.println();\n\n    String myString = \"nopqrstuvwxyz\";\n    Serial.print(\"Original: \");\n    Serial.println(myString);\n    \n    myString.setCharAt(3, 'p');\n    Serial.print(\"\\\"q\\\" replaced by \\\"p\\\": \");\n    Serial.println(myString);\n\n    myString.remove(3, 5);\n    Serial.print(\"Removed 5 chars from index 3: \");\n    Serial.println(myString);    \n}\n\nvoid loop(){}\n\nvoid remove(char *cArr, size_t size, size_t index, size_t len){  \/\/ remove for char arrays\n    for(size_t i = index; i < (size-len); i++){\n        cArr[i] = cArr[i+len];\n    }\n    cArr[size-len] = '\\0';\n}<\/pre>\n
\u00a0<\/p>\n<\/div>\n
\n\n
The output is as expected:<\/p>\n\n
\"Output<\/a>
Output replace_remove.ino<\/figcaption><\/figure>\n\n
Substrings<\/h2>\n\n
Sections of character arrays starting from a certain index<\/h4>\n\n
Creating substrings from character strings is a bit awkward. We use the  function memcpy()<\/code> for this. In general terms, the function is used as follows:<\/p>\n
void* memcpy ( void* destination, const void* source, size_t num );<\/code><\/p>\n
“Translated”, this means: memcpy()<\/code> copies num<\/code> bytes, starting at the address to which the pointer source<\/code> points, and copies them to the address to which the pointer destination<\/code> points. The data type void*<\/code> makes memcpy()<\/code> versatile. It does not matter which data type the pointers to be passed point to. To create a substring, we use the function as follows:<\/p>\n
memcpy( subCharArray, charArray + index, length );<\/code><\/p>\n
When you specify the length of subCharArray<\/code>, please consider the NULL terminator. Regardless of this, you must actually attach the NULL terminator. Or, even easier, you initialize subCharArray<\/code> as {'\\0'}<\/code>. As a result, all elements of the array are initialized as NULL characters.<\/p>\n\n
Substrings of character arrays beginning from a certain character<\/h4>\n\n
If you want to create a substrings that begins at a specific character of the original array and captures all characters from there to the end, then the function strchr()<\/code> comes into consideration. The following line of code defines the pointer subCharArray<\/code>, which points to the address at which the character charToBeFound<\/code> appears for the first time in charArray<\/code>:<\/p>\n
char* subCharArray = strchr(const char* charArray, char charToBeFound);<\/code><\/p>\n
Alternatively, you can use strrchr()<\/code> (with two “r “s). The function returns a pointer that points to the last occurrence of the character you are looking for.<\/p>\n
You just need to be aware that subCharArray<\/code> is still part of charArray<\/code>. Changes to subCharArray<\/code> also change charArray<\/code>. If you do not want to do this, you should create a copy with strdup()<\/code> or via memcpy()<\/code>.<\/p>\n\n
Substrings from String Objects<\/h4>\n\n
For String objects, there is the extremely convenient function substring()<\/code> available. You can use it to create a substring that starts at a specific index. If you only pass the index, all other characters are included in the substring until the end. Alternatively, you can pass a second index before<\/em> which the substring ends.<\/p>\n
String subString = myString.subtring( index );<\/code><\/p>\n
String subString = myString.substring( startIndex, endIndex ); \/\/ substring from startIndex to endIndex - 1<\/code><\/p>\n
Here is the example:<\/p>\n<\/p>\n
\n
void setup(){\n    Serial.begin(9600);\n    \n    char myCharArray[] = \"abcdefghijklm\";\n    Serial.print(\"Original: \");\n    Serial.println(myCharArray);\n\n    char mySubCharArray[6] = {'\\0'};\n    Serial.print(\"Substring from index 3 to 7: \");\n    memcpy(mySubCharArray, myCharArray+3, 5);\n    Serial.println(mySubCharArray);\n\n    char mySubCharArray_2[6] = {'\\0'};\n    Serial.print(\"Substring 3-7, alternative: \");\n    subArray(mySubCharArray_2, myCharArray, 3, 5);\n    Serial.println(mySubCharArray_2);\n    \n    char *mySubCharArray_3 = strchr(myCharArray, 'i');  \/\/ strchr(): first occurance \/ strrchr(): finds last occurance\n    Serial.print(\"Substring, beginning at \\\"i\\\": \");\n    Serial.println(mySubCharArray_3);\n    Serial.println();\n       \n    String myString = \"nopqrstuvwxyz\";\n    Serial.print(\"Original: \");\n    Serial.println(myString);\n    \n    String mySubString = myString.substring(3, 8);\n    Serial.print(\"Substring from index 3 to 7: \");\n    Serial.println(mySubString);   \n\n    String mySubString_2 = myString.substring(7);\n    Serial.print(\"Substring from index 7: \");\n    Serial.println(mySubString_2);   \n}\n\nvoid loop(){}\n\nvoid subArray(char* destination, char* source, size_t index, size_t len){\n    memcpy(destination, source + index, len);\n}<\/pre>\n
\u00a0<\/p>\n<\/div>\n
\n\n
The sketch generates the following output:<\/p>\n\n
\"Output<\/a>
Output substrings.ino<\/figcaption><\/figure>\n\n
Complete Splitting of the Character Sequence by Specific Characters<\/h4>\n\n
You may want to split character arrays and String objects by certain characters. This could be necessary, for example, if a character sequence contains several measured values that are separated from each other by a specific character (delimiter).<\/p>\n
Here, the character arrays offer the simpler solution:<\/p>\n
char* chunk = strtok( char* charArray, char delimiter );<\/code><\/p>\n
chunk<\/code> is a character array that contains all characters up to the first occurrence of the delimiter. The pleasant but perhaps also confusing thing is that you pass the NULL pointer to extract the next section:<\/p>\n
char* nextChunk = strtok( NULL, char delimiter );<\/code><\/p>\n
This works because strtok()<\/code> remembers the address of the character array and the index of the last delimiter. If no more delimiters are found, strtok()<\/code> returns the NULL pointer.<\/p>\n
You can split string objects according to delimiters by searching for the delimiters with indexOf()<\/code> and creating the sections with substring()<\/code>.<\/p>\n
Here is the example of this:<\/p>\n<\/p>\n
void setup(){\n    Serial.begin(9600);\n    char myCharArray[] = \"Hello, I am a character array\";\n    String myString = \"Hi all, I am a string\";\n\n    char *cArrChunk = strtok(myCharArray, \" \");\n    while(cArrChunk != NULL){\n        Serial.println(cArrChunk);\n        cArrChunk = strtok(NULL, \" \");\n    }\n    Serial.print(\"myCharArray: \");\n    Serial.println(myCharArray);\n    Serial.println();\n\n    String stringChunk = myString.substring(0, myString.indexOf(\" \"));\n    while(myString != \"\"){\n        Serial.println(stringChunk);\n        myString.remove(0, stringChunk.length()+1);\n        stringChunk = myString.substring(0, myString.indexOf(\" \"));\n    }\n    Serial.print(\"myString: \");\n    Serial.println(myString);\n}\n\nvoid loop(){}<\/pre>\n
\n\n
Here is the output:<\/p>\n\n
\"Output<\/a>
Output mince_char_arrays_and_strings.ino<\/figcaption><\/figure>\n\n
As you can see, myCharArray<\/code> and myString<\/code> are modified by this procedure. If you don’t want that, you’ll have to work with copies.<\/p>\n\n
Search characters<\/h2>\n\n
We have already searched for specific characters before, but I want to come back to this topic again, as we have omitted some aspects so far. This also includes determining the index of a specific character in a character array. The determination of the index for the last occurrence of a character in a string object is also missing. <\/p>\n\n
Searching Characters in a Character Array<\/h4>\n\n
As we have seen, strchr()<\/code> returns the pointer to the address where the character we are searching is located for the first time. strrchr()<\/code> provides the pointer to the last address where the searched character is located. To calculate the index from these pointers, simply subtract the pointer to the character array:<\/p>\n
indexOfCharX = strchr( char* charArray, char charX ) - charArray;<\/code><\/p>\n
Alternatively, you can, of course, compare every character in your array with the character you are searching for. But that is less elegant.<\/p>\n
If you are not searching for a character but for a character sequence within the character array, you can use the strstr()<\/code> function:<\/p>\n
char* ptrToFirstString = strstr( char* charArray, char* searchString );<\/code><\/p>\n
If strchr()<\/code>, strrchr()<\/code> and strstr()<\/code> end their search unsuccessfully, they return the NULL pointer.<\/p>\n\n
Searching Characters in a String Object <\/h4>\n\n
As we have seen, we can find out the index for the first occurrence of a character in a String object using indexOf()<\/code>. However, the function also accepts character arrays and String objects:<\/p>\n
int indexOfFirstStringX = myString.indexOf( char* \/ String stringX);<\/code><\/p>\n
You can find the index for the last occurrence of one or more characters with :<\/p>\n
int indexOfLastStringX = myString.lastIndexOf( char* \/ String stringX );<\/code><\/p>\n
You can then determine the index for the first or last occurrence of a character or character string from a certain index:<\/p>\n
int indexOfFirstStringXAfterIndexY = myString.indexOf( char* \/ String stringX, size_t indexY);<\/code><\/p>\n
int indexOfLastStringXAfterIndexY = myString.lastIndexOf( char* \/ String stringX, size_t indexY);<\/code><\/p>\n
If indexOf()<\/code> and lastIndexOf()<\/code> end their search unsuccessfully, they return -1.<\/p>\n
Example sketch:<\/p>\n<\/p>\n
\n
void setup(){\n    Serial.begin(9600);\n    char myCharArray[] = \"I am a character array!\";\n\n    Serial.print(\"Rest of myCharArray beginning at first \\\"a\\\": \");\n    char *ptrToFirstA = strchr(myCharArray, 'a');\n    if (ptrToFirstA != NULL){\n        Serial.println(ptrToFirstA);\n    }\n    else{\n        Serial.println(\"Not found\");\n    }\n    \n    Serial.print(\"Rest of myCharArray beginning at first \\\"x\\\": \");\n    char *ptrToFirstX = strchr(myCharArray, 'x');\n    if (ptrToFirstX != NULL){\n        Serial.println(ptrToFirstX);\n    }\n    else{\n        Serial.println(\"Not found\");\n    }\n\n    Serial.print(\"Rest of myCharArray beginning at last \\\"a\\\": \");\n    char *ptrToLastA = strrchr(myCharArray, 'a');\n    Serial.println(ptrToLastA);\n    \n    Serial.print(\"Last \\\"a\\\" is at position: \");\n    int indexOfLastA = findLastIndexOf(myCharArray, sizeof(myCharArray), 'a'); \n    Serial.println(indexOfLastA);\n\n    Serial.print(\"Alternative Method: Last \\\"a\\\" position: \");\n    indexOfLastA = ptrToLastA - myCharArray;\n    Serial.println(indexOfLastA);\n\n    Serial.print(\"First \\\"ar\\\" position: \");\n    char *ptrToFirstAR = strstr(myCharArray, \"ar\");\n    int indexOfFirstAR = ptrToFirstAR - myCharArray;\n    Serial.println(indexOfFirstAR);\n}\n\nvoid loop(){}\n\nsize_t findLastIndexOf(char *cArr, size_t size, char searchChar){\n    size_t lastPos = -1;\n    for(size_t i=0; i<size; i++){\n        if(cArr[i] == searchChar){\n            lastPos = i;\n        }\n    }\n    return lastPos;\n}<\/pre>\n
void setup(){\n    Serial.begin(9600);\n    String myString = \"I am not a character array but a String\";\n\n    Serial.print(\"First index of \\\"t\\\": \");\n    int indexOfFirstT = myString.indexOf(\"t\");\n    Serial.println(indexOfFirstT);\n\n    Serial.print(\"First index of \\\"t\\\" after pos. 7: \");\n    int indexOfFirstTAfterPos7 = myString.indexOf(\"t\", 8);\n    Serial.println(indexOfFirstTAfterPos7);\n\n    Serial.print(\"First index of \\\"x\\\": \");\n    size_t indexOfFirstX = myString.indexOf(\"x\");\n    if((int)indexOfFirstX != -1){\n        Serial.println(indexOfFirstX);\n    }\n    else{\n        Serial.println(\"Not found\");\n    }\n\n    Serial.print(\"Last index of \\\"t\\\": \");\n    int indexOfLastT = myString.lastIndexOf(\"t\");\n    Serial.println(indexOfLastT);\n\n    Serial.print(\"Last index of \\\"ar\\\": \");\n    char searchString[] = \"ar\";\n    \/\/String searchString = \"ar\";\n    int indexOfLastAR = myString.lastIndexOf(searchString);\n    Serial.println(indexOfLastAR);\n}\n\nvoid loop(){}<\/pre>\n
\u00a0<\/p>\n<\/div>\n
\n\n
And here are the outputs:<\/p>\n\n
\"Output<\/a>
Output find_characters.ino, left: character array, right: String Object<\/figcaption><\/figure>\n\n
Compare<\/h2>\n\n
Comparing Character Arrays<\/h4>\n\n
This is how you compare two character arrays:<\/p>\n
int result = strcmp( char* charArray1, char* charArray2 );<\/code><\/p>\n
If you only want to compare the first n characters of the two arrays, then pass “n” as the third parameter:<\/p>\n
int result = strcmp( char* charArray_1, char* charArray_2, size_t n );<\/code><\/p>\n
The strcmp()<\/code> function compares the arrays character by character starting at index 0. This continues until it encounters the first different character or reaches the end or the last of the characters to be compared. If the function encounters a different character, result<\/code> corresponds to the difference between the ASCII codes of these characters. If result<\/code> is negative, then charArray_1<\/code> contains the character with the lower ASCII code. If result<\/code> is positive, then it is the other way around.  If result<\/code> is 0, then the two character arrays are identical, or more precisely: they have an identical character sequence.<\/p>\n
If you want to perform the comparison regardless of upper or lower case letters, you can convert the character arrays with strupr()<\/code> or strlwr()<\/code> before the comparison. However, this will permanently change them, so you may need to make copies.<\/p>\n\n
Comparing String Objects <\/h4>\n\n
To check whether two String objects are the same, use the function equals()<\/code>:<\/p>\n
bool result = myString.equals( myString_2 );<\/code><\/p>\n
If you only want to check parts of myString_2<\/code> and myString<\/code> for identity, you must combine equals()<\/code> with substring()<\/code>. You can ignore upper and lower case with the variant equalsIgnoreCase()<\/code>:<\/p>\n
bool result = myString.equalsInoreCase( myString_2 );<\/code><\/p>\n
As an alternative to equals()<\/code>, use the function compareTo()<\/code>:<\/p>\n
int result = myString.compareTo( myString_2 );<\/code><\/p>\n
Just like strcmp()<\/code>, compareTo()<\/code> compares the two String objects character by character. If two characters are different, the function returns the difference between the ASCII codes of these characters.<\/p>\n<\/p>\n
\n
void setup(){\n    Serial.begin(9600);\n    char myCharArray1[] = \"I am a character array!\";\n    char myCharArray2[] = \"I am also a character array!\";\n    char myCharArray3[] = \"I am a character array!\";\n    char myCharArray4[] = \"I aM A cHaRaCteR aRrAy!\";\n    char myCharArray5[] = \"abcd\";\n    char myCharArray6[] = \"aacd\";\n  \n\n    Serial.print(\"Comparing 1, 2: \");\n    int result = strcmp(myCharArray1, myCharArray2);\n    Serial.println(result);\n\n    Serial.print(\"Comparing 1, 2 (first 6 characters): \");\n    result = strncmp(myCharArray1, myCharArray2, 6);\n    Serial.println(result);\n\n    Serial.print(\"Comparing 1, 3: \");\n    result = strcmp(myCharArray1, myCharArray3);\n    Serial.println(result);\n\n    Serial.print(\"Comparing 1, 4: \");\n    result = strcmp(myCharArray1, myCharArray4);\n    Serial.println(result);\n\n    Serial.print(\"Comparing 1, 4, non-case-sensitive: \");\n    result = strcmp(strlwr(myCharArray1), strlwr(myCharArray3)); \/\/ changes the char arrays permanently!\n    Serial.println(result); \n    Serial.println(myCharArray1);\n\n    Serial.print(\"Comparing 5, 6: \");\n    result = strcmp(myCharArray5, myCharArray6);\n    Serial.println(result);\n\n    Serial.print(\"Comparing 6, 5: \");\n    result = strcmp(myCharArray6, myCharArray5);\n    Serial.println(result);\n }\n\nvoid loop(){}<\/pre>\n
void setup(){\n   Serial.begin(9600);\n   String myString1 = \"I am a String!\";\n   String myString2 = \"I am also a String!\";\n   String myString3 = \"I am a String!\";\n   String myString4 = \"I aM A sTrInG!\";\n   String myString5 = \"abcd\";\n   String myString6 = \"aacd\";\n \n\n   Serial.print(\"Comparing 1, 2: \");\n   int result = (myString1.equals(myString2));\n   Serial.println(result);\n\n   Serial.print(\"Comparing 1, 2 (first 6 characters): \");\n   result = (myString1.substring(0,6)).equals(myString2.substring(0,6));\n   Serial.println(result);\n  \n   Serial.print(\"Comparing 1, 3: \");\n   result = myString1.equals(myString3);\n   Serial.println(result);\n\n   Serial.print(\"Comparing 1, 4: \");\n   result = myString1.equals(myString4);\n   Serial.println(result);\n\n   Serial.print(\"Comparing 1, 4, non-case-sensitive: \");\n   result = myString1.equalsIgnoreCase(myString4);\n   Serial.println(result);\n   Serial.println(myString1);\n\n   Serial.print(\"Comparing 5, 6: \");\n   result = myString5.compareTo(myString6);\n   Serial.println(result);\n\n   Serial.print(\"Comparing 6, 5: \");\n   result = myString6.compareTo(myString5);\n   Serial.println(result);\n}\n\nvoid loop(){}<\/pre>\n
\u00a0<\/p>\n<\/div>\n
\n\n
The outputs are:<\/p>\n\n
\"left:<\/a>
left: output compare_char_arrays.ino, right: compare_strings.ino<\/figcaption><\/figure>\n\n
Using the “==” operator<\/h4>\n\n
If you use the operator ==<\/code> on two character arrays, it compares two pointers. You only get a true<\/code> if both pointers point to the same address, i.e., if the two character arrays are not only the same but truly identical. <\/p>\n
With String objects, on the other hand, the operator ==<\/code> checks whether the “content”, i.e. the string buffers, are the same. equals()<\/code> and ==<\/code> are equivalent. <\/p>\n
Here is an example sketch:<\/p>\n<\/p>\n
\n
void setup(){\n    Serial.begin(9600);\n    char myCharArray1[] = \"I am a character array!\";\n    char myCharArray2[] = \"I am a character array!\";\n    char* myCharArray3 = myCharArray2;\n    String myString1 = \"I am a String!\";\n    String myString2 = \"I am a String!\";\n\n    Serial.print(\"Char array comparison 1: \");\n    if(myCharArray1 == myCharArray2){   \/\/ Compares the pointers, not the arrays\n        Serial.println(\"Identical\");\n    }\n    else{\n        Serial.println(\"Different\");\n    }\n\n    Serial.print(\"Char array comparison 2: \");\n    if(myCharArray2 == myCharArray3){   \/\/ Compares the pointers, not the arrays\n        Serial.println(\"Identical\");\n    }\n    else{\n        Serial.println(\"Different\");\n    }\n\n    Serial.print(\"Char array comparison 3: \");\n    if(myCharArray1 == \"I am a character array!\"){  \/\/ Don't do this!!!!\n        Serial.println(\"Identical\");\n    }\n    else{\n        Serial.println(\"Different\");\n    }\n\n    Serial.print(\"String comparison 1: \");\n    if(myString1 == myString2){\n        Serial.println(\"Equal\");\n    }\n    else{\n        Serial.println(\"Different\");\n    }\n\n    Serial.print(\"String comparison 2: \");\n    if(myString1 == \"I am a String!\"){\n        Serial.println(\"Equal\");\n    }\n    else{\n        Serial.println(\"Different\");\n    }\n }\n\n void loop(){}<\/pre>\n
\u00a0<\/p>\n<\/div>\n
\n\n
Here is the output for compare_2.ino:<\/p>\n\n
\"Output<\/a>
Output compare_2.ino<\/figcaption><\/figure>\n\n
Creating Character Arrays from String Objects and vice versa<\/h2>\n\n
Creating a String object from a character array is simple:<\/p>\n
String myString = ( const char* myCharArray );<\/code><\/p>\n
There are two functions you can use to create character arrays from string objects:<\/p>\n
myString.toCharArray( char* myCharArray, size_t length );<\/code><\/p>\n
const char* myCharArray = myString.c_str();<\/code><\/p>\n
Use the function toCharArray()<\/code> to copy the string buffer, i.e. the character sequence, into a previously defined character array. The first parameter to be passed to toCharArray()<\/code> is the character array, the second is the length of the character array. The NULL terminator is attached automatically. You must take this into account when defining the length.<\/p>\n
The function c_str()<\/code> does something entirely different by returning the pointer to the string buffer in the heap (i.e. where the content of the String object is stored). In other words, nothing new is created here, but you access the character sequence of the String object directly. In this respect, it makes sense for the return value to be a constant. This protects you from accidentally changing your string object. If you intend to change the character array, it is best to create a copy with memcpy()<\/code> (see example sketch). But then you could just as well use toCharArray()<\/code>.<\/p>\n
So why do we need c_str()<\/code>? This function is always useful if you want to pass on the content of the String object unchanged to another function. The c_str()<\/code> function is much faster and saves SRAM.<\/p>\n<\/p>\n
void setup(){\n    Serial.begin(9600);\n    char myCharArray[] = \"I was born as a character array!\";\n\n    String stringFromCharArray = String(myCharArray);\n    Serial.println(stringFromCharArray);\n\n    String myString = \"I was born as a String\";\n\n    char charArrayFromString[myString.length() + 1];\n    myString.toCharArray(charArrayFromString, myString.length() + 1);\n    Serial.println(charArrayFromString);\n\n    char charArrayFromString2[myString.length() + 1];\n    memcpy(charArrayFromString2, myString.c_str(), myString.length() + 1);\n    Serial.println(charArrayFromString2);\n}\n\nvoid loop(){}<\/pre>\n
\n\n
And here is the unsurprising output:<\/p>\n\n
\"Output<\/a>
Output char_array_to_string_and_string_to_char_array.ino<\/figcaption><\/figure>\n\n
Converting Numbers to Character Arrays and String Objects<\/h2>\n\n
Decimal Numbers into Character Arrays <\/h4>\n\n
Floating-point numbers (double and float) and integers (int, long) can be easily converted into character arrays using the dtostrf()<\/code> function:<\/p>\n
dtostrf( double myDouble, signed char min_width, unsigned char precision, char* myCharArray );<\/code><\/p>\n
The parameters are:<\/p>\n