=========================preview======================
(COMP152)[2009](f)midterm~ma_yxf^_10141.pdf
Back to COMP152 Login to download
======================================================
COMP 152 Fall 2009
Midterm Solutions

1. (a) 12345 123450 1234500 1234500
(b) i. 7241
ii. The function is to sort the array elements with odd indexes and those with even indexes separately, in decreasing order.
2. (a) gridNd::gridNd ()
{

cout<<"default constructor"<<endl;

dimension = 2;

data = new int[2];

data[0] = 0;

data[1] = 0;

}

(b) gridNd::gridNd (const gridNd & g)
{

cout<<"copy constructor"<<endl;

dimension = g.dimension;

data = new int[dimension];

for (int i = 0; i < dimension; i++)

this->data[i] = g.data[i];

}

(c) gridNd::gridNd(int x1) { cout << "conversion constructor" << endl; dimension = 1; data = new int[1]; data[0] = x1;
}

(d) gridNd & gridNd::operator=(const gridNd & g) { if( this == &g) return *this; if (data != NULL)
delete [] data;
data = NULL;
dimension = g.dimension;
data = new int[dimension];
for (int i = 0; i < dimension; i++)

this->data[i] = g.data[i];
return (*this);
}

(e) gridNd::~gridNd ()
{
delete[] data;
cout<<"desctructor"<<endl;

2
}

(f) Point a: conversion constructor Point b: default constructor conversion constructor destructor foo: copy constructor copy constructor in function foo desctructor desctructor end of main: destructor destructor
3. (a) void List::deleteRecursive(Node* p){ if (p != NULL){ deleteRecursive(p->next); delete p;
}

head = NULL;
}

(b) List::List(const List & origList){
if (origList.head != NULL){
head = new Node;
head->data = origList.head->data;

Node* temp1 = origList.head->next;
Node* temp2 = head;

while (temp1 != NULL){
temp2->next = new Node;
temp2->next->data = temp1->data;
temp2 = temp2->next;
temp2->next = NULL;
temp1 = temp1->next;

}
}
}

(c) void List::reverseList(){
if (head == NULL || head->next == NULL)
return;

Node* p1 = head;
Node* p2 = p1->next;
Node* p3 = p2->next;
p1->next = NULL;

while (p3 != NULL){
p2->next = p1;
p1 = p2;
p2 = p3;
p3 = p3->next;

}

4
p2->next = p1;
head = p2;

}

4. (a) template <class T>
bool MyArray<T>::erase(const T& item){
int i=0;
for (; i<_size; i++){

if (_data[i] == item)

break;
}
if (i == _size)

return false;

else{
T* newData = new T[_size -1];
for (int j=0; j<i; j++)

newData[j] = _data[j];
for (int j=i+1; j<_size; j++)

newData[j] = _data[j+1];
delete [] _data;
_data = newData;
_size--;
return true;

}
}

(b) template <class T>
void MyArray<T>::clear(){

if (_data != NULL){
delete [] _data;
_data = NULL;

}
_size = 0;
}

(c) T& operator[] (int i); //Inside class
template <class T>
T& MyArray<T>::operator[] (int i){

if (i <0 || i>= _size){
cout << "Error in index\n";
exit(-1);

}
return _data[i];
}

(d) MyArray& operator= (const MyArray& a); //Inside class
template <class T>
MyArray<T>& MyArray<T>::operator= (const MyArray& a){

if( this == &a )
retrun *this;
if (_data != NULL)

delete [] _data;
_size = a._size;
if ( a._size != 0)