Difference between String and string

Using Arduino Programming Questions
1

1. The role of c_str() method is not really clear to me when it says:
The c_str() converts the contents of a String as a C-style, null-terminated string. It returns a pointer to the C-style version of the invoking String. Would appreciate to see the answer of the following question with example:

What is the difference between C-style string and String-style string?

2. I experimented the following codes to understand the role/application of c_str() method without any conclusion.

void setup() 
{
  Serial.begin(9600);
  String myString = "Forum";
  char *ptr = myString.c_str();//ptr holds base address of array not of type String
  Serial.println(*(++ptr)); //shows: o (next character after F of Forum)
}

void loop() 
{

}
2

A String is an object created using the String library. Such Strings may be used with the functions provided by the String library

A C-style string is an array of chars terminated by a zero. Such strings may be used with the C string functions

c_str() is a String function so operates on a String
strstr() is a string function so operates on strings

if (strstr(red.c_str(), "red") != NULL)

first converts the String to a string then test whether the string contains the required text

2 Likes
3

@robogio

The following code @UKHeliBob of post #10 works well even you enter 5 or more characters (including Newline character or carriage return character) from the Serial Monitor when the comparison will be made only with three character string red.

1. You are sending r e d Newline characters from Serial Monitor. The readString() method appends null-character, A null-character is automatically added at the end. Now, the String variable red contains five characters: r e d Newline Null.

2. The following equality comparison fails for reasons explained in post #11.

 if (red == "red")

3. The red.c_str() method solves the problem in the following ways:
(1) The red.c_str() method converts the glued String-style string composed of red\n\0 into C-style string like: {'r', 'e', 'd', '\n', '\0'} where individual characters could be easily accessed by index/pointer (cptr) which is provided by the following code:

char *cptr = red.c_str();
The pointer variable cptr holds the base address 
of the array space that contains the characters: 'r', 'e', 'd', '\n', '\0'
as individual accessible items.

(2) The strstr() function compares characters (one-by-one) of the array pointed by cptr with the source characters of red. When the matching occurs, the process ends and the following message appears on the Serial Monitor. (The Newline character (0x0A = '\n') and Null-character (0x00 = '\0') are never compared.)

$101=152

4. Sketch using c_str() method and strstr() function:

String red;         // incoming serial byte

void setup() 
{
   Serial.begin(9600);
  while (!Serial) 
  {
     ; 
  }
}

void loop() 
{
  while (Serial.available() > 0) 
{
    red = Serial.readString(); //store string
    //if (red == "red") 
    if(strstr(red.c_str(), "red") != NULL)
    {
      Serial.println("$101=152");
    }
  }
}
4

No it doesn't
Where did you get that idea ?

5

1. I guessed from the functioning of substring() method which adds null-character.

2. You are right! the readString() method does not add null-character.

resdString
resdString901×169 11.4 KB

3. But there should be a null-character at the end of r e d Newline as it is String-type string, Then, who adds this null-character at the end of r e d Newline that OP has sent from Serial Monitor and got saved in String-type variable red?

6

You have made the same mistake again. The String is not zero terminated or rather, as it is an object of the String class it can only be used with the String functions anyway, so it does not matter whether it is zero terminated or not because those functions do not need to use the zero termination as an end of string marker in the same way that the C str* functions do

The zero termination is added by the c_str() function when it converts from a String to a string and the resultant string can thus be used by the C str* functions

7

But the following codes show the message Arduino on the Serial Monitor which implies (as I understand) that there is a null-character as the last element of "Arduino" that is assigned to a String-type variable mystring.

String mString = "Arduino";
Serial.println(myString);  //shows: Arduino
8

@UKHeliBob
Can I request that this thread be split! this discussion between you and @GolamMostafa is only adding noise to OPs actual request! (No offence intended! :wink: )

1 Like
9

@sherzaad
The OP has probably got his solution. Now, we are discussing something that is in line with the sprint (the String Class) of the thread from which OP would be benefitted as well!

Let people take the opportunity of being educated from the resourceful person!

10

NOPE

ur discussing my proposed solution implementation! nothing to do with OP's request!!!!

hence my request to split this thread to @UKHeliBob

that way YOU can still be "educated" without clogging OP's thread! :wink:

11

You have not explained the functioning of the strstr() function andd c_str() method to the OP; so, it has not added much to his knowledgebase. You have not also reacted to the following comment @UKHeliBob.

12

This discussion was split from Trying to read from serial and print "$101=152" if incoming serial string is = "red. Not working why?" as it had moved away from the topic of the original

1 Like
13

technically the String class does maintain a null termination and the c_str() method just returns the buffer.

	const char* c_str() const { return buffer; }

This is of course an implementation detail and the whole idea of classes is to abstract and hide the underlying implementation. You should not have to assume the String class does actually manage a cString internally.

2 Likes
14

None taken

15

Is it not a "user data type (the ClassName)" created somewhere in the Library using class keyword? For example:

String myString;
Where:
myString is an object/variable of type String (the ClassName).
16

this does not imply that.

for the first line you have an initializer that is a cString (so null terminated) as per C++ standard. But nothing tells you (implementation details) that this null char is copied over when the String is instantiated.

for the second line It just means that the println() method exposed by Serial (inherited from the Print class) can handle a String object. The way it manages that is unknown unless you look into the source code.

if you look at the source code it does this:

size_t Print::print(const String &s)
{
  return write(s.c_str(), s.length());
}

so it requests a cString compatible buffer from the instance and writes length bytes out. So technically you don't even need to know if the c_str() element is null terminated or not as the right count of bytes is passed to write()

As a side effect, this could let you add null characters into the String buffer and the print would not stop at the null char. Something the String class had to deal with.

17

Yes, hence

and hence

The important thing to take away from this discussion is that a String is not a string

Has your question

been answered yet ?

18

so long story short

What is the difference between C-style string and String-style string?

  • a C-style string also known as cString is a null terminated char array. the standard C libraries offers functions to work on those, see stdlib.h and string.h

  • a String style string is an instance of the String class and you don't have to know how the class represents the text, you just use the String class methods to handle that text. those methods are described in the class documentation

19

Should there be a null-character at the end of a string to print it. Does this null-character marks the end of string and thus stops the printing process?

In MSDOS's int 21h (09h) Programming, it was necessary to terminate the string by '$' (24h) to mark the end-of-string; otherwise printing process would continue for ever!

20

that question does not mean anything :slight_smile:

what do you call a string? what matters is the type of that data and how the print() function you will call handles that type.

if you have a String instance then the code used for printing is

size_t Print::print(const String &s)
{
  return write(s.c_str(), s.length());
}

if you have a cString (null terminated char array) then the code executed is

size_t Print::print(const char str[])
{
  return write(str);
}

which calls this code (defined in the .h)

    size_t write(const char *str) {
      if (str == NULL) return 0;
      return write((const uint8_t *)str, strlen(str));
    }

so in case of a cString you depend on strlen() which does expect a null terminated char array to know how many bytes to send out

1 Like