SABANCI UNIVERSITY

CS204: Advanced Programming, Fall 2014, FINAL

Duration: 150 minutes
1   2   3   4   5   6   7   8   TOTAL  

                                                                           /120  
/22   /15   /16   /15   /15   /16  
PLEASE READ BEFORE THE EXAM
The exam is a closed-book, closed-notes exam. Please read the questions carefully. If you
don’t want to answer a question, please put a check (✔) symbol to the boxes above to get
%20 of that question.

NAME: _______________________ SURNAME: _____________________________

SU ID: _______________________

#ifndef _LinkedList_H
#define _LinkedList_H

#include <iostream>
using namespace std;

template <class T>

struct Node {
T info;
Node *next;

Node() {}
Node (const int& s,
Node<T>* link)
: info(s), next(link) {}
};
template <class T>
class LinkedList {
public:
LinkedList ();
~LinkedList ();
virtual void add(T val) {
cout << "what do I do?\n";
}
virtual void get(T& val) {
cout << "What do I do?\n";
}
bool isEmpty() {
return !head;
}
protected:
Node<T>* head;
};
#endif
#include “LinkedList.cpp”
 
LinkedList.h  

1  
 
Q1: The LinkedList class .h is given above and the .cpp file is below. Complete the implementation of
the destructor. (10 pts)

#include <iostream>
using namespace std;

template <class T>

LinkedList<T>::LinkedList() {
cout << "cons L\n";
head = nullptr;
}

template <class T>

LinkedList<T>::~LinkedList () {
cout << "des L\n"; //complete the rest of this destructor

}  
LinkedList.cpp  

2  
 
Q2: Suppose you have the following LinkedListDemo.cpp. (15 pts)

//Include  what  you  need  here.  

int main () {
LinkedList<int> l;
return 1;
} LinkedListDemo.cpp  

a) How do you create a project and get the executable for this file in Visual Studio C++. You are
only allowed to change LinkedListDemo.cpp. Do your modifications on the box above and state
which files you need to add to the project and to which directories. (5 pts)
b) Overload the << operator for the LinkedList class to print the elements in the list from first (head)
to the last element by putting only a single – (dash) in between. For example, if the list contains 1,
2, and 3 the output is 1-2-3. (Plase note that there is no newline or dash at the end). (7 pts)

//Additions  to  LinkedList.h  

LinkedList.h  

//Additions  to  LinkedList.cpp   LinkedList.cpp  

c) What happens when you try to compile the project you created for LinkedListDemo.cpp if the
virtual function definitions in LinkedList.h were (3 pts)

virtual void add(T val) = 0;

virtual void get(T& val) = 0;
 
3  
 
Q3: You are asked to derive an IntQueue class from the LinkedList class you have. The class will be
used only for int values and implements the FIFO policy. The add(int val) function will enqueue
val (you need to use a tail pointer here) and the get(int& val) will dequeue the Node pointed by
the head pointer; the value will be stored in val. (15 pts)

#ifndef _IntQueue_H
#define _IntQueue_H

#include "LinkedList.h"

class IntQueue :  
public:
IntQueue();
~IntQueue();
void add(int);
void get(int& val);
private:

};
#endif  
IntQueue.h  

a) Fill the first empty rectangular box in the IntQueue.h given above to have public inheritance from
LinkedList. Fill the second one to add a tail pointer to the IntQueue class which will be used to
efficiently enqueue an item. (3 pts)
b) A partial implementation of the IntQueue.cpp is given below. Please complete the implementation.
If the queue is empty during get, throw an exception which tells “the queue is empty”. You don’t
need to catch it here. (10 pts)

#include <iostream>
#include "IntQueue.h"

using namespace std;

IntQueue::IntQueue() {
cout << "cons Q\n";
... //complete this part
}

IntQueue::~IntQueue() {
cout << "dest Q\n";
}

void IntQueue::add(int val) {

... //complete this part
}

void IntQueue::get(int& val) {

... //complete this part
} IntQueue.cpp  

4  
 
c) What is the output for the following main.cpp (assuming the IntQueue class is correctly
implemented as described above)? (2 pts)

#include <iostream>
#include "IntQueue.h"
using namespace std;

int main() {
IntQueue q;
q.add(1);
q.add(2);
q.add(3);
int a;
q.get(a);
cout << a << endl;
q.get(a);
cout << a << endl;
return 1;
}
mainQ3c.cpp  
 

5  
 
Q4: Suppose that you also inherited an IntStack class from the LinkedList class as you did for
IntQueue. Its implementation (the cpp file) is given on the left below. The header file is the same with
IntQueue.h (see Q3) except that IntStack does not have a tail pointer. (15 pts)

