8.5. C-Strings and Scope

During my career as a software engineer, I periodically interviewed for new positions. Interviews, especially second interviews, often include engineers who ask technical questions. During an interview, a software engineer wrote the following code fragment on the blackboard. He wrote a few distracting statements in place of the ellipses and then asked, "What's wrong with this code?"

char* get_name()
{
	char	name[100];
	cin.getline(name, 100);
		.
		.
		.
	return name;
}

Give yet? Here's the problem: the function get_name returns the address of the local variable name, which the program deallocates when the function returns. What becomes of that deallocated memory depends on the program and the computer running it. The program may reallocate the memory and overwrite it very quickly. However, the program that calls get_name is likely still using (or, more accurately, trying to use) the data stored in name. If the program runs correctly once, there's no guarantee that the next call will succeed. Even if the program consistently runs correctly on one computer, there's no guarantee it will work on another. The following figures illustrate three solutions.

Solutions And Consequences

There is no one right solution to solve the problem of a function returning a local C-string. There are several possible solutions, each with advantages and disadvantages. So, we can only choose an appropriate solution in the context of a specific problem. As a practicing computer scientist, one of your tasks is weighing the advantages against the disadvantages so that your chosen solution is the best for a given problem.

static Data

char* get_name()
{
	static	char	name[100];
	cin.getline(name, 100);
		.
		.
		.
	return name;
}

The static data solution is straightforward to use, and because it only allocates data once, it's also fast. Nevertheless, static data does have some disadvantages, albeit mostly minor ones. Early programming languages like FORTRAN didn't have automatic variables; the program allocated the memory for all variables at load time. Modern programming languages that support automatic variables run the same programs using far less memory than those older languages. Making a few variables static won't greatly increase the program's memory requirements, but making all variables static certainly would.

Functions that have static variables cannot be recursive or reentrant. We briefly covered recursive functions in Chapter 6, and reentrancy is a property needed by specialized functions most often seen in operating systems and is beyond this course's scope. Both issues only concern a few specialized functions and are easily ignored. But there is one aspect of static data that we must understand.

void client() { char* data; data = get_name(data); . . . data = get_name(data); . . . }		void client() { char* data[10]; data[0] = get_name(data); data[1] = get_name(data); . . . }
(a)		(b)

Dynamic Data

char* get_name(int size) { char* name = new char[size]; cin.getline(name, size); . . . return name; }
(a)	(b)

Dynamic data, just like static data, has advantages and disadvantages. The new operator allocates a new block of memory for each C-string that get_name reads and returns. Therefore, each returned C-string has a unique memory location.

void client() { char* data; data = get_name(100); . . . data = get_name(100); . . . }		void client() { char* data[10]; data[0] = get_name(100); data[1] = get_name(100); . . . }
(a)		(b)

Calling-Scope Data

void client() { char data[100]; . . get_name(data, 100); // use data }	char* get_name(int size, char* name) { cin.getline(name, size); . . . return name; }
(a)	(b)
(c)

char* get_name(int size, char* name = nullptr)
{
	if (name == nullptr)
		name = new char[size];

	cin.getline(name, size);
		. . .
	return name;
}

void client()
{
	char* data = get_name(100);
	// use data
		.
		.
		.
		.
}