字符串用于存储文本。它们可用于在LCD或Arduino IDE串行监视器窗口中显示文本。字符串对于存储用户输入也很有用。例如，用户在连接到Arduino的键盘上键入的字符。
Arduino编程中有两种类型的字符串
字符数组，与C编程中使用的字符串相同。
Arduino字符串，它允许我们在草图中使用字符串对象。
在本章中，我们将学习Arduino示意图中的字符串、对象和字符串的使用。在本章结束时，您将了解在草图中使用哪种类型的字符串。
我们将学习的第一种类型的字符串是由char类型的一系列字符组成的字符串。在前一章中，我们学习了数组是什么;存储在内存中的同一类型变量的连续序列。字符串是char变量的数组。
字符串是一个特殊的数组，它在字符串的末尾有一个额外的元素，它的值总是0(0)。这就是所谓的“空终止字符串”。
这个示例将展示如何创建一个字符串并将其打印到串行监视器窗口。
例子
void setup() {
char my_str[6]; // an array big enough for a 5 character string
Serial.begin(9600);
my_str[0] = 'H'; // the string consists of 5 characters
my_str[1] = 'e';
my_str[2] = 'l';
my_str[3] = 'l';
my_str[4] = 'o';
my_str[5] = 0; // 6th array element is a null terminator
Serial.println(my_str);
}
void loop() {
}下面的例子展示了字符串的组成;一个字符数组，其中可打印字符和0作为数组的最后一个元素，以表明这是字符串结束的地方。通过使用Serial.println()并传递字符串的名称，可以将字符串打印到Arduino IDE串行监视器窗口。
同样的例子可以用下面所示的更方便的方法来写
例子
void setup() {
char my_str[] = "Hello";
Serial.begin(9600);
Serial.println(my_str);
}
void loop() {
}在这个示意图中，编译器会计算字符串数组的大小，并自动使用null结束字符串。一个由6个元素组成、5个字符和一个0组成的数组的创建方法与前面的示意图完全相同。
我们可以在一个示意图中改变一个字符串数组，如下所示。
例子
void setup() {
char like[] = "I like coffee and cake"; // create a string
Serial.begin(9600);
// (1) print the string
Serial.println(like);
// (2) delete part of the string
like[13] = 0;
Serial.println(like);
// (3) substitute a word into the string
like[13] = ' '; // replace the null terminator with a space
like[18] = 't'; // insert the new word
like[19] = 'e';
like[20] = 'a';
like[21] = 0; // terminate the string
Serial.println(like);
}
void loop() {
}I like coffee and cake I like coffee I like coffee and tea
The sketch works in the following way.
In the sketch given above, a new string is created and then printed for display in the Serial Monitor window.
The string is shortened by replacing the 14th character in the string with a null terminating zero (2). This is element number 13 in the string array counting from 0.
When the string is printed, all the characters are printed up to the new null terminating zero. The other characters do not disappear; they still exist in the memory and the string array is still the same size. The only difference is that any function that works with strings will only see the string up to the first null terminator.
Finally, the sketch replaces the word "cake" with "tea" (3). It first has to replace the null terminator at like[13] with a space so that the string is restored to the originally created format.
New characters overwrite "cak" of the word "cake" with the word "tea". This is done by overwriting individual characters. The 'e' of "cake" is replaced with a new null terminating character. The result is that the string is actually terminated with two null characters, the original one at the end of the string and the new one that replaces the 'e' in "cake". This makes no difference when the new string is printed because the function that prints the string stops printing the string characters when it encounters the first null terminator.
The previous sketch manipulated the string in a manual way by accessing individual characters in the string. To make it easier to manipulate string arrays, you can write your own functions to do so, or use some of the string functions from the C language library.
The next sketch uses some C string functions.
void setup() {
char str[] = "This is my string"; // create a string
char out_str[40]; // output from string functions placed here
int num; // general purpose integer
Serial.begin(9600);
// (1) print the string
Serial.println(str);
// (2) get the length of the string (excludes null terminator)
num = strlen(str);
Serial.print("String length is: ");
Serial.println(num);
// (3) get the length of the array (includes null terminator)
num = sizeof(str); // sizeof() is not a C string function
Serial.print("Size of the array: ");
Serial.println(num);
// (4) copy a string
strcpy(out_str, str);
Serial.println(out_str);
// (5) add a string to the end of a string (append)
strcat(out_str, " sketch.");
Serial.println(out_str);
num = strlen(out_str);
Serial.print("String length is: ");
Serial.println(num);
num = sizeof(out_str);
Serial.print("Size of the array out_str[]: ");
Serial.println(num);}void loop() {}This is my string String length is: 17 Size of the array: 18 This is my string This is my string sketch. String length is: 25 Size of the array out_str[]: 40
The sketch works in the following way.
The newly created string is printed to the Serial Monitor window as done in previous sketches.
The strlen() function is used to get the length of the string. The length of the string is for the printable characters only and does not include the null terminator.
The string contains 17 characters, so we see 17 printed in the Serial Monitor window.
The operator sizeof() is used to get the length of the array that contains the string. The length includes the null terminator, so the length is one more than the length of the string.
sizeof() looks like a function, but technically is an operator. It is not a part of the C string library, but was used in the sketch to show the difference between the size of the array and the size of the string (or string length).
The strcpy() function is used to copy the str[] string to the out_num[] array. The strcpy() function copies the second string passed to it into the first string. A copy of the string now exists in the out_num[] array, but only takes up 18 elements of the array, so we still have 22 free char elements in the array. These free elements are found after the string in memory.
The string was copied to the array so that we would have some extra space in the array to use in the next part of the sketch, which is adding a string to the end of a string.
The sketch joins one string to another, which is known as concatenation. This is done using the strcat() function. The strcat() function puts the second string passed to it onto the end of the first string passed to it.
After concatenation, the length of the string is printed to show the new string length. The length of the array is then printed to show that we have a 25-character long string in a 40 element long array.
Remember that the 25-character long string actually takes up 26 characters of the array because of the null terminating zero.
When working with strings and arrays, it is very important to work within the bounds of strings or arrays. In the example sketch, an array was created, which was 40 characters long, in order to allocate the memory that could be used to manipulate strings.
If the array was made too small and we tried to copy a string that is bigger than the array to it, the string would be copied over the end of the array. The memory beyond the end of the array could contain other important data used in the sketch, which would then be overwritten by our string. If the memory beyond the end of the string is overrun, it could crash the sketch or cause unexpected behavior.