Project 1: Dynamic Memory Allocation Solution



Assignment ID: proj1

File(s) to be submitted: proj1.cpp

***** This assignment must correctly compile and run on the ranger system using the g++ compiler *****

Objectives: 1) Use pointers; 2) Dynamically allocate memory; 3) Read and write files; 4) Use value-returning functions.

Project description:

In this assignment you will have the opportunity to recall what you’ve previously learned about pointers, value returning functions, and file processing. You will write a small program that simulates just in time memory allocation, by dynamically allocating an array, and then reallocating it as the size of the input reaches the array’s capacity.


  1. Your program must contain the three functions listed below, in a single file named proj1.cpp:

    1. main – This function must appear first in your project cpp file, and will perform the following tasks:

      • Read an input file (must be named nums.txt) having the following format:

        1. First line: An integer value representing the initial size of the array

        1. Second line: A floating value that is the percentage by which the array should be expanded when its capacity is reached (i.e., if a 25% expansion is desired, this value would be 0.25).

        1. Remainder of the file: A set of integers (one per line) to be read into the array

      • Validate number of array elements to allocate: This number must be between 100 and 350 and must be in increments of 50 (100, 150, 200, 250, …). If the value is outside these specifications, print the word “Error” and exit the program. If a valid array size is read, continue as shown below.

      • Dynamically allocate an array with the number of elements specified, by calling the function allocateArray (described below). After allocating the array, write to stdout and to the output file (must be named out.txt) the number of elements allocated.

      • Read the remaining integers from the input file (one at a time), and add each to the array. ** You may not read the input file more than once and you may not read the values into a container to process later. You must process the file as you go.**

      • Each time the array capacity is reached, call the calcAvg function and print (to stdout and the output file) the count of elements, and the average of the integers read up to that point (as a double); and invoke function allocateArray to increase the size of the array by the factor specified in the input file, and continue reading the integers in the input file until all input has been processed.

      • After the last integer in the file is read and placed into the array, output the following to stdout and the output file: the size of the array, the number of integers read, and the average of those integers.

      • Example (assume lines one and two of the input file are 200 and 0.25 respectively):

        1. Allocate an array with 200 elements, and output this value to stdout and to the output file.

        1. Once you have read and inserted the 200th integer into the array, output the array size, count of items read, and the average of the values read so far, and invoke allocateArray to expand the array size by 25% – The new size is 250 (200 * 1.25).

        1. Continue to process the file. Upon inserting the 250th item (reaching the new capacity of the array), repeat ii. above, to create an array of size 312 (250 * 1.25 truncated).

        1. Repeat this process until the input file has no more integers. Each time the capacity is reached print the number of elements and average, and expand the array.

        1. Once the end of file is reached, print the array size (it will likely be greater than the number of integers read in), the number of elements read, and the average of those numbers.

      • Prior to exiting the program, deallocate all dynamically allocated memory. You may not rely on program termination for memory deallocation.

    1. allocateArray – This function dynamically allocates memory for an array, and when necessary copies elements from the old array to the new and deallocates the memory of the array being expanded. It returns a pointer to the newly allocated array. Its details follow:

      • Input parameters:

        1. A pointer to a dynamic array of integers (the array being outgrown) or NULL/nullptr

        1. A pointer to an integer representing the size of the array.

        1. A double indicating the percentage amount (expressed as a decimal) by which the array should be expanded (50% would be expressed as 0.5).

      • Processing and output– This function must be able to handle calls to create the initial array, as well as to expand an existing array. In the initial case, it should be invoked with a NULL pointer initially (there is not yet an array in existence), along with a pointer to the (initial) desired array size. In subsequent calls the function should allocate a new array, larger by the percentage factor of the parameter). The new size should be cast as int to truncate the fractional part. It should also copy the existing data to the new array, deallocate the old array, update the size of the array, and return the integer pointer to the newly allocated array.

    1. calcAvg – This function accepts as input parameters the dynamic array (an int pointer), and the number of values that have been read into it (an int), and returns the calculated average (as a double).

  1. Your output format MUST MATCH EXACTLY the output in this specification – this means the verbiage, line spacing, character spacing (do not use tabs – only a single space between elements) – the actual values will vary, based on the contents of the input file. Use cout unformatted for all output. The output below is from processing the sample output file provided with the assignment specification:

  1. Test your program – Use different input files and choose different starting array sizes and expansion factors. See rubric section.

  1. Code comments – Add the following comments to your code:

  • A section at the top of the source file(s) with the following identifying information:

Your Name

CSCI 3110-00X (your section #)

Project #X

Due: mm/dd/yy

  • Below your name add comments in each file that gives an overview of the program or class.

  • Place a one or two-line comment above each function that summarizes the purpose of the function.

5. Rubric


Points Off

main: Input filename


main: Output filename


main: Validation of initial array size


main: Initial array allocation (allocated from function call)


main: File processing loop


main: Subsequent array allocation (timing and correctness of call)


main: Intermediate averages (timing and correctness of call)


main: All required output to stdout and file


main: Deallocate memory

-5 (each time)

allocateArray: Initial allocation and return


allocateArray: Subsequent allocation (new size and correctness)


allocateArray: Subsequent allocation (copy)


allocateArray: Subsequent allocation (deallocation)


allocateArray: Subsequent allocation (modified and returned values)


calcAvg: Correctness and return


general: Function signatures per specification (name, return type, number/type of parameters)

-5 (per item)

general: Does not compile (on ranger using Linux g++ compiler)


general: Other


error: Content is protected !!