The string Class(PART 1)

Constructing a String 

Table 16.1    string Class Constructors

Constructor	Description
(#1)    string(const char * s)	Initializes a string object to the NBTS pointed to by s.
(#2)    string(size_type n, char c)	Creates a string object of n elements, each initialized to the character c.
(#3)    string(const string & str)	Initializes a string object to the string object str (copy constructor).
(#4)    string()	Creates a default string object of 0 size (default constructor).
(#5)    string(const char * s, size_type n)	Initializes a string object to the NBTS pointed to by s and continues for n characters, even if that exceeds the size of the NBTS.
(#6)    template<class Iter> string(Iter begin, Iter end)	Initializes a string object to the values in the range [begin, end), where begin and end act like pointers and specify locations; the range includes begin and is up to but not including end.
(#7)    string(const string & str, size_type pos, size_type n = npos)	Initializes a string object to the object str, starting at position pos in str and going to the end of str or using n characters, whichever comes first.
(#8)    string(string && str) noexcept (C++11)	Initializes a string object to the string object str; str may be altered (move constructor).
(#9)    string(initializer_list<char> il) (C++11)	Initializes a string object to the characters in the initializer list il.

// str1.cpp -- introducing the string class
#include <iostream>
#include <string>
// using string constructors

int main()
{
    using namespace std;
    string one("Lottery Winner!");     // ctor #1
    cout << one << endl;               // overloaded <<
    string two(20, '$');               // ctor #2
    cout << two << endl;
    string three(one);                 // ctor #3
    cout << three << endl;
    one += " Oops!";                   // overloaded +=
    cout << one << endl;
    two = "Sorry! That was ";
    three[0] = 'P';
    string four;                       // ctor #4
    four = two + three;                // overloaded +, =
    cout << four << endl;
    char alls[] = "All's well that ends well";
    string five(alls,20);              // ctor #5
    cout << five << "!\n";
    string six(alls+6, alls + 10);     // ctor #6
    cout << six  << ", ";
    string seven(&five[6], &five[10]); // ctor #6 again
    cout << seven << "...\n";
    string eight(four, 7, 16);         // ctor #7
    cout << eight << " in motion!" << endl;
    // std::cin.get();
    return 0; 
}

The sixth constructor has a template argument:
template<class Iter> string(Iter begin, Iter end);
The intent(含义) is that begin and end act like pointers pointing to two locations in memory.
(In general, begin and end can be iterators, generalizations of pointers extensively(广泛)
used in the STL.) The constructor then uses the values between the locations pointed to
by begin and end to initialize the string object it constructs.The notation [begin, end),
borrowed from mathematics, means the range includes begin but doesn’t include end.

That is, end points to a location one past the last value to be used. Consider the following
statement:
string six(alls+6, alls + 10); // ctor #6
Because the name of an array is a pointer, both alls + 6 and alls + 10 are type
char *, so the template is used with Iter replaced by type char *.The first argument
points to the first w in the alls array, and the second argument points to the space following
the first well.Thus, six is initialized to the string "well". Figure 16.1 shows how
the constructor works.

Now suppose you want to use this constructor to initialize an object to part of another
string object—say, the object five.The following does not work:
string seven(five + 6, five + 10);
The reason is that the name of an object, unlike the name of an array, is not treated as
the address of an object, hence five is not a pointer and five + 6 is meaningless. However,
five[6] is a char value, so &five[6] is an address and can be used as an argument
to the constructor:
string seven(&five[6], &five[10]);// ctor #6 again

The seventh constructor copies a portion of one string object to the constructed
object:
string eight(four, 7, 16); // ctor #7
This statement copies 16 characters from four to eight, starting at position 7 (the
eighth character) in four.

 

The string Class Input

Another useful thing to know about a class is what input options are available. For C-style
strings, recall, you have three options:

char info[100];
cin >> info; // read a word
cin.getline(info, 100); // read a line, discard(丢弃) \n
cin.get(info, 100); // read a line, leave \n in queue

For string objects, recall, you have two options:

string stuff;
cin >> stuff; // read a word
getline(cin, stuff); // read a line, discard \n

Both versions of getline() allow for an optional argument(可选参数) that specifies which character
to use to delimit(确定边界) input:

cin.getline(info,100,':'); // read up to :, discard :
getline(stuff, ':'); // read up to :, discard :

The main operational difference is that the string versions automatically size the target
string object to hold the input characters:

char fname[10];
string lname;
cin >> fname; // could be a problem if input size > 9 characters
cin >> lname; // can read a very, very long word
cin.getline(fname, 10); // may truncate(截断) input
getline(cin, fname); // no truncation

The automatic sizing feature allows the string version of getline() to dispense with(免除)
the numeric parameter(数值参数) that limits the number of input characters to be read.
A design difference is that the C-style string input facilities are methods of the
istream class, whereas the string versions are standalone(独立的) functions.That’s why cin is an
invoking(调用) object for C-style string input and a function argument for string object input.

The getline() function for the string class reads characters from the input and
stores them in a string object until one of three things occurs:
1. The end-of-file is encountered, in which case eofbit of the input stream is set,
implying that both the fail() and eof() methods will return true.
2. The delimiting character (\n, by default) is reached, in which case it is removed
from the input stream but not stored.
3. The maximum possible number of characters (the lesser(较小的) of string::npos and the
number of bytes in memory available for allocation) is read, in which case failbit
of the input stream is set, implying that the fail() method will return true.

Because the
input functions for string objects work with streams and recognize the end-of-file, you
can also use them for file input. Listing 16.2 shows a short example that reads strings from
the file. It assumes that the file contains strings separated by the colon(冒号) character and uses
the getline() method of specifying a delimiter(分隔符). It then numbers(编号) and displays the strings,
one string to an output line.

// strfile.cpp -- read strings from a file
#include <iostream>
#include <fstream>
#include <string>
#include <cstdlib>
int main()
{
     using namespace std;
     ifstream fin;
     fin.open("tobuy.txt");
     if (fin.is_open() == false)
     {
        cerr << "Can't open file. Bye.\n";
        exit(EXIT_FAILURE);
     }
     string item;
     int count = 0;
     
     getline(fin, item, ':');
     while (fin)  // while input is good
     {
        ++count;
        cout << count <<": " << item << endl;
        getline(fin, item,':');     
     }
     cout << "Done\n";
     fin.close();
     return 0;
}

Here is a sample tobuy.txt file:
sardines:chocolate ice cream:pop corn:leeks:
cottage cheese:olive oil:butter:tofu:
Typically, for the program to find the text file, the text file should be in the same directory
as the executable(可执行) program or sometimes in the same directory(目录) as the project file. Or
you can provide the full path name. On a Windows system, keep in mind that in a C-style
string the escape sequence \\ represents a single backslash(反斜杠):

fin.open("C:\\CPP\\Progs\\tobuy.txt"); // file = C:\CPP\Progs\tobuy.txt

Note that with : specified as the delimiting character(分界符), the newline character becomes
just another regular character.Thus, the newline character at the end of the first line of
the file becomes the first character of the string that continues as "cottage cheese".
Similarly, the newline character at the end of the second input line, if present, becomes
the sole(唯一的) content of the ninth input string.