C++ Primer Plus

Developing applications often requires the use of temporary files whose lifetimes are transient and must be controlled by the program. Have you ever thought about how to go about this in C++? It’s really quite easy to create a temporary file, copy the contents of another file, and delete the file. First of all, you need to come up with a naming scheme for your temporary file(s). But wait...how can you ensure that each file is assigned a unique name? The tmpnam() standard function declared in cstdio has you covered:

char* tmpnam( char* pszName );

The tmpnam() function creates a temporary name and places it in the C-style string that is pointed to by pszName. The constants L_tmpnam and TMP_MAX, both defined in cstdio, limit the number of characters in the filename and the maximum number of times tmpnam() can be called without generating a duplicate filename in the current directory. The following example generates 10 temporary names:

#include

#include

int main()

{

    using namespace std;

    cout << "This system can generate up to " << TMP_MAX

         << " temporary names of up to " << L_tmpnam

         << " characters.\n";

    char pszName[ L_tmpnam ] = {'\0'};

    cout << "Here are ten names:\n";

    for( int i=0; 10 > i; i++ )

    {

        tmpnam( pszName );

        cout << pszName << endl;

    }

    return 0;

}

More generally, by using tmpnam(), you can now generate TMP_NAM unique filenames with up to L_tmpnam characters per name. The names themselves depend on the compiler. You can run this program to see what names your compiler comes up with.

Incore Formatting

The iostream family supports I/O between a program and a terminal. The fstream family uses the same interface to provide I/O between a program and a file. The C++ library also provides an sstream family, which uses the same interface to provide I/O between a program and a string object. That is, you can use the same ostream methods you’ve used with cout to write formatted information into a string object, and you can use istream methods such as getline() to read information from a string object. The process of reading formatted information from a string object or of writing formatted information to a string object is termed incore formatting. Let’s take a brief look at these facilities. (The sstream family of string support supersedes the strstream.h family of char-array support.)

The sstream header file defines an ostringstream class that is derived from the ostream class. (There is also a wostringstream class based on wostream, for wide character sets.) If you create an ostringstream object, you can write information to it, which it stores. You can use the same methods with an ostringstream object that you can with cout. That is, you can do something like the following:

ostringstream outstr;

double price = 380.0;

char * ps = " for a copy of the ISO/EIC C++ standard!";

outstr.precision(2);

outstr << fixed;

outstr << "Pay only CHF " << price << ps << endl;

The formatted text goes into a buffer, and the object uses dynamic memory allocation to expand the buffer size as needed. The ostringstream class has a member function, called str(), that returns a string object initialized to the buffer’s contents:

string mesg = outstr.str();    // returns string with formatted information

Using the str() method “freezes” the object, and you can no longer write to it.

Listing 17.21 provides a short example of incore formatting.

Listing 17.21. strout.cpp

// strout.cpp -- incore formatting (output)

#include

#include

#include

int main()

{

    using namespace std;

    ostringstream outstr;   // manages a string stream

    string hdisk;

    cout << "What's the name of your hard disk? ";

    getline(cin, hdisk);

    int cap;

    cout << "What's its capacity in GB? ";

    cin >> cap;

    // write formatted information to string stream

    outstr << "The hard disk " << hdisk << " has a capacity of "

            << cap << " gigabytes.\n";

    string result = outstr.str();   // save result

    cout << result;                 // show contents

    return 0;

}

Here’s a sample run of the program in Listing 17.21:

What's the name of your hard disk? Datarapture

What's its capacity in GB? 2000

The hard disk Datarapture has a capacity of 2000 gigabytes.

The istringstream class lets you use the istream family of methods to read data from an istringstream object, which can be initialized from a string object. Suppose facts is a string object. To create an istringstream object associated with this string, you can use the following:

istringstream instr(facts);     // use facts to initialize stream

Then you use istream methods to read data from instr. For example, if instr contained a bunch of integers in character format, you could read them as follows:

int n;

int sum = 0;

while (instr >> n)

    sum += n;

Listing 17.22 uses the overloaded >> operator to read the contents of a string one word at a time.

Listing 17.22. strin.cpp

// strin.cpp -- formatted reading from a char array

#include

#include

#include

int main()

{

    using namespace std;

    string lit = "It was a dark and stormy day, and "