AWESOME! COS2614 Exam Solutions (Questions Answers)

,
,
,
,
,Question 1

bool valid = true;
QString name = "";
do{
name = QInputDialog::getText(0,
"Question 1",
"Please enter name");
if(name.length() == 0)
{
//error message:
QMessageBox::information(0,
"Error",
"Please enter name.");
valid = false;
continue;
}

QStringList list = name.split(",");
if(list.length() < 2){
QMessageBox::information(0,
"Error",
"Please enter first name and last name in
coma separated list.");
valid = false;
continue;
}

name = list.join(" ");
}while(valid == false);

QMessageBox::information(0,"Question 1",name);



Question 2

2.1

Registration::Registration(QString n, QString e, QString a){

attendee = Person(n, e, a);

date = QDate::currentDate();

}

2.2 toString, calculateFee

2.3 It means the class member is static. Which means that it can be accessed at the class level and
it’s value is shared between instances of the same class.

2.4

double StudentRegistration::calculateFee()
{
double _fee = Registration::calculateFee();
return _fee/3;

,}



2.5 class RegistrationList: public QList<Registration*>

2.6 Registration and StudentRegistration by order of inheritance.

2.7

double RegistrationList::totalFee()
{
double total = 0;
for(int i = 0; i < this->size(); i++){
total += this->at(i).calculateFee();
}
return total;
}

2.8 Polymorphism is the ability of something to take on multiple forms. The code in 2.7 shows how
the call to ‘calculateFee’ behaves differently depending on it’s type which can either be Registration
or StudentRegistration.

2.9 It could inherit from QMap<int, Registration*> instead, using int to store the id as the key and
Registration* to store the related value.

It could also make use of a QStack<Registration*> container making it easy to push and pop item in
the list.

2.10

Registration and Person:

They have a composition relationship. It’s a one is to one type relationship where one instance of
Registration can hold one instance of Person.

Registration and RegistrationList:

They have a composition relationship. It’s a one is to many relationship where one instance of
RegistrationList can hold many instances of Registration.

2.11 a. class RegistrationList: public QMap<int, Registration*>

2.11 b. QList allows you to store items directly in your list whereas QMap needs them to be stored in
key value form.

It’s easier to search for items in a QMap because they are accessed using their key. QList needs you
to iterate through the list when searching if you do not know the item’s index.

,Question 3

#ifndef FORTUNECOOKIE_H
#define FORTUNECOOKIE_H
#include <QDialog>

class FortuneCookie: public QDialog
{
Q_OBJECT

public:
FortuneCookie();
public slots:
on_button_click();
};

#endif // FORTUNECOOKIE_H


#include "fortunecookie.h"
#include <QPushButton>
#include "quotefactory.h"
#include <QMessageBox>
#include <QString>

FortuneCookie::FortuneCookie()
{
setFixedSize(150,50);
QPushButton* btn = new QPushButton("Open a fortune cookie",this);
setWindowTitle("Fortune Cookie");
connect(btn,SIGNAL(clicked(bool)),this,SLOT(on_button_click()));
}

FortuneCookie::on_button_click()
{
QuoteFactory qf;
QString quote = qf.getQuote();
QMessageBox::information(0,"Message",quote);
}


3.2 The child management facility is the ability of the parent container to manage the life time of its
child objects. When the parent is removed from memory, it will ensure that any child pointers are
deleted preventing memory leaks.

3.3 Views are classes responsible for generating the user interface. Model classes hold the data/
application logic used by the application. The benefit of this is that you can reuse application logic
between applications and user interfaces.

3.4 a.

MainWindow::MainWindow(QWidget *parent)
: QMainWindow(parent)
{
QMenu* menu = new QMenu("&Applications", this);
QAction* action = new QAction("&FortuneCookie", this);
QActionGroup* actionGroup = new QActionGroup(this);
actionGroup->addAction(action);

, menu->addActions(actionGroup->actions());
menuBar()->addMenu(menu);
QToolBar* toolbar = new QToolBar("Cookie bar",this);
toolbar->addActions(actionGroup->actions());
QMainWindow::addToolBar(Qt::BottomToolBarArea, toolbar);
connect(action, SIGNAL(triggered(bool)), this,
SLOT(startApplication()));
}


3.4 b.

void MainWindow::startApplication()
{
FortuneCookie* fc = new FortuneCookie();
setCentralWidget(fc);
}




Question 4

4. 1 Design patterns are efficient and elegant solutions to common problems in object oriented
software design. They are high-level abstract templates that can be applied to particular kinds of
design problems.

4.2 They attempt to express similar code in an abstract way, this allows for code reuse. Design
patterns also promote extensibility. A measure of how easy it is to add improvements to an
application

4.3

Composite: Every QObject maintains a list of its children. You can make one QObject a child of
another by calling setParent(), which automatically adds it to the list of children of its parent.

Observer: The QObject class represents the application of a simplified form of the observer pattern,
particularly in its implementation of signals and slots.

4.4 The implementation of implicit sharing in Qt containers applies a simplified form of the classic
flyweight pattern. Although it represents a way of saving memory by sharing data that would
otherwise be duplicated, there isn’t any explicit data. Examples: QString, QVariant, and QStringList.

4.5 It composes objects into tree structures to represent part-whole hierarchies. It is intended to
facilitate building complex (composite) objects from simpler (component) parts representing tree-
like structures.

4.6 Client, Component, Leaf and Composite.

,