Section 3.2 Strings of Characters.

In all programs seen until now, we have used only numerical variables, used to express exclusively numbers. But in addition to numerical variables there also exist strings of characters, that allow us to represent successions of characters, like words, sentences, names, texts, et cetera. Until now we have only used them as constants, but we have never considered variables able to contain them.

In C++ there is no specific elemental variable type to store strings of characters. In order to fulfill this feature we can use arrays of type char, which are successions of char elements. Remember that this data type (char) is the one used to store a single character, for that reason an array of them is used to make strings of single characters.

For example, the following array (or string of characters):

char jenny [20];

We could represent jenny (an array of 20 elements of type char) storing the strings of characters "Hello" and "Merry Christmas" in the following way:

Initialization of strings

Because strings of characters are ordinary arrays they fulfill all teir same rules. For example, if we want to initialize a string of characters with predetermined values we can do it in a similar way to any other array:

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

Nevertheless, string of characters have an additional way to initialize its values: using constant strings.

In the expressions we have used in examples of previous chapters there have already appeared several times constants that represented entire strings of characters. These are specified enclosed between double quotes ("), for example:

"the result is: "

Unlike single quotes (') which allow to specify single character constants, double quotes (") are constants that specify a succession of characters. These strings enclosed between double quotes have always a null character ('\0') automatically appended at the end.

Therefore we could initialize the string mystring with values by any of these two ways:

char mystring [] = { 'H', 'e', 'l', 'l', 'o', '\0' };
char mystring [] = "Hello";

Before going further, I notice to you that the assignation of multiple constants like double-quoted constants (") are only valid when initializing the array, that is, at the moment when declared. Expressions within the code like:

mystring = "Hello";
mystring[] = "Hello";

mystring = { 'H', 'e', 'l', 'l', 'o', '\0' };

At the moment of initializing an Array it is a special case, since it is not an assignation, although the same equal sign (=) is used. Anyway, have always present the rule previously underlined.

Assigning values to strings

mystring[0] = 'H';
mystring[1] = 'e';
mystring[2] = 'l';
mystring[3] = 'l';
mystring[4] = 'o';
mystring[5] = '\0';

strcpy (string1, string2);

strcpy (mystring, "Hello");

// setting value to string
#include <iostream.h>
#include <string.h>

int main ()
{
  char szMyName [20];
  setstring (szMyName,"J. Soulie");
  cout << szMyName;
  return 0;
}

Look how we have needed to include <string.h> header in order to be able to use function strcpy.

Although we can always write a simple function like the following setstring with the same operating than cstring's strcpy:

// setting value to string
#include <iostream.h>

void setstring (char szOut [], char szIn [])
{
  int n=0;
  do {
    szOut[n] = szIn[n];
    n++;
  } while (szIn[n] != 0);
}

int main ()
{
  char szMyName [20];
  setstring (szMyName,"J. Soulie");
  cout << szMyName;
  return 0;
}

Another frequently used method to assign values to an array is by using directly the input stream (cin). In this case the value of the string is assigned by the user during program execution.

When cin is used with strings of characters it is usually used with its getline method, that can be called following this prototype:

cin.getline ( char buffer[], int length, char delimiter = ' \n');

The following example repeats whatever you type on your keyboard. It is quite simple but serves as example on how you can use cin.getline with strings:

// cin with strings
#include <iostream.h>

int main ()
{
  char mybuffer [100];
  cout << "What's your name? ";
  cin.getline (mybuffer,100);
  cout << "Hello " << mybuffer << ".\n";
  cout << "Which is your favourite team? ";
  cin.getline (mybuffer,100);
  cout << "I like " << mybuffer << " too.\n";
  return 0;
}

Notice how in both calls to cin.getline we used the same string identifier (mybuffer). What the program does in the second call is simply step on the previous content of buffer by the new one that is introduced.

If you remember the section about communication through the console, you will remember that we used the extraction operator (>>) to receive data directly from the standard input. This method can also be used instead of cin.getline with strings of characters. For example, in our program, when we requested an input from the user we could have written:

cin >> mybuffer;

• It can only receive single words (no complete sentences) since this method uses as delimiter any occurrence of a blank character, including spaces, tabulators, newlines and carriage returns.
• It is not allowed to specify a size for the buffer. What makes your program unstable in case that the user input is longer than the array that will host it.

Converting strings to other types

• atoi: converts string to int type.
• atol: converts string to long type.
• atof: converts string to float type.

// cin and ato* functions
#include <iostream.h>
#include <stdlib.h>

int main ()
{
  char mybuffer [100];
  float price;
  int quantity;
  cout << "Enter price: ";
  cin.getline (mybuffer,100);
  price = atof (mybuffer);
  cout << "Enter quantity: ";
  cin.getline (mybuffer,100);
  quantity = atoi (mybuffer);
  cout << "Total price: " << price*quantity;
  return 0;
}

Functions to manipulate strings

strcat:   char* strcat (char* dest, const char* src);

Appends src string at the end of dest string. Returns dest.

strcmp:   int strcmp (const char* string1, const char* string2);

Compares strings string1 and string2. Returns 0 is both strings are equal.

strcpy:   char* strcpy (char* dest, const char* src);

Copies the content of src to dest. Returns dest.

strlen:   size_t strlen (const char* string);

Returns the length of string.

NOTE: char* is the same as char[]

Check the C++ Reference for extended information about these and other functions of this library.

© The C++ Resources Network, 2000-2001 - All rights reserved

Previous: 3-1. Arrays

index

Next: 3-3. Pointers