#include <iostream> #include <iostream>

#include "IntStack.h" #include "IntQueue.h"
#include "IntStack.h"
IntStack::IntStack() { using namespace std;
std::cout << "cons S\n";
} int main() {
IntQueue q;
IntStack::~IntStack() { q.add(1);
std::cout << "dest S\n"; q.add(2);
} cout << q << endl;
IntStack s;
void IntStack::add(int val) { s.add(1);
head = new Node<int>(val, head); s.add(2);
} cout << s << endl;

void IntStack::get(int& val) { return 1;

if(isEmpty()) { } mainQ4a.cpp  
throw "stack is empty\n";  
} else {
Node<int>* temp = head;
head = head->next;
val = temp->info;
delete temp;
}
} IntStack.cpp  
a) The compiler gives a redefinition error (i.e., some of the LinkedList functions are redefined) for
the main.cpp on the right Please find what is wrong, explain how to fix it, and write the output
assuming that you correctly overloaded the << function as described. (5 pts)
b) Suppose we have the following functions given below (left) in the main.cpp (left + right).

#include <iostream>
int main() {
#include "IntQueue.h"
IntQueue q;
#include "IntStack.h"
q.add(1);
q.add(2);
get_X(q); //X can be 1,2,3,4
void get_1(LinkedList<int> l) {
int a = -1;
return 1;
l.get(a);
}  
cout << a << endl;
} mainQ4b.cpp  (continued)  
void get_2(LinkedList<int>& l) {
int a = -1;
l.get(a);
cout << a << endl;
}

void get_3(IntQueue l) {
int a = -1;
l.get(a);
cout << a << endl;
}

void get_4(IntQueue& l) {
int a = -1;
l.get(a);
cout << a << endl;
}
  mainQ4b.cpp  
6  
 
 Assuming we are using the IntQueue class given in Q3, write the outputs when X in the main.cpp
above is replaced with 1, 2, 3, and 4. If you claim that the compiler complains for some value of X
do not give an output and put “does not compile” as your answer for that value and tell why. If
you claim that the program compiles but crashes after some point write the output until that point
and explain why it crashes. Otherwise, just write the output. (5 pts)

c) Answer the previous question (b) for the main function below (the part on the left having the
functions remains exactly the same). (5 pts)

int main() {
IntStack s;
s.add(1);
s.add(2);
get_X(s); //X can be 1,2,3,4

return 1;
}  
mainQ4c.cpp  

7  
 
Q5: The IntStack implementation is given in Q3. (20 pts)

a) Add a move constructor and a copy constructor to the IntStack class. Keep your constructor
implementations self contained, i.e., write everything you need inside the function. Please do not
use an extra helper function. (10 pts)

//Additions  to  IntStack.h  

IntStack.h  

//Additions  to  IntStack.cpp  

IntStack.cpp  

8  
 
 #include <iostream>
#include "IntStack.h"
b) The IntStack class now has three constructors:
using namespace std; default (D), copy (C), and move (M). Write which of these
constructors are called for the statements on the left (s1 is
IntStack foo() {
IntStack x; given as an example) assuming no optimization is performed
return x; by the compiler. Please note that more than one constructor
}
type can be called for each statement. (5 pts)
int main() {
IntStack s1; s1: D
IntStack s2(s1);
IntStack&& s3 = foo();
IntStack s4(s3); s2:
IntStack s5 = s2;
IntStack s6 = move(s2); s3:
return 1;
} s4:
 
s5:

mainQ5a.cpp   s6:

. . . c) Please write valid or invalid below for

. . . each reference given on the left. An invalid
IntStack foo() { reference is one on which the compiler complains.
return IntStack(); If you think that the reference is invalid, briefly
}
explain (in one sentence) why. (5 pts)
int main() {
const IntStack s; sr1:
IntQueue q;

IntStack& sr1 = s;
IntStack& sr2 = foo();
sr2:
const LinkedList<int>& lr1 = foo();
LinkedList<int>&& lr2 = q;
const LinkedList<int>& lr3 = s;
lr1:
return 1;
}

 
lr2:

lr3:
mainQ5b.cpp  

9  
 
Q6: You are given a DumbStackUser class as shown below. (15 pts)

class DumbStackUser {
public:
DumbStackUser() {
cout << "def cons D\n";
static int var = 0;
var++;
if(var == 1) {
throw var;
}
};
DumbStackUser(bool actDumb) {
cout << "cons D\n";
try {
if(actDumb) {
s.get(val);
}
} catch (int a) {
cout << "caught int exception\n";
}
}
~DumbStackUser() {
cout << "des D\n";
}
private:
int val;
IntStack s;
};
  DumbStackUser  

