7 EASY TO UNDERSTAND exam solutions! Contain BOTH Questions and solutions. Pass your subject with ease with these solutions. The following exams are covered in this document: 2018-06-P1, 2018-06-P2, 2017-10-P1, 2017-06-P2, 2016-10-P1, 2016-06-P1, 2015-10-P1
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.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.
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);
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.
,
The benefits of buying summaries with Stuvia:
Guaranteed quality through customer reviews
Stuvia customers have reviewed more than 700,000 summaries. This how you know that you are buying the best documents.
Quick and easy check-out
You can quickly pay through credit card or Stuvia-credit for the summaries. There is no membership needed.
Focus on what matters
Your fellow students write the study notes themselves, which is why the documents are always reliable and up-to-date. This ensures you quickly get to the core!
Frequently asked questions
What do I get when I buy this document?
You get a PDF, available immediately after your purchase. The purchased document is accessible anytime, anywhere and indefinitely through your profile.
Satisfaction guarantee: how does it work?
Our satisfaction guarantee ensures that you always find a study document that suits you well. You fill out a form, and our customer service team takes care of the rest.
Who am I buying these notes from?
Stuvia is a marketplace, so you are not buying this document from us, but from seller francoissmit. Stuvia facilitates payment to the seller.
Will I be stuck with a subscription?
No, you only buy these notes for $5.96. You're not tied to anything after your purchase.
