CS 311 Fall 2020 > Project 2

CS 311 Fall 2020
Project 2

Project 2 is due at 5 pm Tuesday, September 15 Thursday, September 17. It is worth 60 points.

Procedures

This project is to be done individually.

Turn in answers to the exercises below on the UA Blackboard Learn site, under Project 2 for this class.

Your answers should consist of the source code for Exercise A (file msarray.h). This should be attached to your homework submission.
Send only the above! I do not want project files or executables.
I may not look at your homework submission immediately. If you have questions, e-mail me.

Exercises (60 pts total)

Exercise A — Moderately Smart Array Class

Purpose

In this exercise, you will write an array class. It will not be quite as “smart” as it could be (std::vector is much smarter), but it will be much better than a built-in C++ array; for example, it knows its size, and has copy operations.

Key to this project is proper management of a resource in a class. Be sure you have no resource leaks, and that ownership and related issues are properly documented.

And as before, make your code high quality. In particular, follow the applicable coding standards.

Instructions

This project is to be done individually.

Implement a C++ class template that manages and allows access to a fixed-size array. The type of item in the array and the number of items in the array should be specified by the client code. Be sure to follow the coding standards. Standard 4A (“Requirements on template parameter types must be documented.”) now applies. You do not need to follow standards 4B, 4C, or 4D.

Name your class template MSArray, so that, for example, a MSArray whose items have type double would be declared as MSArray<double>.
Implement your class template in the file msarray.h. Since everything in this file will be a template, there should be no associated source file.
Your class template should act as if it maintains a single array with a given size and value type.
Include the following functions, and no others, in the public interface of your package:
- Default ctor: This should create a MSArray of size 8. All items in the array should be default-constructed.
- Dctor, copy ctor, move ctor, copy assignment, move assignment:
  - Be sure that the dctor frees any dynamically allocated memory.
  - The copy operations should create an entirely new copy of the data, so that modifying the copy does not change the original.
  - Write these functions as described in the slides (Invisible Functions II).
- 1-parameter ctor: parameter is a non-negative integer giving the number of items in the array. All items in the array should be default-constructed.
- 2-parameter ctor: first parameter is a non-negative integer giving the number of items in the array, as above. Second parameter is an item of the value type; each item in the array should be set to this value.
- Bracket operator: Given an integer subscript from 0 to size − 1 (where size is the number of items in the array), return a reference to the proper item.
- Member function size: no parameters. Returns the number of items in the array.
- Member function begin: no parameters. Returns the address of item 0 in the array (think “iterator”).
- Member function end: no parameters. Returns the address of the item one-past the end of the array (think “iterator”).
- Operators “==” and “!=”. Two MSArray objects with the same value type are equal if they have the same size and their corresponding items are all equal. Two MSArray objects with different value types cannot be compared.
- Operators “<”, “<=”, “>”, and “>=”. As above, two MSArray objects with different value types cannot be compared. For two MSArray objects with the same value type, these operators should use lexicographic order, which works like alphabetical order. So, when comparing MSArray objects a and b, if a[0] < b[0], then a < b. If a[0] > b[0], then a > b. Otherwise, we proceed to a[1] and b[1], and compare them similarly. If each item in a is equivalent to the corresponding item in b, and the size of a is less than that of b, then we should have a < b. Lastly, all of these operators should be consistent, so that, for example, a > b precisely when b < a, and a >= b when !(a < b).
Include the following member types, and no others, in the public interface of your package:
- value_type: the type of each item in the array.
- size_type: the type of the size of an array and also of an index into an array. Be sure to make a good choice for what this type is!
A const MSArray<T> should be one that does not allow modification of the items in its array. A non-const MSArray should allow such modification. Hint: This has implications for how you implement functions begin and end, as well as the bracket operator.
The == and != operators for MSArray should be usable for value types that do not define any comparison operators other than operator== and operator!=.
The <, >, <=, and >= operators for MSArray should be usable for value types that do not define any comparison operators other than operator<.
You may not use any C++ Standard Library classes or class templates in your implementation. (You may use simple types, like std::size_t, and functions or function templates, like std::swap, std::copy, std::equal, std::sort, etc.)
You may not create any new implicit type conversions. Hint: 1-parameter constructors, “explicit”.
As in Project 1, some parameter values may be illegal for some functions. You must deal with this somehow. The way you do it is up to you, but you must document how you did it.
Avoid unnecessary duplication of code.
- If a function returns internal data in modifiable form, and thus has both const and non-const versions, then it is acceptable to repeat the code in the function bodies. (For example, see the bracket operator in intarray.h.) But code duplication should be avoided in other cases.

Example Code

Here is some code using MSArray. Some of it will not compile, as noted.

MSArray<int> ia(8);           // Array of 8 ints
MSArray<int> iax;             // Another array of 8 ints
MSArray<double> da(40, 3.2);  // Array of 40 doubles; each is set to 3.2
MSArray x(8);                 // DOES NOT COMPILE; no template parameter

// Set all items (counter loop)
for (int c = 0; c < ia.size(); ++c)
{
    ia[c] = c * c;
}

// Range-based for-loop calls MSArray member functions begin, end
for (auto x : ia)
{
    cout << "Item :" << x << endl;
}

const MSArray<int> ia2 = ia;  // Copy constructor
if (ia2 == ia)                // Condition should be true
    cout << "Equal!" << endl;

MSArray<double> da2;
da2 = da;                     // Copy assignment
da2 = ia;                     // DOES NOT COMPILE; different value types

if (da == ia)                 // DOES NOT COMPILE; different value types
    cout << "blah blah" << endl;

Test Program

A test program is available: msarray_test.cpp. If you compile and run the test program (unmodified!) with your code, then it will test whether your code works properly.

The test program requires doctest.h, the header for the doctest unit-testing framework, version 2. This file may be downloaded from the doctest GitHub site.

Do not turn in the test program or the doctest framework.

Note. As before, the test program does not check all of the requirements of the project. Some of these cannot be checked by a test program.

Thoughts

Once again, this is to be high-quality code.
The requirements above specify what is to be in the public interface of the package. Nothing is said about private functions. You may write any private functions you want. However, these still must follow the coding standards, including standard 4A (but not 4B, 4C, or 4D).

CS 311 Fall 2020 Project 2