Given the following mainQ6x.cpp’s please write the outputs (do not forget to include the constructor
and destructor calls). If you think that there is an uncaught exception, please write the output until that
exception is thrown and also write which throw statement is responsible.

a) (5 pts)

int main() {
try {
try {
DumbStackUser d = DumbStackUser(true);
} catch (string s) {
cout << "caught string exception: "<< s << "\n";
throw 1.0;
} catch (char s[]) {
cout << "caught char [] exception: " << s << "\n";
throw 1.0;
} catch (const char s[]) {
cout << "caught const char [] exception: " << s << "\n";
throw 1;
} catch (...) {
cout << "inner catch all\n";
throw 1;
}
} catch (double d) {
cout << "caught double exception\n";
} catch (...) {
cout << "outer catch all\n";
}
return 1;
}  
mainQ6a.cpp  

10  
 
b) (5 pts)

int main() {
DumbStackUser d;
try {
DumbStackUser d;
} catch (int d) {
cout << "caught int exception: " << d << "\n";
} catch (...) {
cout << "outer catch all\n";
}

return 1;
} mainQ6b.cpp  

c) (5 pts)

int main() {
try {
DumbStackUser d;
} catch (int d) {
cout << "caught int exception: " << d << "\n";
} catch (...) {
cout << "outer catch all\n";
}
DumbStackUser d;

return 1;
}
mainQ6c.cpp  
 

11  
 
Q7: Please answer the following questions: (15 pts)

a) Suppose that the IntStack class has a member mutex variable as shown below in IntStack.h. The
IntStack.cpp is untouched and you cannot change it.

. . .
#include <mutex>

class IntStack ... {

public:
mutex mutex;
. . . // the rest is same.
IntStack.h  (modified)  

You are asked to implement a function transfer(IntStack* stacks, int from, int to) which
gets an array of stacks and two integers from and to. It gets an element from the IntStack object
stacks[from] and adds it to stacks[to]. The function needs to be thread-safe. Please complete the
empty box in the implementation of transfer function below. (7 pts)

#include <iostream>
#include <string>
#include <thread>
#include <mutex>

#include "IntStack.h"
using namespace std;

void transfer(IntStack* stacks, int from, int to) {

}
int main() {
IntStack* stacks = new IntStack[10];
for(int i = 0; i < 10; i++) {
for(int j = 0; j < 100; j++) {
stacks[i].add(i);
}
}
thread threads[100];
for (int i = 0; i < 100; ++i) {
threads[i] = thread(transfer, stacks, i % 10, (i + 1) % 10);
}

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

threads[i].join();

return 1;
}
mainQ7a.cpp  

12  
 
 #include <iostream>
#include <string>
#include <thread>

#include "IntStack.h"
using namespace std;

int a = 0;
void incrementFiveTimes() {
for(int i = 0; i < 5; i++) {
a++;
}
}

int main() {
thread threads[2];
for (int i = 0; i < 2; ++i)
threads[i] = thread(incrementFiveTimes);

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

threads[i].join();

cout << a << endl;

return 1;
}   mainQ7b.cpp  
b) What is the minimum and maximum values that can be printed by the code above assuming the ++
operation is handled in three steps: read/increment/write? Please explain how these
minimum/maximum scores are achieved by stating the a sample order of operations
(read/increment/write) of the threads. (6 pts)
c) How can you fix the code in part (b) with minimal change (single line) such that the code always
prints 10? (2 pts)

13  
 
Q8: Please answer the following questions. (15 pts)

a) Fill in the box below with an appropriate expression so that the function returns one's complement
of num. (3 pts)

int ones(int num) {

 
return

}
 

b) What does the following function do? Please explain briefly. (4 pts)

int foo(int num) {

int i;
for(i = 0; num; i++) {
num &= (num-1);
}
return i;
}  

c) What is the output of the following code? (4 pts)

int add(int first, int second) {

return first + second + 15;
}

int oper(int first, int second, int (*functocall)(int, int)) {

return (*functocall)(first, first);
}

int main() {
int (*plus)(int, int) = add;
int add;
add = oper(15, 10, plus);
cout << add << endl;

return 1;
}
 

d) Fill the rectangles in the output on the right for the code excerpt on the left. (4 pts)

int a[5];  
int* ap = &(a[0]);  
int* ap2 = &(a[4]);  
cout << ap2 - ap << endl;
cout << "ap is " << ap << endl;
ap  is                              0x7fff504b4ab0
cout << " ap2 is " << ap2 << endl;  
ap2  is    

14