Can I Make String Array in C a Char Array Again

Graphic symbol sequences

The cord grade has been briefly introduced in an earlier chapter. It is a very powerful form to handle and manipulate strings of characters. Nonetheless, because strings are, in fact, sequences of characters, we tin can represent them also as plain arrays of elements of a character type.

For example, the post-obit assortment:

is an array that can store up to 20 elements of type char. It can be represented as:

Therefore, this array has a capacity to store sequences of up to 20 characters. Merely this chapters does non demand to be fully exhausted: the array tin can also conform shorter sequences. For example, at some point in a plan, either the sequence "Howdy" or the sequence "Merry Christmas" tin be stored in foo, since both would fit in a sequence with a chapters for 20 characters.

By convention, the end of strings represented in character sequences is signaled by a special character: the null character, whose literal value tin exist written equally '\0' (backslash, zero).

In this case, the assortment of xx elements of type char called foo can be represented storing the character sequences "Hello" and "Merry Christmas" equally:

Detect how subsequently the content of the string itself, a nil character ('\0') has been added in order to bespeak the finish of the sequence. The panels in gray color represent char elements with undetermined values.

Initialization of zilch-terminated character sequences

Because arrays of characters are ordinary arrays, they follow the same rules as these. For case, to initialize an array of characters with some predetermined sequence of characters, we can practise it just like any other assortment:

char myword[] = { 'H', 'e', 'l', 'l', 'o', '\0' };

The to a higher place declares an array of half dozen elements of type char initialized with the characters that class the give-and-take "Hello" plus a null graphic symbol '\0' at the end.

But arrays of character elements have another style to be initialized: using cord literals direct.

In the expressions used in some examples in previous capacity, cord literals have already shown up several times. These are specified by enclosing the text between double quotes ("). For instance:

This is a string literal, probably used in some earlier example.

Sequences of characters enclosed in double-quotes (") are literal constants. And their blazon is, in fact, a null-terminated array of characters. This means that string literals always have a null character ('\0') automatically appended at the end.

Therefore, the array of char elements called myword can be initialized with a null-terminated sequence of characters by either one of these ii statements:

1 2

char myword[] = { 'H', 'e', 'fifty', '50', 'o', '\0' }; char myword[] = "Hullo";

In both cases, the array of characters myword is declared with a size of vi elements of type char: the five characters that compose the word "Hullo", plus a final null character ('\0'), which specifies the terminate of the sequence and that, in the second case, when using double quotes (") information technology is appended automatically.

Please notice that here we are talking near initializing an array of characters at the moment it is being alleged, and not nearly assigning values to them later (one time they have already been declared). In fact, because string literals are regular arrays, they take the same restrictions equally these, and cannot exist assigned values.

Expressions (in one case myword has already been declared every bit in a higher place), such every bit:

ane 2

myword = "Bye"; myword[] = "Good day";

would not be valid, similar neither would be:

myword = { 'B', 'y', 'east', '\0' };

This is because arrays cannot be assigned values. Note, though, that each of its elements can be assigned a value individually. For case, this would be correct:

1 2 three 4

myword[0] = 'B'; myword[1] = 'y'; myword[ii] = 'e'; myword[3] = '\0';

Strings and null-terminated graphic symbol sequences

Plain arrays with nada-terminated sequences of characters are the typical types used in the C linguistic communication to correspond strings (that is why they are likewise known as C-strings). In C++, even though the standard library defines a specific type for strings (class string), all the same, plain arrays with aught-terminated sequences of characters (C-strings) are a natural mode of representing strings in the language; in fact, string literals still always produce goose egg-terminated character sequences, and not string objects.

In the standard library, both representations for strings (C-strings and library strings) coexist, and almost functions requiring strings are overloaded to support both.

For example, cin and cout support null-terminated sequences directly, allowing them to be directly extracted from cin or inserted into cout, just like strings. For example:

one 2 3 4 5 6 7 8 nine 10 eleven 12 xiii 14 15 16 17 eighteen 19

// strings and NTCS: #include <iostream> #include <string> using namespace std; int master () { char question1[] = "What is your proper name? "; cord question2 = "Where practise you alive? "; char answer1 [lxxx]; string answer2; cout << question1; cin >> answer1; cout << question2; cin >> answer2; cout << "How-do-you-do, " << answer1; cout << " from " << answer2 << "!\n"; render 0; }

What is your proper name? Homer Where do you lot live? Greece Hullo, Homer from Hellenic republic!

In this example, both arrays of characters using null-terminated sequences and strings are used. They are quite interchangeable in their use together with cin and cout, only there is a notable divergence in their declarations: arrays have a fixed size that needs to be specified either implicit or explicitly when alleged; question1 has a size of exactly 20 characters (including the terminating cypher-characters) and answer1 has a size of fourscore characters; while strings are simply strings, no size is specified. This is due to the fact that strings accept a dynamic size determined during runtime, while the size of arrays is determined on compilation, earlier the program runs.

In any example, null-terminated character sequences and strings are easily transformed from one another:

Null-terminated graphic symbol sequences tin can be transformed into strings implicitly, and strings can exist transformed into nada-terminated character sequences by using either of string's member functions c_str or data:

i two 3 4

char myntcs[] = "some text"; string mystring = myntcs; // catechumen c-cord to string cout << mystring; // printed as a library string cout << mystring.c_str(); // printed as a c-string

(note: both c_str and data members of cord are equivalent)

quinnthouree.blogspot.com

Source: https://www.cplusplus.com/doc/tutorial/ntcs/

Share this post