Study Guide 7 Answers

The memory needed to store the array named data is allocated and deallocated based on scope. But the problem is that the memory is deallocated, not that the variable goes out of scope. We'll look at three ways of fixing the error below. All three corrections use a variable named data and it does go out of scope when the get_data function ends, but the memory in the solutions is not deallocated when the function ends.

int* get_data()
{
	int data[100];
	// fill the data array
	return data;
}

1. The function returns the address of data (the syntax is correct - the name of an array is an address), but datais a local automatic variable whose memory is deallocated when the function ends. The function caller is left trying to access deallocated memory that is available for reuse.
2. There are three ways to fix the problem (see Returning One-Dimensional Arrays From Functions for example code fragments)
   1. Make data static (i.e., add the "static" keyword to the variable definition). The array name data still goes out of scope (and becomes inaccessible) when the function ends. But the memory is not deallocated because the array is static rather than automatic.
   2. Define the array in the calling scope and pass it in as a pointer argument. The argument named data is a local variable and goes out of scope when the function returns, but the array that data points at is defined in a different scope and is not deallocated.
   3. Allocate the array dynamically with the new operator. The local variable data goes out of scope when the function ends but the memory allocated by new is not deallocated.

int* get_data()
{
	static int data[100];
	// fill the data array
	return data;
}

int* get_data(int* data)
{
	// fill the data array
	return data;
}
 

int* get_data()
{
	int* data = new int[100];
	// fill the data array
	return data;
}

See sg02_answers, question 28.

void f(foo* data, int x, int y)
{
	. . . 
}

foo temp = data[x];
data[x] = data[y];
data[y] = temp;
 

The type of the array is foo, so the type of the temporary variable, temp in this example, must also be foo - int will not work. The name of the temporary variable is not significant.

• sizeof(data) is the total number of bytes in data: bytes/character * the number of characters in the array.
• sizeof(char) is the number of bytes in single character: bytes/character.
• Unit analysis: (bytes/character * the number of characters in the array) / (bytes/character)

void copy(char* destination, char* source, int size)
{
	for (int i = 0; i < size; i++)
		destination[i] = source[i];
}

• source and destination must be the same type
• As the previous problem demonstrated, we can't calculate the size of source, so the size must be a function parameter
• destination must be large enough to hold the data copied to it; if its size is not the same as source, it must be passed as a fourth parameter

//double average(double[] scores, int size)
double average(double* scores, int size)
{
	double sum = 0;
	for (int i = 0; i < size; i++)
		sum += scores[i];
	return sum / size;
}

Some issues to consider:

• The accumulator (sum in the above code) must be type double - the function is summing double-values, so making it an int can cause a truncation error
• The accumulator must be initialized to 0
• The accumulator must be defined and initialized outside and before the for-loop; otherwise, it is reinitialized during each iteration of the loop and loses the previous values
• You can make the accumulator static but doing so doesn't add value to the function
• The accumulator (sum) and the size are scalar variables - not arrays
• As demonstrated by previous questions, sizeof does not work when an array is passed as a pointer to a function
• you can add additional variables:

  temp = scores[i];
  sum = sum + temp;

  but doing so adds no value to the program