void arraySum(int* first, int* second, int* third, int length) {
for (int i=0;i<length;i++) {
third[i] = first[i] + second[i];
}
}
Tests in this course may contain any material covered in lecture up until this point, although much stronger emphasis will be placed on material for which you have received graded feedback. This page contains a collection of exercises that you may wish to complete to prepare yourself for the test. Note that you do not need to complete all of the offered exercises; more questions appear here than will appear on your test.
Write a function arraySum, which sums elements in two arrays and
stores them in a third. The function should take three int* arrays
and an int length. Assume all three arrays are the same size. For each
index, the sum of the integers at that position in the first and
second arrays are stored in the third.
Solution:
void arraySum(int* first, int* second, int* third, int length) {
for (int i=0;i<length;i++) {
third[i] = first[i] + second[i];
}
}
Write a function average which computes the average of the values
in an array of floats. You must take a float* parameter; you may
take other parameters as you see fit. Your function should return the
average of the values in that array.
Solution:
float average(float* data, int count) {
float total = 0;
for (int i=0;i<count;i++) {
total += data[i];
}
return total/count;
}
Write a function fibonacci which takes a parameter int n and
returns an int* to a new array which contains the first n
Fibonacci numbers (0, 1, 1, 2, 3, 5, 8, 13, …).
Solution:
int* fibonacci(int n) {
int* result = new int[n];
for (int i=0;i<n;i++) {
if (i<2) {
result[i] = i;
} else {
result[i] = result[i-1] + result[i-2]
}
}
return result;
}
Write a function zerowash which allocates space for a million
int values, sets them all to 0, and then deallocates the memory.
Solution:
void zerowash() {
int* space = new int[1000000];
for (int i=0;i<1000000;i++) {
space[i] = 0;
}
delete[] space;
}
Explain the difference between delete and delete[].
Solution:
delete is used to delete objects; delete[] is used to delete arrays.
Each of the following code fragments contains a bug. Identify the bug and explain how to correct it.
Code to create an array of ten elements and set each element equal to its index.
int* array = new int[10];
for (int i=1;i<=10;i++) {
array[i] = i;
}
Solution:
Arrays in C++ start indexing at 0. The loop should read
for (int i=0;i<10;i++)
Code to define a function which sums all of the values in an array.
int sum(int* array) {
int acc = 0;
for (int i=0;i<len(array);i++) {
acc += array[i];
}
return acc;
}
Solution:
There is no len function in C++. The function sum must be
modified to take an additional parameter which contains the length
of the array.
Code to define a class which represents a single (X,Y) coordinate.
class Point {
public:
Point(int x, int y);
int getX();
int getY();
private:
int x;
int y;
};
Point::Point(int x, int y) {
x = x;
y = y;
}
int Point::getX() {
return x;
}
int Point::getY() {
return y;
}
Solution:
The body of the constructor will not do anything. It should read
this->x = x;
this->y = y;
For consistency, the getX and getY methods should also be using this->.
Code to calculate the distance between two points.
Point* p; Point* q;
float dx = p->getX() - q->getX();
if (dx<0) {
dx = -dx;
}
float dy = p->getY() - q->getY();
if (dy<0) {
dy = -dy;
}
float dist = sqrt(dx*dx+dy*dy); // assume sqrt exists (in the cmath library)
cout << "The points are " << dist << " unit(s) apart." << endl;
Solution:
The pointers p and q are never initialized; they should be
assigned pointers to new objects.
Ideally, this distance-calculating code would be a method rather
than code written in e.g. main. That's a stylistic concern,
though, while the uninitialized p and q variables can lead the
program to crash.
What is the purpose of a class? What is the difference between a class and an object?
Solution:
A class groups data and behavior (fields and methods) together. We
use classes to describe concepts relevant to the program we are
writing so that our code can recognize and discuss those concepts
rather than focus on tiny details. An object is an instance of a
class: it is an example of the sort of thing that the class describes.
Define polymorphism as it pertains to C++. Give an example which was not given in lecture.
Solution:
Polymorphism allows an object to be treated as an instance of its
superclass. For instance, a pointer to an Employee object might be
treated as a pointer to a Person object (since we would expect
Employee to be a subclass of Person).
What is the purpose of the private keyword?
Solution:
The private keyword designates fields and methods which cannot be
called from outside of the definition of a class's methods. We know
that outsiders cannot change the value of private fields (unless a
public method allows them to do so), allowing us to reason about
what values they may contain.
Draw a stack diagram of the following code when it reaches the end of main. Be sure to be clear what is on the stack and what is on the heap.
class LabAssignment {
public:
LabAssignment(int number, int score);
int number;
int score;
};
LabAssignment::LabAssignment(int number, int score) {
this->number = number;
this->score = score;
}
int main() {
LabAssignment a(1,98);
LabAssignment* b = new LabAssignment(2,84);
LabAssignment* c = b;
b = new LabAssignment(3,95);
c->score = 92;
return 0;
}