COS1512 Tut Letter 101

COS1512/101/3/2019
Tutorial Letter 101/3/2019
Introduction to Programming II
COS1512
Semesters 1 and 2
School of Computing
Please activate your myUnisa and myLife email addresses and ensure you have
regular access to the myUnisa module site COS1512-2019-S1 or COS1512-
2019-S2 as well as your e-tutor group site.
Note: This is a blended online module, and therefore your module is available on
myUnisa. However, in order to support you in your learning process, you will also
receive Tutorial Letter 101 in printed format. Please visit the COS1512 course website
on myUnisa at least twice a week.
BARCODE
CONTENTS
Page
1 INTRODUCTION ............................................................................................................................ 4
2 OVERVIEW OF THE MODULE COS1512 ..................................................................................... 5
2.1 Purpose .......................................................................................................................................... 5
2.2 Outcomes ....................................................................................................................................... 6
3 LECTURER(S) AND CONTACT DETAILS .................................................................................... 7
3.1 Lecturer(s) ...................................................................................................................................... 7
3.2 Department ..................................................................................................................................... 7
3.3 University ........................................................................................................................................ 8
4 MODULE-RELATED RESOURCES .............................................................................................. 8
4.1 Joining myUnisa ............................................................................................................................. 8
4.2 Other resources – Printed support materials .................................................................................. 9
4.3 Prescribed books ............................................................................................................................ 9
4.4 Recommended books ................................................................................................................... 10
4.5 Prescribed software ...................................................................................................................... 10
4.6 myUnisa Forum ............................................................................................................................ 10
4.7 Tutorial letters ............................................................................................................................... 10
4.8 Additional Resources .................................................................................................................... 11
5 STUDENT SUPPORT SERVICES FOR THE MODULE .............................................................. 11
5.1 E-Tutors ........................................................................................................................................ 11
5.2 Downloading study material and software .................................................................................... 12
5.3 Additional Resources on myUnisa ................................................................................................ 12
5.4 Announcements on myUnisa ........................................................................................................ 12
5.5 Installation of the software ............................................................................................................ 12
6 STUDY PLAN ............................................................................................................................... 12
6.1 Syllabus ........................................................................................................................................ 12
6.2 Planning your academic year ....................................................................................................... 13
6.3 Hints on studying this module ....................................................................................................... 15
7 MODULE PRACTICAL WORK AND WORK-INTEGRATED LEARNING ................................... 16
8 ASSESSMENT ............................................................................................................................. 16
8.1 Assessment plan .......................................................................................................................... 16
8.2 General assignment numbers ....................................................................................................... 19
8.2.1 Unique assignment numbers ........................................................................................................ 19
2
COS1512/101/3/2019
8.2.2 Due dates for assignments ........................................................................................................... 19

8.3 Submission of assignments .......................................................................................................... 19
8.4 Assignments ................................................................................................................................. 20
9 EXAMINATION ............................................................................................................................. 20
10 FREQUENTLY ASKED QUESTIONS .......................................................................................... 20
11 IN CLOSING ................................................................................................................................. 21
12 APPENDIX A: ASSIGNMENTS FOR COS1512 .......................................................................... 22
13 APPENDIX B: THE SOFTWARE FOR COS1512........................................................................ 56
14 APPENDIX C: SOURCE LISTINGS OF THE SAMPLE PROGRAMS IN THE TEXTBOOK ....... 62
15 APPENDIX D: GLOSSARY.......................................................................................................... 62
16 APPENDIX E: Solution to assignment 3 ................................................................................... 63
Please note / important note: COS1512 is a semester module. You need AT LEAST eight
hours per week for this module.
If you do not receive your study material immediately after registration, you have to download it
from myUnisa so that you are able to start IMMEDIATELY with your studies. See section 5.3 in
this tutorial letter for details about the downloading of study material.
To gain admission to the examination you have to submit one assignment before a
specific date. The due date is 5 April if you are registered for the first semester and 30
August if you are registered for the second semester.
The COSALLF/301/0/2019 tutorial letter contains important general information that you will
need during the year such as the names and contact details of lecturers assigned to the
different modules.
3
1 INTRODUCTION
Dear Student
Welcome to COS1512. We hope that you will find this module interesting and stimulating and
that you will increase your knowledge about and your skills in programming in C++. We shall do
our best to make your study of this module successful. In order to succeed with your studies,
you need to start studying immediately and do the assignments properly.
This Tutorial Letter 101 contains important information about the scheme of work, resources
and assignments for this module. We urge you to read it carefully and to keep it at hand when
working through the study material, preparing the assignments, preparing for the examination
and addressing questions to your lecturers.
Please read Tutorial Letter 301 and the Study @ Unisa brochure in combination with Tutorial
Letter 101 as it gives you an idea of generally important information when studying at a distance
university and within a particular College.
In Tutorial Letter 101, you will find the assignments and assessment criteria as well as
instructions on the preparation and submission of the assignments. This tutorial letter also
provides all the information you need with regard to the prescribed study material and other
resources and how to obtain it. Please study this information carefully and make sure that you
obtain the prescribed material as soon as possible.
We have also included certain general and administrative information about this module.
Please study this section of the tutorial letter carefully.
Because this is a blended online module, you need to use myUnisa to study and complete the
learning activities for this course. You need to visit the website on myUnisa for COS1512
frequently. The website for COS1512 for the first semester is COS1512-19-S1 and for the
second semester it is COS1512-19-S2.
We hope that you will enjoy this module and wish you all the best!
1.1 To get started…
Because this is a blended online module, you need to go online to see your study materials and
read what to do for the module. Go to the myUnisa website here: https://my.unisa.ac.za and log
in with your student number and password. You will see COS1512-19-S1 (for the first semester)
or COS1512-19-S2 (for the second semester) in the row of modules in the orange blocks across
the top of the webpage. Remember to also check in the -More- tab if you cannot find it in the
orange blocks. Click on the module you want to open.
In addition, you will receive a printed copy of this tutorial letter from your module. While the
printed material may appear to be different from the online study materials, they are exactly the
same.
1.1.1 About myUnisa

myUnisa is the student website that allows you to connect with your lecturers, e-tutors and
fellow students, download your study material, submit assignments, gain access to the Library
and various learning resources and participate in online discussion forums.
We also use myUnisa for announcements, and to deliver additional study material. Please join
myUnisa and visit the COS1512 course website regularly, at least twice a week.
4
COS1512/101/3/2019
1.2 Tutorial Matter

The tutorial matter for this module consists of the following:
 this tutorial letter, COS1512/101/3/2019;
 tutorial letter COSALLF/301/4/2019;
 a CD containing the prescribed C++ software (Disk2019);
 additional tutorial letters published on the COS1512 course website under Additional
Resources, containing additional information or solutions to assignments.
When you register, you will receive an inventory letter containing information about your
tutorial matter. See also the brochure entitled Study @ Unisa, (which you received with your
tutorial matter). Check the study material that you have received against the inventory letter.
You should have received all the items listed in the inventory, unless there is a statement like
“out of stock” or “not available”. If any item is missing, follow the instructions on the back of the
inventory letter without delay.
Some of this study material may not have been available when you registered. Study
material that was not available when you registered will be posted to you as soon as
possible, but is also available on myUnisa.
Please do not contact the School about missing tutorial matter, cancellation of a module,
payments, enquiries about the registration of assignments, and so on, but rather the
relevant department as indicated in the Study @ Unisa brochure. The School should only
be contacted about academic matters.
If you have not received all of the above mentioned tutorial matter, please contact our
DESPATCH DEPARTMENT, using the contact details as given in the Study @ Unisa
brochure. In the meantime, please download the study material from myUnisa.
2 OVERVIEW OF THE MODULE COS1512

2.1 Purpose
COS1512 is one of a number of first-year Computer Science modules offered by the School of
Computing at Unisa.
COS1512 focuses on providing an introduction to objects and the object-oriented programming
environment using C++ as programming language. The following topics are covered:
 file I/O streams as an introduction to objects and classes;
 using pre-defined classes such as string and vector;
 C strings, pointers and dynamic arrays;
 ADTs (i.e. user-defined classes including the functions and operators for these classes
as well as separate compilation);
 recursion;
 single inheritance, and
 function and class templates.
The paragraphs below show where COS1512 fits into the programming modules offered by the
School of Computing:
5
COS1511 deals with the basic concepts of programming, using the programming language C++.
It is aimed at students who have not done any programming before. It is a pre-requisite for
COS1512.
COS1512 introduces the learner to objects and the object-oriented programming environment.
COS1521 provides a general background to computer systems.
INF1511 is an introductory course in Python programming.
COS1501 introduces the mathematics relevant to Computer Science.
2.2 Outcomes
Once you have completed this module, you should have reached the following outcomes:
Outcome 1:
You should be able to design a logical solution to a simple programming problem, making
appropriate assumptions.
Assessment criteria:
 Through assignments, including multiple choice and written assignments and an

examination at the end of the semester, you are assessed on your ability to:
 interpret a problem description which specifies the requirements of a program;
 identify all steps necessary to solve a problem and order the steps in the correct logical
sequence;
 write down the logical sequence of operations that a computer should perform to solve
a particular problem;
 apply object-oriented principles during problem solving.

Outcome 2:
You should be able to write C++ program code, demonstrating the principles of good
programming style.
Through assignments, including multiple choice and written assignments and an examination at
the end of the semester, you are assessed on your ability to:
 use the different C++ programming constructs appropriately and correctly, in order to
implement a solution to a programming problem;
 write functions and use them in a program;
 define classes and use object-oriented principles to implement programming problems;
 recognise/locate errors in a program and correct them.
6
COS1512/101/3/2019
Outcome 3:
You should be able to demonstrate an understanding of the theory underlying the basic
programming concepts.
Through assignments, including multiple choice and written assignments and an examination at
the end of the semester, you are assessed on your ability to:
 explain the purpose of a particular C++ programming construct and identify problem
descriptions where they are applicable;
 define relevant programming concepts.

The specific learning objectives for each chapter in the prescribed book for COS1512 in order to
reach the above learning outcomes are given in more detail in the study guide included in
Tutorial Letter 102, available under Additional Resources on the COS1512 course website.
3 LECTURER(S) AND CONTACT DETAILS

3.1 Lecturer(s)
If you experience problems with this subject or have any other enquiry about it, please feel free
to contact the lecturers. The names and telephone numbers of your lecturers for this module, as
well as the module e-mail address you can use for any queries regarding this module, are
supplied in tutorial letter COSALLF/301/0/2019.
Email: Email is a convenient and the most effective way of communicating with a lecturer.
Students registered for the first semester should send e-mail queries either to the
module leader for COS1512 (e-mail supplied on the course website) or to
[email protected]
and students registered for the second semester should send e-mail queries either to the
module leader for COS1512 (e-mail supplied on the course website) or to
[email protected].
Include the module code and your student number in the subject header of the message. Ask
specific questions. It is difficult to respond properly via email to a request such as 'I don't
understand problem 5.1. Please explain.' Always state exactly what it is that you do not
understand.
Phone us: You are welcome to phone us directly, but please consult your tutorial letters and the
myUnisa discussion forum to ensure that your query has not already been addressed. We are
sometimes unavailable due to other departmental, research or university duties. If you fail to
reach us directly, please phone the secretary. In urgent cases you may also leave a message at
a secretary for us to call you back. The best contact hours are between 9:00 and 13:00 in the
mornings, except Wednesdays when we have our departmental meetings.
3.2 Department
Please note that the School of Computing is situated on the Science Campus in Florida. The
School of Computing can be contacted telephonically at 011 670 9200 or via e-mail with the e-
mail address [email protected]. Should you be unable to reach any of the lecturers for
COS1512, please leave a message and your contact details with one of the secretaries, who
7
can be contacted via the number given above. Remember to include the module code and your
student number with the message.
3.3 University
Lecturers for this module are only responsible for content-related queries about the study
material used for COS1512.
If you need to contact the University about matters not related to the content of this module,
please consult the publication Study @ Unisa that you received with your study material. This
brochure contains information on how to contact the University (e.g. to whom you can write for
different queries, important telephone and fax numbers, addresses and details of the times
certain facilities are open).
NB: Always have your student number at hand when you contact the University. Whenever you
write to a lecturer, please include your student number to enable the lecturer to help you more
effectively.
4 MODULE-RELATED RESOURCES
4.1 Joining myUnisa
If you have access to the internet, you can quickly access resources and information at the
University. The myUnisa learning management system is Unisa's online campus that will help
you to communicate with your lecturers, with other students and with the administrative
departments of Unisa.
You can start at the main Unisa website, http://www.unisa.ac.za, and then click on the myUnisa
orange block. This will take you to the myUnisa website. To go to the myUnisa website directly,
go to https://my.unisa.ac.za. Click on the “Claim UNISA Login” on the top of the screen on the
myUnisa website. You will then be prompted to give your student number to claim your initial
myUnisa as well as myLife login details.
This module is presented following a blended approach in the sense that even though you will
still receive some printed study material, most of the information needed to complete this
module is available on myUnisa. myUnisa has inter alia the following tools which you will use
regularly:
Assignments This is a tool to manage your assignments; to submit, track and see
marks obtained.
Official Study Tutorial letters 101 and 301 as well as some past examination papers are
Material available under Official Study Material.
Additional Additional tutorial letters such as solutions to assignments and the

Resources examination tutorial letter are published under Additional Resources. The
Additional Resources tool also contains a variety of resources related to
COS1512. For example the Study Guide (Tutorial Letter 102) and the
Code::Blocks software.
Course Contact The Course Contact tool facilitates e-mail communication between
students and lecturers. Students use their myLife e-mail to send e-mails
to their lecturers through myUnisa.
Frequently Asked Frequently asked questions, or FAQs, are listed questions and answers,
Questions all supposed to be frequently asked in some context, and pertaining to a
8
COS1512/101/3/2019
particular topic.
Learning Units The Learning Units tool contains learning units/lessons for COS1512
and represents the weeks in your study programme. Please use the
weekly Learning Units to guide you in your studies.
Please consult the publication Study @ Unisa which you received with your study material for
more information on myUnisa.
4.2 Other resources – Printed support materials
Because we want you to be successful in this blended online module, we also provide you with
Tutorial Letter 101 in printed format. This will allow you to continue studying and do the
assignments, even if you are not online.
 Tutorial Letter 101 will be sent to you at the beginning of the semester, but you do not
have to wait to receive it to start studying – You can go online as soon as you register
and all your study materials will be there.
 Therefore, Tutorial Letter 101 is not something that you need to wait for before you start
with the module. It is only an offline copy of the formal content for the online module.
 This will give you the chance to do a lot of the studying for this module WITHOUT going
online. This will save you money, of course, and you will be able to take as much time as
you need to read -- and to re-read -- the materials and do the activities.
It is therefore very important that you log into myUnisa regularly. We recommend that you
should do this at least every week, and preferably twice a week, to check for the following:
 Check for new Announcements. You can also set up your myLife email so that you
receive the Announcement emails on your mobile device.
 Do the Discussion forum activities. For every unit in this module, we want you to share
with the other people in your group in the activities. You can read the instructions there,
and even prepare your answers but you need to go online to post your messages.
 Do other online activities. For some of the unit activities, you need to post something
on the Blog or take a quiz or complete a survey in Self Assessment. Don't skip these
activities because they will help you to complete the assignments and activities for the
module.
We hope that this system will help you to succeed in this blended online module by giving you
extra ways to study the materials and practice with all of the activities and assignments. At the
same time, you MUST go online in order to complete the activities and assignments on time --
and to get the most from the online course.
Remember, the printed support materials are a back-up to everything that is found online, on
myUnisa. There are no extra things there. In other words, you should NOT wait for the
Printed support materials to arrive to start studying.
4.3 Prescribed books

The prescribed book for this module is:
9
Walter Savitch. Problem Solving with C++, 10th edition. Pearson International Edition: Addison-
Wesley, 2018.
You may also use the 7th, 8th or 9th edition of the prescribed book.
You are expected to purchase your own copy of the prescribed book. For contact details of
official booksellers, please consult the list of official booksellers and their addresses in Study @
Unisa. If you have any difficulties with obtaining books from these bookshops, please contact
[email protected].
We will refer to the prescribed book as Savitch.
4.4 Recommended books
You do not have to consult any other textbooks apart from Savitch. However, some of you may
want to read more widely, and consult alternative references. The following useful books are
available in the Unisa library. Please note that the library does not have multiple copies of
these books and that only limited waiting lists are kept.
DS Malik. C++ Programming: From Problem Analysis To Program Design. Course
Technology, Thomson Learning, 2009.
HM Deitel and PJ Deitel. C++ How to Program. 8th edition. Prentice Hall, 2008.
John R. Hubbard. Programming with C++. 2nd edition. Schaum’s Outlines, 2000.
4.5 Prescribed software
The prescribed software for this module is Code::Blocks 10.05. We will refer to the software as
Code::Blocks. Code::Blocks includes the MinGW C++ compiler and an Integrated Development
Environment (IDE), which we use to create program files. The prescribed software is provided
on the CD Disk2019 that you should have received in your study package when you registered.
The Disk2019 contains instructions on how to install the software, and how to use the IDE to
write, compile and execute your programs. Click on the link for COS1512 and follow the
instructions.
If you did not receive Disk2019 upon registration, you should download the software
immediately from myUnisa so that you are able to start with your studies at once. The
software is available under Additional Resources on the COS1512 webpage.
4.6 myUnisa Forum
Content-related queries should be posted on the COS1512 discussion forum on myUnisa rather
than sent to the COS1512 e-mail address. In this way fellow students can also contribute and
benefit. You can also contact the e-tutor to whom you are allocated with content-related queries
(see section 5.1).
4.7 Tutorial letters
In addition to the Study Guide, the software and this tutorial letter, there will be other tutorial
letters during the course of the semester. Some will provide additional information (Tutorial
Letters 102, 103, etc.) whilst others will discuss Assignments 1 and 2 (Tutorial Letters 201 and
202). All tutorial letters will be available on myUnisa under Additional Resources. Note also that
the solutions to the self-assessment assignment - Assignment 3 - are available online on the
COS1512 website.
You only receive a printed copy of this tutorial letter (Tutorial Letter 101). All subsequent
tutorial letters are only available on myUnisa under Additional Resources.
10
COS1512/101/3/2019
4.8 Additional Resources

Please check Additional Resources on myUnisa regularly for documents that will assist you if
you have problems installing software, using the compiler, writing a program, etc. You will also
find extra help for the examination there.
5 STUDENT SUPPORT SERVICES FOR THE MODULE

The Student Services Bureau of Unisa provides support for students in general academic
matters, such as selecting appropriate modules, developing study skills, adapting to distance
education, assistance for students with special needs or general difficulties with studies. See
COSALLF/301/4/2019 and Study @ Unisa for contact information.
The Study @ Unisa brochure is available on myUnisa: www.unisa.ac.za/brochures/studies.This
brochure has all the tips and information you need to succeed at distance learning and,
specifically, at Unisa.
5.1 E-Tutors
Unisa offers online tutorials (e-tutoring) to students registered for modules at NQF level 5 and 6,
this means qualifying first year and second year modules.
Once you have been registered for a qualifying module, you will be allocated to a group of
students with whom you will be interacting during the tuition period as well as an e-tutor who will
be your tutorial facilitator. Thereafter you will receive an sms informing you about your group,
the name of your e-tutor and instructions on how to log onto myUnisa in order to receive further
information on the e-tutoring process. If you login into myUnisa you will notice that your group
site has been added there. Your tutor will be able to assist you there. For example, if you were
allocated in group 4, the group site will be named COS1512-19-S1-4E. You can use the
discussion forum to discuss module content issues with your tutor as well as with students
belonging to that group. You will also find the contact details of your tutor. If you have content
related problems (that is, problems with the material in your study guide that you do not
understand), please contact your e-tutor.
Online tutorials are conducted by qualified e-tutors who are appointed by Unisa and are offered
free of charge. All you need to be able to participate in e-tutoring is a computer with internet
connection. If you live close to a Unisa Regional Centre, please feel free to visit it to access the
internet. E-tutoring takes place on myUnisa where you are expected to connect with other
students in your allocated group. It is the role of the e-tutor to guide you through your study
material during this interaction process. For you to get the most out of online tutoring, you need
to participate in the online discussions that the e-tutor will be facilitating. Please contact your e-
tutor with all content–related queries.
There are modules which students have been found to repeatedly fail, these modules are
allocated face-to-face tutors and tutorials for these modules take place at the Unisa regional
centres. These tutorials are also offered free of charge, however, it is important for you to
register at your nearest Unisa Regional Centre to secure attendance of these classes.
This module is furthermore part of the “Extended Science Pathways” (ESP) programme in which
students do their first-year semester modules over a year instead of a semester. You cannot
apply to do the ESP programme as Unisa registrations place students to either mainstream or
ESP.
11
5.2 Downloading study material and software
One of the requirements for study at the School of Computing is to have regular internet
access to access myUnisa and your myLife e-mails. You are therefore expected to
download any study material from the Internet that, for whatever reason, is not available
on paper in time. You may download it from myUnisa. The study material is updated regularly,
thus you need to check the COS1512 website at least twice a week on myUnisa.
Because COS1512 is a semester module, time is of the utmost importance. You should start
studying the module immediately after registration. This tutorial letter, the Study Guide and the
software are most important.
The Study Guide (Tutorial letter 102) is available on myUnisa under Additional Resources.
Please download it from myUnisa. It is also incorporated in the Learning Units, which you
should use to guide your studies week by week.
The software should also be downloaded from myUnisa under Additional Resources for
COS1512, at once if you do not receive Disk2019 immediately after registration. Please note
that it is not necessary to download the full contents of the CD. You need Code::Blocks only.
You may copy it onto a memory stick and install it from there according to the instructions given
on the COS1512 website.
When you want to use myUnisa for the first time, you have to register. Go to my.unisa.ac.za and
click on “Join myUnisa”. Then follow the instructions on the screen. You will get a password for
future use. We also suggest that you get your myLife email address as soon as possible. See
the Study @ Unisa brochure for instructions. The University communicates with you via this
email address. You also get notified about important announcements for COS1512 via this
email address. Please check your myLife email regularly.
5.3 Additional Resources on myUnisa
Apart from the Disk2019 content that is available on myUnisa under Additional Resources, you
will find other resources such as old exam papers, extra examples of some programming
constructs, etc.
5.4 Announcements on myUnisa
We urge you to access myUnisa on a regular basis. We put announcements on myUnisa
regarding the module on a regular basis.
5.5 Installation of the software
Once you have access to a computer, you should install the software for this module on the
computer. (If you will be using one of Unisa's computer laboratories, the software will already be
installed). The software that you need for COS1512, namely a compiler and an IDE, are
included on the CD-ROM disk that you should have received as part of your study package
(Disk2019). The Learning Units contains full instructions on how to install the compiler and IDE
and how to start using them.
6 STUDY PLAN
Use your Study @ Unisa brochure for general time management and planning skills.
6.1 Syllabus
In this module we cover the following chapters of Savitch:
12
COS1512/101/3/2019
Chapter Sections covered
Chapter 1 1.1 and 1.2
Chapter 4 Only 4.6
Chapter 5 Only 5.5
Chapter 6 All sections
Chapter 8 8.1 and 8.3, plus the subsection Converting Between string Objects and C
Strings, thus excluding 8.2 with the exception of the subsection Converting
Between string Objects and C Strings
Chapter 9 All sections excluding the optional subsections in 9.2
Chapter 11 All sections, plus Appendixes 7 and 8
Chapter 12 12.1 and only the first two pages of 12.2
Chapter 14 14.1 and 14.2, thus excluding 14.3
Chapter 15 Only 15.1, thus excluding 15.2 and 15.3
Note that some of the sections (in Chapters 1, 4 and 5) are omitted, because they have already
been covered in COS1511. The other sections that are omitted fall outside the scope of this
module.
6.2 Planning your academic year
In overview, the undergraduate academic year is as follows:
First semester Second semester
21 January 2019 Academic year begins 8 July 2019 Academic year begins
18 February 2019 First assignment due 5 August 2019 First assignment due
1 April 2019 Second assignment due 16 September 2019 Second assignment due
May/June 2019 Examinations October/November 2019 Examinations
To get going with your studies, do the following:
 Read this tutorial letter (COS1512/101/3/2019) and Tutorial Letter

COSALLF/301/4/2019.
 Obtain a copy of the prescribed book.
13
 Arrange for access to a computer.
We provide two study programmes, one for students who registered for the first semester, and
one for students who registered for the second semester. We recommend that you use the
study programmes as a starting point. You will probably need to adapt this schedule, taking into
account your other modules and your personal circumstances.
Study programme for first semester registration:
Week Date (Monday) Activity Remark

1 21 Jan 2019 Install software, Do Questions 1 & 2 in Assignment 1
Study sections in
chapters 1, 4 and 5
2 28 Jan 2019 Study chapter 6 Do Questions 3 & 4 in Assignment 1
3 4 Feb 2019 Study chapter 9 Do Question 5 in Assignment 1
4 11 Feb 2019 Complete Due date 18 February
assignment 1
5 18 Feb 2019 Study chapter 10 Do Questions 1 & 2 in Assignment 2
6 25 Feb 2019
7 4 Mar 2019 Study chapter 11 Do Question 3 & 4 in Assignment 2
8 11 Mar 2019 Study chapter 12 Do Questions 5 & 6 in Assignment 2
9 18 Mar 2019 Study chapter 15 Do Question 7 in Assignment 2
Do Questions 1 & 2 in Assignment 3
10 25 Mar 2019 Complete Due date 1 April
assignment 2
11 1 Apr 2019 Study chapter 17 Do Questions 3, 4 & 5 in Assignment 3
12 8 Apr 2019 Study chapter 8 Do Questions 6 & 7 in Assignment 3
13 15 Apr 2019 Study chapter 14 Do Questions 8 in Assignment 3
14 22 Apr 2019 Complete Self-assessment
assignment 3
15 29 April 2019 till Revision Study all tutorial matter, including
exam solutions to assignments and material
provided in Additional Resources. Do
examination paper supplied in
examination tutorial letter on paper.
Study programme for second semester registration:
Week Date (Monday) Activity Remark

1 8 July 2019 Install software, Queries on software installation will only
Study sections in be answered up to 5 February
chapters 1, 4 and 5 Do Questions 1 & 2 in Assignment 1
2 15 July 2019 Study chapter 6 Do Questions 3 & 4 in Assignment 1
3 22 July 2019 Study chapter 9 Do Question 5 in Assignment 1
14
COS1512/101/3/2019
4 29 Jul 2019 Complete Due date 5 August

assignment 1
5 5 Aug 2019 Study chapter 10 Do Questions 1, 2 & 3 in Assignment 2
6 12 Aug 2019
7 19 Aug 2019 Study chapter 11 Do Question 4 in Assignment 2
8 26 Aug 2019 Study chapter 12 Do Questions 5 and 6 in Assignment 2
9 2 Sep 2019 Study chapter 15 Do Question 7 in Assignment 2
Do Questions 1 & 2 in Assignment 3
10 9 Sep 2019 Complete Due date 16 September
assignment 2
11 16 Sep 2019 Study chapter 17 Do Questions 3, 4 & 5 in Assignment 3
12 23 Sep 2019 Study chapter 8 Do Questions 7 & 7 in Assignment 3
13 30 Sep 2019 Study chapter 14 Do Questions 8 in Assignment 3
14 7 Oct 2019 Complete Self-assessment
assignment 3
15 14 Oct 2019 Revision Study all tutorial matter, including
till exam solutions to assignments and material
provided in Additional Resources. Do
examination paper supplied in
examination tutorial letter on paper.
6.3 Hints on studying this module

Study each chapter in the prescribed book by following these steps:
 Read the corresponding discussion given in the Learning Unit for the week when you
have to study the chapter. This discussion is also available in the Study Guide that can
be downloaded from the COS1512 website on myUnisa under Additional resources.
 Scan the chapter in Savitch to get an overview of what the chapter is about.
 Read the chapter again, making sure that you process the information. Relate the text to
the given program listings. You will sometimes have to read a little ahead or read a whole
section to make meaningful sense of a program listing or discussion. Many students
merely read the code and not the accompanying text that explains the code.
 Remember to highlight or indicate all the words or phrases you think are key points the
writer is making. You can use these and the headings to make your concept maps or
summaries whichever you prefer.
 Take the source listing of the sample programs in the textbook, type it into a text file,
compile it and execute it. Observe the output produced. Some of the source listings of
the examples can be found on the companion website that goes with your textbook.
Appendix B contains instructions on how to gain access to the source listings. The
Learning Units also contain links to some of the source listings.
15
 Do as many as possible of the self-check questions on a section as you study it. Answers
to the self-check questions are available at the end of each chapter.
 Answer the assignment questions on the chapter. Implement all programming questions
on your computer.
It is important to realise that the process of learning how to program follows a learning curve:
The more programs you write, the more proficient you will become. Remember that COS1512
has a large practical component and that it is essential to gain a lot of programming experience.
Programming modules also require much more time than other modules with no practical work.
You will probably find that you need to work hard and consistently throughout the semester to
develop the necessary programming skills. Plan to spend at least 8 hours per week on this
module.
7 MODULE PRACTICAL WORK AND WORK-INTEGRATED LEARNING

This module does not require any work integrated learning. However, all the assignments
require extensive practical work on a computer. The examination is a purely written examination
and does not involve doing any work on the computer. There are no compulsory separate
practicals that students need to attend during the year.
All COS1512 students must have access to a computer running Windows. The computer must
have a CD-ROM drive. Note that Windows 8 is the default operating system supported by
Unisa.
If you do not have a computer at home, gain access to one somewhere else, possibly at work,
at a friend’s home, or at one of Unisa’s computer laboratories. The Unisa computer laboratories
in Pretoria and at the regional offices are available to students for the practical work. You will
receive a COSALL tutorial letter explaining where the laboratories are, the hours during which
they are open and the booking procedure.
8 ASSESSMENT
8.1 Assessment plan
Assignments are seen as part of the learning material for this module. As you do the
assignment, study the reading texts, consult other resources, discuss the work with fellow
students or tutors or do research, you are actively engaged in learning. Looking at the
assessment criteria given for each assignment will help you to understand what is required of
you more clearly. The assessment criteria for each assignment correspond to a large extent to
the learning outcomes specified in the Study Guide and Learning Units for the study material
covered by the assignment.
Two sets of assignments for this year are given at the end of this tutorial letter. The first set of
assignments have to be submitted by students registered for the first semester, and the second
set of assignments have to be submitted by students registered for the second semester. The
tutorial matter you have to master in order to complete each assignment appears in the study
programme in Section 6 and at the start of each assignment. The Study Guide and Learning
Units contain details on each section.
Give yourself enough time to do the assignments properly, bearing in mind that a single session
in front of the computer will not be sufficient to complete a programming task. We suggest that
you do the assignment question(s) on a specific chapter as soon as you have studied it. This
will allow you to master the study material and to start timeously with your assignments.
The time constraints under the semester system do not allow us to accept late assignments.
16
COS1512/101/3/2019
All the assignments require practical work, i.e. programs that you have to implement on your
computer. Submit the source code of each program, as well as the input and corresponding
output for the program. Assignments1 and 2 have to be submitted by the due date. Assignment
3 is for self-assessment, i.e. you do not have to submit it to Unisa, but will ‘mark’ it yourself by
comparing your attempt with the model solution.
You are required to submit your assignments electronically via myUnisa in PDF format. Please
submit only one PDF file for an assignment. This PDF file should contain the source code as
well as the input and the output produced by that source code for each question in the
assignment. Tutorial Letter 103 under Additional Resources on the COS1512 website on
myUnisa shows you how to create your assignment as a PDF file so that you can submit it
electronically. There is also a video on how to create a PDF file for an assignment under
Additional Resources on the COS1512 website.
Please note the following:
 Submit only one copy of a specific assignment.

 Each assignment has a unique number. Use the correct assignment number and unique
number on myUnisa when submitting your assignments electronically.
 Please make sure that the assignment you submit contains the correct content.
 Please do not encrypt your assignment file or mark it as ‘Read only’.
 Do not send assignments directly to any of the lecturers or to the COS1512 e-mail
address.
 Assignments must reach UNISA on or before the due date.
 Check on myUnisa, or contact the Assignments Section to ensure that your assignment
was received by UNISA.
 All programs must be implemented on a computer. Hand-written programs will not be
marked.
 Copy your programs and output to one WORD document and convert it to PDF before
you submit.
 Use single spacing for the document that you submit.
 Only PDF files will be accepted.
 Assignments may not be submitted by fax or e-mail
For detailed information on how to submit assignments electronically, refer to the Study @
Unisa brochure, which you received with your study package. Instructions on how to register to
become a myUnisa user, are provided on the web site.
You will receive tutorial letters (201 and 202) discussing each assignment. The solution to
assignment 3 is provided on the course website under Additional Resources. Work through the
solutions and make sure that you understand them. When you receive your marked assignment
back from Unisa, compare it to our solutions and make sure you understand the differences,
and also why you lost marks. The assignments serve a very important learning function.
Therefore, even if you do not submit a particular assignment, you should still complete it and
compare your solution to ours as part of your study programme.
We may mark only selected questions in the assignment and not the entire assignment. In that
case, the mark allocation for the assignment will be adapted. However, as mentioned before,
we discuss each assignment question in a detailed tutorial letter that you will receive after the
due date.
17
When we mark assignments, we comment on your answers. Many students make the same
mistakes and consequently we discuss general problems in the solutions to the assignments.
As mentioned before, it is therefore, important to work through these tutorial letters and to
make sure you understand our solutions and where you went wrong.
The marks you obtain for an assignment are converted to a percentage. If you for instance
obtained 25 marks out of a possible 50 marks for Assignment 1, you received 50% for
Assignment 1. For Assignment 1 this percentage in turn contributes a weight of 20% to the year
mark, and for Assignment 2 this percentage contributes a weight of 80% to the year mark.
You are welcome to work in small groups. However, every member of the group must write and
submit his or her own individual assignment. Therefore, discuss the problem, find solutions, etc.
in the group, but then do your own programming and submit your own effort. You will learn to
program only if you sit down in front of the computer, type in the code, debug the program and
get it to work. It is unacceptable for students to submit identical assignments on the basis that
they worked together. That is copying (a form of plagiarism) and none of these assignments will
be marked. It is dishonest to submit the work of someone else as your own, i.e. to commit
plagiarism. Such unethical behaviour does not become our profession.
Assignment assessment and semester mark calculation: Your mark for this module is made
up of a semester mark (20%) and an examination mark (80%). The final semester mark is
calculated based on your performance in assignments throughout the semester. Therefore,
assignments not only give you the opportunity to evaluate your understanding of the materials
covered in the module, but also contribute towards your final mark.
The weights allocated to the assignments for COS1512 are summarized as follows:
Assignment number Weight
1 20%
2 80%
3 0% (self-assessment)
To explain how this will work, assume that a student receives 75% for assignment 1, and 80%
for assignment 2. His/her year mark will then be calculated as follows:
Mark Contribution to semester mark

Assignment received Weight
(Percentage) Mark(%) * Weight(%) Contribution
1 75% 20% 75/100 * 20/100 0.15
2 80% 80% 80/100*80/100 0.64
Total: 0.79
When the total of 0.79 is converted to 20% of the final mark, it will be 15.8%, thus the student’s
semester mark will be 15.8%. The examination will form the remaining 80% of the final mark for
the module. Note that the semester mark will not form part of the final mark for the
supplementary examination.
18
COS1512/101/3/2019
The following formula will be used to calculate your final semester mark:
Semester mark (out of 100) x 20% + Examination mark (out of 100) x 80%
8.2 General assignment numbers
Assignments are numbered consecutively starting from 01 using Arabic numerals. The
assignments are marked and a percentage is awarded according to your achievement. These
assignments have a very important learning function. Please attempt all assignments, and
compare them to the solutions provided.
8.2.1 Unique assignment numbers
Assignment Unique number
Assignment 1 Semester 1 845521
8.2.2 Due dates for assignments

The table below gives the due dates of the assignments for this module. Do not submit
assignment 3 - it is a self assessment assignment.
Assignment Due Date Semester Due Date Semester Weight

1 2
01 18 February 2019 5 August 2019 20%
02 1 April 2019 16 September 2019 80%
03 29 Apr 2019 - do not 14 October 2019 - do Self Assessment

submit not submit
Due to regulatory requirements (imposed by the Department of National Education) the

following applies: To gain admission to the examination you have to submit an assignment
before 5 April if you are registered for the first semester and before 30 August if you are
registered for the second semester. We suggest you submit ALL assignments to provide the
best possible preparation for the examination.
8.3 Submission of assignments
Students should submit assignments electronically via myUnisa. Assignments are not
accepted via fax or email.
For detailed information and requirements as far as assignments are concerned, see Study @
Unisa, which you received with your study package. Follow the instructions given in Tutorial
Letter COSALLF/301/4/2019, as well as the brochure Study @ Unisa, when submitting your
assignments. The URL for myUnisa is: http://my.unisa.ac.za/. Instructions on how to register to
become a myUnisa user, and how you should format your assignments before you submit them
19
electronically, are given on the web site. The two most important things to remember are that
your submission must consist of a single PDF file, and that you may submit an assignment only
once. Also, for COS512 use single line spacing in the documents that you submit.
The process to submit an assignment via myUnisa is briefly described below:
 Go to myUnisa at https://my.unisa.ac.za/.
 Log on with your student number and password.
 Choose the correct module (COS1512) in the orange block.
 Click on assignments in the menu on the left-hand.
 Click on the assignment number for the assignment that you want to submit.
 Follow the instructions.

PLEASE NOTE: Assignments can be tracked (e.g. whether or not the University has
received your assignment or the date on which an assignment was returned to you) on
myUnisa.
8.4 Assignments
The assignments for both semester 1 and semester 2 are available in Appendix A.
Please make sure that you do the correct assignments for the semester you have registered for.
All assignments are compulsory. Note that assignment 3 is the same for both semester 1 and
semester 2, and follows after the assignments for semester 2.
9 EXAMINATION
A 2 hour examination will be scheduled for this module. Please refer to the my Studies @ Unisa
brochure for general examination guidelines and examination preparation guidelines.
10 FREQUENTLY ASKED QUESTIONS

What if I cannot find the prescribed book?
Do not contact the lecturers if you have problems obtaining the textbook. If you have any
difficulties with obtaining books from the official booksellers bookshops, please contact
[email protected].
You can also buy an e-book version of Savitch at www.coursesmart.com.
What if I fail to submit my assignment on time?
A grace period is allowed for submission difficulties via MyUnisa. If the MyUnisa system is down
when you try to submit an assignment, do not contact the lecturers. Wait until the problem has
been solved and submit as soon as possible. We are usually aware of the problems with
MyUnisa. If you submit late for any other reason, include a note with the assignment with the
reasons for the late submission. No assignment will be marked (i.e. a mark of ZERO will be
awarded) after the solutions for the particular assignment have been published. This is usually a
week or two after the due date.
20
COS1512/101/3/2019
How do I request an extension? (Do not!)

Please do not phone, fax or email for an extension. Submit the assignment as soon as possible,
and include a note of explanation.
What if there are mistakes in the marking of assignments? (Do NOT re-submit to
Assignments Department!)
We use a team of external markers that are sub-contracted for the purpose of marking
assignments during the year. There are close to 500 students enrolled for the module. For this
reason, inconsistency in the marking style of individual markers may be encountered. We
request that students only query assignment marking where the marks will change significantly
(i.e. more than 5%). Please follow the RE-MAIL PROCEDURE below should you require that an
assignment be remarked. If your marks are added incorrectly or a question is not marked which
we stated (in the solutions) was to be marked, or you feel strongly that you were penalised
unfairly, follow the procedure below. If you phone we will just tell you to follow the RE-MAIL
PROCEDURE.
The RE-MAIL procedure:
Scan your marked assignment and attach it to an e-mail, addressed to the module email,
TOGETHER WITH A MESSAGE stating your marking dilemma with the specified questions of
the assignment.
What if I don't receive my study material or I lose it?
All study material is downloadable from myUnisa web site for COS1512. Please download
electronic copies (PDF files) of tutorial letters and the study guide from Official Study
Material or Additional Resources, and the CD from Additional Resources.
May I send my assignment by email?
No. Assignments have to be registered. Students may submit assignments either by post or
Mobile MCQ submission or electronically via myUnisa. Assignments are not accepted via fax or
e-mail.
Have we received your assignment?
If you want to find out whether an assignment has been received by Unisa, marked or
returned, look at the status of your assignment on MyUnisa.
11 IN CLOSING
Do not hesitate to contact your lecturer or e-tutor by email if you are experiencing problems with
the content of this tutorial letter or any aspect of the module.
I wish you a fascinating and satisfying journey through the learning material and trust that you
will complete the module successfully.
Enjoy the journey!
COS1512 Team
21
12 APPENDIX A: ASSIGNMENTS FOR COS1512
FIRST SEMESTER ASSIGNMENTS
ASSIGNMENT 1 (FIRST SEMESTER)
UNIQUE NUMBER 845521

DUE DATE: 18 February 2019
TUTORIAL MATTER: Chapters 4 to 7 and 9 of the Study Guide

Chapters 4 (section 4.6), 5 (section 5.5), 6
and 9 (excluding the optional parts of section
9.2) of Savitch
WEIGHT: 20%
MARKS: 70
EXTENSION: None
Answer all the questions. Submit all the programs you are required to write, as well as the
input and output of all programs.
Copy the programs and the required input and output to ONE word processor file with
single line spacing and convert it to a PDF file before you submit it. See Additional
Resources on MyUnisa for instructions on how to create a PDF file.
WE DO NOT ACCEPT ANY MEMORY STICKS OR CDs.
Question 1 (10 marks)

Write a program to compute and display the charges for a patient’s hospital stay. First the
program should ask if the patient was admitted as an in-patient or an out-patient. If the patient
was an in-patient, the following data should be entered:
 The number of days spent in the hospital

 The daily rate
 Hospital medication charges
 Charges for hospital services (lab tests etc)
The program should ask for the following data if the patient was an out-patient:
 Hospital medication charges
 Charges for hospital services (lab tests etc)
The program should use two overloaded functions, each named calcCharges, to calculate the
total charges for the patient. One of the overloaded functions should accept arguments
(parameters) for the in-patient data, while the other function accepts arguments for the out-
patient information. Both functions should return the total charges.
Test both overloaded functions in your program.
22
COS1512/101/3/2019
Write a C++ program to validate whether a matric student qualify to register for the BSc
Computer Science degree. The student qualifies if he or she is has achieved a minimum of 60%
in Mathematics, Physical Science and English. The program should use the assert function to
validate that the marks of the students are not more than 100%. The program should then
display a message to inform the student whether he qualifies or not. Run your program twice,
once to test it with marks for Mathematics, Physical Science and English less than or equal to
100%; and the second time testing it with one of the marks for Mathematics, Physical Science
and English more than 100%. Submit the output for both runs.

Write a C++ program that the Traffic Department can use when the owner of a car pays all his
outstanding road fines. The Traffic Department has a file called Fines.dat that keeps the
registration number and the road fine due for each traffic offence, one per line.
Your program should request the registration number from the user, read the contents of file
Fines.dat (shown below) line by line; if the road fine matches the registration number, display
the fine and calculate the total amount due for that registration number. At the same time all the
remaining registration numbers and road fines should be written to a new file called
OutStandingFines.dat.
Run your program to calculate the road fines owed by a car with registration number ABC123.
Fines.dat:
ABC123 400
DEC234 340
ABC123 500
GED345 600
ABC123 240
GEE600 120
GED345 230
GEE600 470
ABC123 120
NB: You should not count the number of lines in the file to determine how many times the file
should be accessed.
Sample output:
Please enter registration number: ABC123
Fines:
R400.00
R500.00
R240.00
R120.00
Total fine due R1260.00
Process returned 0 (0x0) execution time : 4.309 s

Press any key to continue.
23
To make phone numbers easier to remember, some companies use letters to show their phone
numbers. For example, using letters, the telephone number 438 5626 can be shown as GET
LOAN. In some cases, to make numbers more meaningful, companies may use more than
seven letters. For example, 225 5466 can be displayed as CALL HOME, which uses eight
letters.
Write a C++ program that reads a list of telephone numbers expressed in capital letters from a
text file and converts the telephone numbers in capital letters, to the corresponding telephone
numbers in digits. Each converted phone number should be displayed on the console in both
formats, alphabetic and digital. At the same time, the program creates another file in which the
telephone numbers appear in digital format, one number per line. Allow the user to specify the
name of the input file, as well as the name of the output file.
Apply the following convention: If a number consists of more than seven letters, only the first
seven letters are processed. A space is displayed between the third and fourth digits. Letters A,
B and C corresponds to digit 2; letters D, E and F to digit 3; letters G, H and I to digit 4; letters J,
K and L to digit 5; letters M, N and O to digit 6; letters P, Q R and S to digit 7; letters T, U and V
to digit 8; and letters W, X, Y and Z to digit 9. If any other character is encountered, a * is
displayed.
The input file contains the following data, with one number per line:
CALL HOME
GET LOAN
Hi THERE
BYE FOR NOW
HELP ME PASS
For example, once the first number in the input file has been processed, the console window
should display the following:
CALL HOME 225 5466.
The output file should now also contain the number:

225 5466

(a) What is a pointer?
(b) What is a dereferencing operator?
(c) What is the difference between assignment statements p1 = p2; and *p1 = *p2;
(d) What is a dynamic variable?
(e) What is the purpose of the new operator?
(f) What is the purpose of the delete operator?
(g) What is the freestore (also called the heap)?

(h) What is the difference between dynamic variables and automatic variables?
24
COS1512/101/3/2019
(i) What is a dynamic array?

(j) What is the advantage of using dynamic arrays?
(k) What is the relationship between pointers and arrays?
(l) Write statements to do the following:
i. Define two pointer types p1 and p2 for pointer variables that contain pointers to
int variables.
ii. Declare two int variables a and b and initialize b to 100.
iii. Let p1 point to b.
iv. Dynamically allocate an integer variable and store its address in p2.
v. Divide the value that p1 is pointing to by 4 and assign the result to a.
vi. Assign the result of b divided by a to the variable that p2 is pointing to.
vii. Define an int pointer p3.
viii. Let p3 point to a.
ix. Assign the value of the variable that p2 is pointing to, to the variable that p3 is
pointing to.
x. Add 6 to variable a.
xi. Assign twice the value of the variable that p3 is pointing to, to the variable that p1
is pointing to
xii. Let p1 point to the same variable as p2.
xiii. What is the value of the variable that p1 is pointing to at this stage? (Hint: Add
statements (i) – (xiii) in a C++ program and display the value of the variable in
question).
xiv. Free the memory allocated to the variables that p1, p2 and p3 are pointing to.
(m) Write statements to do the following:
i. Declare an int variable count, ask the user to input its value, and read in the
value.
ii. Define a pointer type PtrType for pointer variables that contain pointers to int
variables.
iii. Declare p1 to be a pointer to a variable of type int.
iv. Dynamically allocate an array of count integers and store its address in p1.
v. Initialise the elements of the array that p1 is pointing to, so that each element has
the value of its position in the array (starting at position 0 as the first position).
vi. Display the values of the array elements – each element on a new line.
25
vii. Free the memory allocated to the array that p1 is pointing to.
26
COS1512/101/3/2019
ASSIGNMENT 2 (FIRST SEMESTER)

DUE DATE: 1 April 2019
TUTORIAL MATTER: Chapters 10, 11, 12 and 15 of the Study

Guide (Tutorial Letter 102 available under
Additional Resources on the COS1512
website on myUnisa )
Chapters 10, 11, 12 (excluding “Creating a
Namespace”) and 15 (only 15.1 “Inheritance
basics”)
Appendices 7 and 8 in Savitch
EXTENTION: None
WEIGHT: 80%
MARKS: 110
Consider the following structure used to keep module records:
struct Module
{
string moduleName;
string moduleCode;
string lecturer;
int nrStudents;
}
Turn the module record into a class type rather than a structure type. The module class should
have private member variables for all the data. Include public member functions for each of
the following:
 a default constructor that sets the module‘s name and lecturer to a blank string, the
module code to seven 0’s and the number of students to 0;
 an overloaded constructor that sets the member variables to specified values;
27
 member functions to set each of the member variables to a value given as an argument
to the function (i.e. mutators);
 member functions to retrieve the data from each of the member variables (i.e accessors);
Embed your class definition in a test program. The program should input a value for each of the
member variables, use the overloaded constructor to instantiate a module object and then print
all the available information for that module. Use the keyboard to supply input and display the
output on the screen. Test your program with the following input:
Module name: Introduction to Programming II
Module code: COS1512
Lecturer: Dr Schoeman
Number of students: 534
Question 2 – a bit of theory and terminology (20 marks)
(a) What is the purpose of the keywords public and private in the class declaration?
(b) What is the difference between a class and an object?

(c) What does it mean to ‘instantiate’ an object?
(d) What is the purpose of a constructor?
(e) What is the difference between the default constructor and the overloaded constructor?
(f) What is the purpose of a destructor?
(g) What is the purpose of an accessor?
(h) What is the purpose of a mutator?
(i) What is the purpose of the scope resolution operator?
(j) What is the difference between the scope resolution operator and the dot operator?
(k) What is the difference between a member function and an ordinary function?
(l) What is an abstract data type (ADT)?
(m) How do we create an ADT?
(n) What are the advantages of using ADTs?
(o) What is separate compilation?
(p) What are the advantages of separate compilation?
(q) What is a derived class?
(r) What is the purpose of inheritance?
28
COS1512/101/3/2019
Consider the class declaration and main() function below. There are two errors in the main()
function. Name the errors and explain how to fix them.
class Game
{
public:
Game();
string getName();
int getLevel();
double getScore();
private:
string Name;
string Champion;
int Level
double Score;
};
int main()
{
Game sodoku, brickbreaker[2];
.........(additional code)
double nScore = sodoku.Champion;
return 0;
cout << "The first brickbreaker player is "
<< brickbreaker.getName() << endl;
}
The questions below refer to the class declaration of the class Money, which represents the
South African currency. The class has two integer data members, rands and cents.
#include <iostream>
using namespace std;
class Money
{
public:
Money(); // default constructor
Money(int r, int c); // constructor
~Money(); // destructor
int theRands() const;
int theCents() const;
Money Plus(Money m);
Money operator+ (Money & m);
bool GreaterThan(Money m);
private:
29
int rands;
int cents;
};
int main()
{
Money m1;
Money m2(15,90);
Money m3(5,15);
m1 = m2.Plus(m3);
cout << m1 << " + " << m2 << " gives " << m1.Plus(m2) << endl;
m1 = m2 + m3;
cout << m2 << " + " << m3 << " gives " << m1 << endl;
if (m2.GreaterThan(m1))
cout << m2 << " is greater than " << m1 << endl;
else
cout << m2 << " is less than " << m1 << endl;
return 0;
}
(b) What is the purpose of a constructor?

(c) Give implementations of the default constructor and the second constructor, as well as the
destructor.
(d) Implement the theRands and the theCents member functions. theRands returns the
number of rands and theCents returns the number of cents.
(d) Implement the Plus()member function. The Plus() member function should add a
Money object to the existing Money object, and return the sum as a Money object.
(e) Implement the overloaded operator+ that adds a Money object to the existing Money
object, and returns the sum as a Money object.
(f) The member function greaterThan() is used to compare two Money objects with each
other. Give an implementation for this member function.
(g) Overload the stream insertion operator as a friend function. It should use the member
functions the theRands and the theCents to write the value of the Money object to the
given output stream.
(h) The statement
if (m1 > m2)
cout << m2 << " is greater than " << m1 << endl;
else
cout << m2 << " is less than " << m1 << endl;
displays a message to indicate which value is bigger. Give three different implementations
for the overloaded operator > to accomplish this:
 using the member function greaterThan()
 implementing the overloaded operator > as a friend function
 implementing the overloaded operator > as a member function. Hint: See chapter
11 in the study guide, Appendix F.
30
COS1512/101/3/2019
(i) Run your program three times: each time with a different version of the overloaded operator
>; comment the other two versions out during each run using "//".
Enrichment exercise:
Turn the Money class into an ADT, so that separate files are used for the interface and
implementation. Use separate compilation to compile the implementation separate from
the application program that tests the ADT.
PLEASE NOTE: The enrichment exercises do not form part of the assignment. It is for practice
only.
Define a class MedicalAidMember as an aDT that uses separate compilation, i.e. separate
files for the interface and the implementation. The class represents the medical aid record for a
staff member and has five member variables:
 name, a string that holds the combined first name and last name of the staff member
 number, an integer that indicates the medical aid number of the staff member
 nrDependants, an integer that denotes the number of dependants the staff member
has
 dependants, an array to keep a maximum of six string values, representing the
names of the staff member’s dependants, and
 contribution, a double value that indicates the staff member’s medical aid
contribution.
In addition, the class should have the following member functions:

 A default constructor that initializes all the names to empty strings. All numerical data
members should be initialized to 0.
 An overloaded constructor that sets name and number to specified values.
nrDependants should be set to 0, while all elements in dependants are initialized to
empty strings. contribution should be initialized to 1000.
 A destructor that does not perform any action.
 Accessor functions for member variables name and number.
 A member function addDependant() that adds the name of a dependant to
dependants; and update the value of nrDependants. Make sure that the number of
dependants never exceeds 6. Use the following prototype: void
addDependant(const string dependant);
 A member function calcContribution() that adds R150.55 to the staff member’s
medical aid contribution for each dependant, and update member variable
contribution accordingly.
 An overloaded stream insertion operator << (implemented as a friend function) that
outputs all the member variables of a MedicalAidMember object to any file in the
following format:
Staff member’s name
Staff member’s medical aid number
Number of dependants
List of dependants, one name per line
31
Medical aid contribution in rands and cents.
Demonstrate the class in an application program (main.cpp) that is used to create medical aid
records for staff members and then insert these records in a file called MedicalAidData.dat.
The program extracts a staff member’s first name and last name from a file called Staff.dat,
then creates a string representing the staff member’s name. It generates a random number to
be used as the medical aid number for the staff member. An object member is then instantiated
to represent the staff member. The number of dependants the staff member has is obtained
from the user and each dependant’s name is entered. This is used to update the object
member. The staff member’s medical aid contribution (based on the number of dependants) is
then calculated and updated. Thereafter the object member is inserted into the file
MedicalAidData.dat.
Using the input file Staff.dat below and the highlighted input given as shown in the console
output below:
Input file Staff.dat:
Peter McConroy
Dumisang Mkhize
Eleanor Esterhuizen
the program produces the following output:

Peter McConroy's medical aid number is 549
How many dependants does this member have? 1
Enter name of dependant: Annie
Dumisang Mkhize's medical aid number is 12100

Enter name of dependant: Alice
Enter name of dependant: Alex
Eleanor Esterhuizen's medical aid number is 23651

and should produce the following output file

MedicalAidData.dat:
Peter McConroy
549
1
Annie
R1150.55
Dumisang Mkhize
12100
2
Alice
Alex
R1301.10
Eleanor Esterhuizen
23651
0
R1000.00
32
COS1512/101/3/2019
Remember that even if you use the same input file, the medical aid number will differ because it
is generated as a random number. Submit copies of the input and output files and the console
window, as well as all the files in the ADT.
Overload the stream extraction operator >> for the class Module in Question 1 to input values
for an object of class Module either from the keyboard or from a file. Also overload the stream
insertion operator << to output the data for a module either on the screen or to a file.
Use separate compilation and write a program that inputs the name of a lecturer. The program
should then find all the modules taught by that lecturer in a file named Modules.dat, and put
those objects into an array. Assume that the file will never contain data for more than 20
modules. Use the array to determine the total number of students taught by the lecturer, as well
as the average number of students per module taught by the lecturer. Display the names of the
modules, the total number of students taught by the lecturer, and the average number of
students per module taught by the lecturer on the screen. Use the overloaded stream extraction
operator >> to extract objects from file Modules.dat. Use the following data for
Modules.dat:
Introduction to Programming I
COS1511
Dr Schoeman
2354
Introduction to Programming I
COS1511
Mrs du Plessis
2534
COS1512
Dr Schoeman
458
COS1512
Mrs du Plessis
2698
Adapt the application program to use a vector instead of an array. It should not be necessary to
change the class interface or implementation file in any way.
This is an additional exercise which you can try once you have studied Chapter 8 (C strings and
Vectors) in Sebesta. You do not have to submit it as part of Assignment 2 and we will not mark
it, if you do submit it.
33
Consider the following class:
class Computer
{
public:
Computer();
Computer(int s, int mm, int hm);
void display_specs(ostream & out)const;
int get_speed()const;
int get_mmemory()const;
int get_hmemory()const;
private:
int speed;
int main_memory;
int harddisk_memory;
};
(a) Implement class Computer.
(b) Test class Computer in a driver program that does the following:
 instantiates an object of class Computer, with the following details:
speed: 1600
main memory: 4
hard disk: 16
 use the accessor functions to display the specifications of the instantiated object on
the console
 display the specifications of the instantiated object on the console with the member
function display_specs().
(c) Derive and implement a class Laptop from class Computer. This class has additional
member variables, battery_time and weight. Class Laptop also has an overloaded
constructor and member functions, get_battime() and get_weight()to return
member variables battery_time and weight respectively. The class Laptop should
override function display_specs() in order to display the member variables of Laptop.
Implement the overloaded constructor for the class Laptop by invoking the base class
constructor.
(d) Test class Laptop in a driver program that does the following:
 instantiates an object of class Laptop, with the following details:
speed: 1333
main memory: 2
hard disk: 8
battery time: 8
weight: 1.25
 use the accessor functions to display the specifications of the instantiated object on
the console.
34
COS1512/101/3/2019
SECOND SEMESTER ASSIGNMENTS

ASSIGNMENT 1 (SECOND SEMESTER)

DUE DATE: 5 August 2019
TUTORIAL MATTER: Chapters 4 to 7 and 9 of the Study Guide

Chapters 4 (section 4.6), 5 (section 5.5), 6,
and 9 (excluding the optional parts of section
9.2) of Savitch
WEIGHT: 20%
MARKS: 70
EXTENSION: None

Write a program to calculate the volume of spheres, cylinders and boxes. Your program should
contain three functions, each called calcVolume and returning a double. The volumes should
be calculated according to the following formulas:
 The volume of a box is its width multiplied by its height multiplied by its length.
 The volume of a sphere is 4/3r3, where r is the radius of the sphere.
 The volume of a box is r2h, where r is the radius of the cylinder and h is the height of the
cylinder.
Define a global constant PI and set its value to 3.14. Your program should ask the user which
shape’s volume they want to calculate, and get the required information. It should then call the
correct calcVolume function and output the volume to the screen.
35
Write a C++ program to calculate windchill factor. Windchill factor is an index taking into account
the wind speed and the temperature in cold weather to provide a measure of the chilling effect
of wind at a given air temperature. Windchill can be calculated by the formula:
W = 13.12 +0.6215 * t – 11.37 * v0.16 + 0.3965 * t * v0.016
where
v = wind speed in m/sec
t = temperature in degrees Celsius: t <= 10
W = windchill index (in degrees Celsius)
Write and test a function that returns the windchill index. Your code should ensure that the
restriction on the temperature is not violated.
Hint: See Appendix 4 in Savitch for the function double pow (double, double) to raise
the first argument to the power of the second argument. Remember to include the <cmath>
header.

Write a program that will calculate a student’s year marks for all his subjects. The program must
read the subject code, the assignment marks for two assignments and the percentage that each
assignment contributes towards the year mark, for each subject that the student is registered
for.
Create an input file called assignments.dat that contains the following information for a
specific student:
COS1511 30 66 70 49
COS1512 25 76 75 67
COS1521 10 58 90 62
COS1501 50 62 50 57
INF1501 40 82 60 78
INF1511 20 24 80 55
The first field in each line represents the subject code, followed by the percentage that
assignment 1 contributes towards the year mark and the student’s percentage for assignment 1.
Then follow the percentage that assignment 2 contributes towards the year mark and the
student’s percentage for assignment 2. You should not count the number of lines in the file to
determine how many times the file must be accessed.
Your program must read the file line by line, calculate the student’s year mark for the subject as
a percentage and write the subject code and the year mark to an output file yearmark.dat. If
your program works correctly, the output file will look as follows:
COS1511 54.10%
COS1512 69.25%
COS1521 61.60%
COS1501 59.50%
36
COS1512/101/3/2019
INF1501 79.60%
INF1511 48.80%

Lebo is in grade 4. She typed the following essay about her holiday on the computer. Please
help her correct the following 2 errors - she did not start her sentences with uppercase letters,
and she used the character ‘5’ instead of the letter ‘s’.
Create a file named essay.txt containing the essay below. Write a program that will read the
file character by character, change the first character of the first word of each sentence to an
uppercase character, and change all the ‘5’ characters to ‘s’. Write the essay character by
character to an output file called correct.txt.
Create an input file called essay.txt with the essay as follows:

my holiday. we went to my aunt’5 farm. 5he ha5 ponie5. 5he taught me
to ride the ponie5, and that wa5 great fun. and 5he ha5 lot5 and lot5
of 5trawberrie5. we could pick them our5elve5, and we could eat a5
many a5 we wanted. my uncle let me help him to milk the cow5. it i5
very difficult. the duck in the duck pond bit my finger when I gave
him bread to eat.
Ask the user to input the name of the input and output file.

(b) What is a pointer?
(b) What is a dereferencing operator?
(c) What is the difference between the assignment statement p1=p2; and *p1 = *p2;
(d) What is a dynamic variable?
(e) What is the purpose of the new operator?
(f) What is the purpose of the delete operator?
(g) What is the freestore (also called the heap)?

(h) What is the difference between dynamic variables and automatic variables?
(i) What is a dynamic array?
(j) What is the advantage of using dynamic arrays?
(k) What is the relationship between pointers and arrays?
(l) Write statements to do the following:
i. Define a pointer type int_ptr for pointer variables that contain pointers to int
variables.
37
ii. Declare p1 to be a pointer to an int.
iii. Dynamically allocate an integer variable and store its address in p1.
iv. Assign the value 23 to the variable that p1 is pointing to.
v. Declare an int variable a.
vi. Let p1 point to a.
vii. Free the memory allocated to the variable that p1 is pointing to.
(m) Write statements to do the following:
i. Define a pointer type int_ptr for pointer variables that contain pointers to int
variables.
ii. Declare p2 to be a pointer to an int.
iii. Obtain an integer value nrElements from the user indicating the number of
elements to allocate.
iv. Dynamically allocate an array of nrElements integers and store its address in
p2.
v. Declare an int array a with 500 elements.
vi. Assume p2 has been initialized and copy the elements of p2 one by one to the
corresponding elements in a.
vii. Free the memory allocated to the variable that p2 is pointing to.
(n) Write a program that asks a user to enter the size of a dynamic array that stores exam
marks obtained by students. Create the dynamic array and a loop that allows the user to
enter an exam mark into each array element. Loop through the array to calculate the
highest mark obtained and output it. Delete the memory allocated to your dynamic array
before exiting your program.
38
COS1512/101/3/2019
ASSIGNMENT 2 (SECOND SEMESTER)

DUE DATE:
16 September 2019
TUTORIAL MATTER: Chapters 10, 11, 12 and 15 of the Study

Guide (Tutorial Letter 102 available under
Chapters 10, 11, 12 (excluding “Creating a
Namespace”) and 15 (only 15.1 “Inheritance
basics”)
Appendices 7 and 8 in Savitch
WEIGHT: 80%
MARKS: 110
EXTENTION: None
Consider the following structure used to keep an address:
struct Address
{
string streetName;
int streetNr;
string city;
string postalCode;
}
Turn the address record into a class type rather than a structure type. The address record class
should have private member variables for all the data. Include public member functions
for each of the following:
39
 a default constructor that initialises the street name and the city to a blank string, the
street number to 0 and the postal code to a string of four 0’s;
 member functions to set each of the member variables to a value given as an argument
to the function (i.e. mutators);
 and member functions to retrieve the data from each of the member variables (i.e.
accessors).
Use this class in a program which prints an address. The program should input a value for each
of the member variables and then print an address consisting of the values for the member
variables in proper address format. Use the keyboard to supply input and display the output on
the screen. Test your program with the following input:
Street name: Preller St
Street number: 543
City: Muckleneuk
Postal code: 0002
Question 2 – a bit of theory and terminology (20 marks)
(b) What is the difference between a class and an object?

(c) What does it mean to ‘instantiate’ an object?
(d) What is the purpose of a constructor?
(e) What is the difference between the default constructor and the overloaded constructor?
(f) What is the purpose of a destructor?
(g) What is the purpose of an accessor?
(h) What is the purpose of a mutator?
(i) What is the purpose of the scope resolution operator?
(j) What is the difference between the scope resolution operator and the dot operator?
(k) What is the difference between a member function and an ordinary function?
(l) What is an abstract data type (ADT)?
(m) How do we create an ADT?
(n) What are the advantages of using ADTs?
(o) What is separate compilation?
(p) What are the advantages of separate compilation?
(q) What is a derived class?
(r) What is the purpose of inheritance?
40
COS1512/101/3/2019
Consider the following class declaration with a main() function. There are two errors in the
main() function. Name them and explain how to fix them.
class Restaurant
{
public:
Restaurant();
int getTables();
int getTempStaff();
int getPermStaff();
string getShifts();
private:
string Menu;
int Tables;
int TempStaff;
int PermStaff;
string Shifts[3];
};
int main()
{
Restaurant mimmos;
string menu = mimmos.Menu;
//get information about shift 3

cout << "Shift info:" << mimmos[2].getShifts() << endl;
return 0;
}

The following code is a partial implementation of a class:
#include <iostream>
#include <string>
class Scrabble {
public:
Scrabble();
Scrabble(string word, int rem);
~Scrabble();
void Calculate();
void Penalize();
void SetLetters();
void GetLetters(string &let1,string &let2, string &let3);
void SetWord(string word, int rest);
string GetWord();
41
int GetPoints();
private:
string letters1, letters2,letters3;
string wordBuilt;
int points;
int unused;
};
//Retrieve word
string Scrabble:: GetWord()
{
return(wordBuilt);
}
//Retrieve points
int Scrabble:: GetPoints()
{
return(points);
}
//Initialises sets of letters

void Scrabble::SetLetters()
{
letters1 = "A B D L U R S I E O ";
letters2 = "B S R L O T E M P U ";
letters3 = "V C M O P A R G Y R ";
}
int main(){
int point;
string word;
string let1, let2, let3;
int rest;
Scrabble Scrabble1;
Scrabble1.SetLetters();
Scrabble1.GetLetters(let1, let2, let3);
cout << "\nLet's play a bit of scrabble...You get 3 tries..."
<< endl;
cout << "Please make the longest word possible using the "
<< "following letters:\n" << let1 << endl;
cout << "\nYou will be penalised for letters not used.\n";
cin >> word;
rest = 10 - word.size();
Scrabble1.SetWord(word,rest);
Scrabble1.Calculate();
Scrabble1.Penalize();
cout << Scrabble1 << endl;
cout << "\nPlease make the longest word possible using the "
<< "following letters:\n"<<let2<<endl;
cin >> word;
42
COS1512/101/3/2019
cout << "\nPlease make the longest word possible using the "
<< "following letters:\n"<<let3<<endl;
cin >> word;
return(0);
}
The program displays a number of letters on the screen and asks the user to build a word, using
as many of the letters as possible.
(b) What is the purpose of a constructor?
(c) Is SetLetters()an accessor or mutator? Explain your answer.
(d) Complete the implementation of the class by writing code for the following:
 Implement a destructor for the class Scrabble.
 Implement the constructors. By default wordBuilt should be initialized to
“SCRABBLE” and unused to 10. The second constructor allows the user to initialize
wordBuilt and unused to other values.
 Implement the member function GetLetters().
 Implement the member function SetWord() which will update the private variable
wordBuilt with the word that the user built as well as update the variable unused
with the number of letters that the user did not use.
 Implement the member function Penalize(). This function must deduct three points
for each letter not used, and update points accordingly.
 Implement the member function Calculate(). This function must calculate and
update points according to the rules below:
Letters A,E,I,U and O, are worth 4 points each,
letters B,D,P,R and M, are worth 3 points each,
letters T,S,C,L and N, are worth 2 points each,
letters K,X,Z,W and Y, are worth 8 points each,
letters V,F,G,J and H, are worth 9 points each,
any remaining letters are worth 1 point each.
43
 Overload the insertion operator to send the word and points to the given output
stream.
Enrichment Exercise:
Turn the Scrabble class into an ADT, so that separate files are used for the interface and
implementation. Use separate compilation to compile the implementation separate from the
application file that tests the ADT.
PLEASE NOTE: The enrichment exercises do not form part of the assignment. It is for practice
only.
Define a class Shares as an ADT that uses separate compilation (i.e separate interface and
implementation files). The class represents shares for a shareholder in a specific company on
the JSE. This class has four member variables:
 company, a string that holds the name of the company
 nrShares, an integer value that indicates the number of shares this shareholder owns
 unitValue, a float value that indicates the current value of one share and
 pastUnitValues, an array to keep five double values.
In addition, the class has the following member functions:

 A default constructor that initializes company to an empty string. nrShares and
unitValue should each be initialized to 0. All elements in pastUnitValues should be
initialized to 0.
 An overloaded constructor that represents shares bought in a new company and sets
company, nrShares and unitValue to specified values, while all elements in
pastUnitValues are initialized to 0.
 A destructor that does not perform any action.
 Accessor functions for member variables nrShares and unitValues.
 An overloaded equality operator== to compare two Shares objects. The ==
operator is implemented as a friend function with the following prototype:
bool operator==(const Shares & s1, const Shares & s2)
This function returns true if shares1 and shares2 have the same company name;
and false if not.
 A member function updateShares() that adds the number of shares bought to
nrShares; update the value of unitValue and also update pastUnitValues to
include the unit value of the current purchase as the last element in array
pastUnitValues. Hint: move all elements in pastUnitValues one position to the left
to add the current unitValue as the last element. Use the following prototype: void
updateShares(const Shares & s1);
 An overloaded extraction operator >> (implemented as a friend function) so that it
can be used to input values of type Shares.
 An overloaded insertion operator << (implemented as a friend function) that outputs
all the member variables of a Shares object.
44
COS1512/101/3/2019
Demonstrate the class in an application program (main()). This program obtains the detail for
a new purchase of shares from the user and creates an object to represent the new purchase of
shares. It then extracts all existing shares in the user’s portfolio one by one from a file
Portfolio.dat and checks whether the shareholder already has shares in the company. If
the user already holds shares in the company, the member function updateShares() is used
to update the shares in the company to include the new shares purchased. All shares (updated
as well as unchanged existing shares) are output to a new portfolio file called
NewPortfolio.dat. If the user does not already own shares in the company, the new
purchase of shares are simply output to NewPortfolio.dat. Before outputting a shareholding
to NewPortfolio.dat, the program calculates the value of the shareholding (number of
shares * unit value per share) and adds it to a running total. The running total is used to
calculate the total value of the shares, which is displayed on the console window at the end of
the program. Be sure to use appropriate member functions in the required statements. See
below for sample input and corresponding output. Submit copies of the input and output files
and the console window, as well as all the files in the ADT.
Portfolio.dat
OldMutual 10 12.5 0 0 0 0 12.5
Sanlam 15 10.5 12.43 15.3 11.4 9.4 10.5
Allied 5 6.5 0 0 8.45 7.98 6.5
Output:
Enter name of company in which shares are bought: OldMutual
Enter number of shares bought: 10
Enter unit value of one share: 5
Total value of all shares: R 290.00
Process returned 0 (0x0) execution time : 11.030 s

Press any key to continue.
NewPortfolio.dat
OldMutual 20 5 0 0 0 12.5 5
Sanlam 15 10.5 12.43 15.3 11.4 9.4 10.5
Allied 5 6.5 0 0 8.45 7.98 6.5
Overload the stream extraction operator >> for the class Address defined in question 1 to
input an object of class Address either from the keyboard or from a file. Also overload the
stream insertion operator << to output an Address object either to the screen or to a file.
Use separate compilation to convert class Address to an ADT. Then write an application
program that requests the user to specify a postal code and uses the overloaded extraction
operator >> to extract Address objects one by one from a file named Address.dat.
Compare the postal code supplied by the user to the postal code of each object extracted from
the file. If the postal codes are the same, put the object into an array of Address objects.
Assume that the array will never need to contain more than 20 Address objects. Once all the
45
objects have been extracted from the file and compared to the user-specified postal code, use
the overloaded insertion operator << to display all the Address objects in the array.
Use the following data for the file Address.dat:

Hope St
67
Clarence
0917
Nelson Mandela Drive
643
Pretoria
0181
Albert St
91
Pretoria
0181
Church St
14
Wellington
6734
Main St
907
Soweto
0912
Bushbuck St
89
Polokwane
3452
If the user input 0181 as the postal code, your program should display the two addresses in
Pretoria on the screen.
Adapt the application program to use a vector instead of an array. It should not be necessary to
change the class interface or implementation file in any way.
This is an additional exercise which you can try once you have studied Chapter 8 (C strings and
Vectors) in Savitch. You do not have to submit it as part of Assignment 2 and we will not mark it,
if you do submit it.
Define a class Employee with member variables for an employee’s basic salary, pension
amount, medical aid amount and tax percentage. (The medical aid amount and pension amount
is what the employee pays – the company also contributes the same amount towards the
employee’s salary). The tax is calculated on the sum of the basic salary, pension amount and
medical aid amount.
Add appropriate constructors and accessors for class Employee and include the following
member functions:
 a member function calcTax()to calculate the amount that will be deducted from the
employee’s salary for tax.
46
COS1512/101/3/2019
 a member function calcGrossPay() to calculate the gross pay consisting of the basic
salary plus the pension amount (contributed by the company) plus the medical aid
amount (contributed by the company).
 A member function calcDeductions() to calculate how much should be deducted

from the gross salary for pension and medical aid, i.e. the company’s contribution plus
the member’s contribution.
(e) Implement class Employee.
(f) Test class Employee in a driver program that does the following:
 Instantiates an object of class Employee, with the following details:
basic salary: R25110.00
pension amount: R2350.00
medical aid amount: R2400.00
% tax paid: 0.08.
 Use the accessor functions to display the specifications of the instantiated object on
the console.
 Calculate and display an employee’s net salary by deducting the tax amount and the
medical aid and pension deductions from the gross salary. Use functions
calcTax(), calcGrossSalary()and calcDeductions()to accomplish this.
(g) Derive and implement a class Manager from class Employee. This class has an
additional member variable, Allowance (the entertainment allowance amount that a
manager receives). Class Manager also has an overloaded constructor and a function
Display() that displays the salary details of a manager. The class Manager should
override function calcTax() in order to include the entertainment allowance in the
taxable amount when the tax percentage is calculated. It should also override function
calcGrossPay()to include the entertainment allowance.
Implement the overloaded constructor for the class Manager by invoking the base class
constructor.
(h) Test class Manager in a driver program that does the following:
 instantiates an object of class Manager, with the following details:
basic salary: R60560.00
pension amount: R5500.00
medical aid amount: R2800.00
allowance: R3100.00
% tax paid: 0.14.
 display the specifications of the instantiated object on the console with the member
function Display()
 Calculate and display a manager’s net salary by deducting the tax amount and the
medical aid and pension deductions from the gross salary. Use functions
calcTax(), calcGrossSalary()and calcDeductions()to accomplish this.
47
SELF ASSESSMENT ASSIGNMENT 3 (SEMESTER 1 AND SEMESTER 2)
TUTORIAL MATTER: Chapters 8, 14, 15 and 17 of the Study Guide

(Tutorial Letter 102 available under
Chapters 8, 14 (excluding section 14.3), 15
(excluding sections 15.2 and 15.3) and 17 of
Savitch
WEIGHT: None
MARKS: 0
This assignment is for self-assessment. Do not submit this assignment. The solution to this
assignment appears in Appendix E of this tutorial letter.
Question 1
Examine the code fragment below and answer the questions that follow:
1: #include <iostream>
2: using namespace std;
3:
4: //------------------------------------------
5:
6: class A
7: {
8: private:
9: int x;
10: protected:
11: int getX();
12: public:
13: void setX();
14: };
15:
16: int A::getX()
17: {
18: return x;
19: }
20:
21: void A::setX()
22: {
23: x=10;
24: }
25:
26: //----------------------------------------------
27: class B
48
COS1512/101/3/2019
28: {
29: private:
30: int y;
31: protected:
32: A objA;
33: int getY();
34: public:
35: void setY();
37: };
38:
39: void B::setY()
40: {
41: y=24;
42: int a = objA.getX();
43: }
44:
45: //----------------------------------------------
46:
47: class C: public A
48: {
49: protected:
50: int z;
51: public:
52: int getZ();
53: void setZ();
54: };
55:
56: int C::getZ()
57: {
58: return z;
59: }
60:
61: void C::setZ()
62: {
63: z=65;
64: }
Answer the following questions based on the code fragment given above:
(a) Is line 18 a valid access? Justify your answer.
(b) Is line 32 a valid statement? Justify your answer.
(c) Identify another invalid access statement in the code.
(d) Class C has public inheritance with the class A. Identify and list class C’s private,
protected and public member variables resulting from the inheritance.
(e) If class C had protected inheritance with the class A, identify and list class C’s
private, protected and public members variables resulting from the inheritance.
Question 2
49
Consider the class definitions below and answer the questions that follow:
class Date
{
public:
friend ostream & operator<<(ostream & cout, const Date & d);
Date(int y, int m, int d);
private:
int year, month, day;
};
class Publication
{
public:
Publication(const string & p, const Date & d,
const string & t);
Date GetDate( ) const;
string GetPublisher( )const;
string GetTitle() const;
private:
string publisher;
Date date;
string title;
};
(a) Implement the Date and the Publication classes.
(b) Code the interface of a derived class Book for which the Publication class is the
base class. The Book class has two additional member variables representing the ISBN
number and the author of a book. Furthermore, the Book class contains member
functions getISBN( ) and getAuthor( ) that return the ISBN number and the author
respectively. The declaration must also include a constructor for the class Book.
(c) Implement the Book class.
(d) Recode the following interface such that class Magazine, derives from class
Publication:
class Magazine
{
public:
Magazine(const string & p, const Date & d, int ipy);
int GetIssuesPerYear( ) const;
Date getDate( ) const;
string getPublisher( )const
private:
int issuesPerYear;
string publisher;
Date date;
string title;
};
(e) Implement the Magazine class.

50
COS1512/101/3/2019
(f) In a driver program embed code to do the following:
(i) Declare an object B of type Book, with the following details:
publisher: FisherKing
date: 01/01/2000
title: Global Warming
isbn : 123456789
author: Ann Miller
(ii) Output all the details of Book B.
(iii) Declare an object M of type Magazine, with the following details:
publisher: Blue Marlin

date: 02/02/2005
title: The Earth and the Environment
number of issues per year: 12
(iv) Output all the details of Magazine M.
(v) Write a statement to overload operator<< as a friend function to the class Book
and add the following implementation to your code:
ostream & operator<<(ostream & out, const Book & B)
{
out<<B.title<<endl;
out<<B.publisher<<endl;
out<<B.date<<endl;
out<<B.author<<endl;
out<<B.ISBN<<endl;
}
You should obtain the following compiler errors:

In function `std::ostream& operator<<(std::ostream&,
const Book&)':
error: `std::string Publication::title' is private
error: `std::string Publication::publisher' is private
error: `Date Publication::date' is private
Suggest two ways to fix this compiler problem.
Question 3
Write a function template for a function that has parameters for a partially filled array and for a
value of the base type of the array. If the value is in the partially filled array, then the function
returns the index of the first indexed variable that contains the value. If the value is not in the
51
array, the function returns -1. The base type of the array is a type parameter. Notice that you
need two parameters to give the partially filled array: one for the array and one for the number
of indexed variables used. Also write a suitable test program to test this function template.
Question 4
Write a template version of a search function for determining whether an array contains a
particular value.
Question 5
Study the Matrix class interface and answer the questions that follow:
(Refer to the Notes at end of the question if you are unfamiliar with Matrices)
template<class Object>
class Matrix
{
public:
Matrix( int row = 0, int col = 0 );
void SetValue(Object value, int r, int c);
Object GetValue( int r, int c) const;
int GetRow() const;
int GetCol() const;
void OutPut(ostream & out) const;
private:
vector< vector<Object> > array;
int rows;
int cols;
};
(a) Complete the implementation of the Matrix class where indicated:

template <class Object>
Matrix<Object>::Matrix (int row, int col)
{ rows = row;
cols = col;
array.resize(row);
for (int r = 0; r < row; r++)
array[r].resize(col);
//SetValue assigns row r and column c of the Matrix to value

void Matrix<Object>::SetValue(Object value, int r, int c)
{
//Complete code here
}
52
COS1512/101/3/2019
//GetValue returns the value in row r and col c of the Matrix

Object Matrix<Object>::GetValue( int r, int c) const
{
}
//GetRow returns rows

int Matrix<Object>::GetRow() const
{
}
//GetCol returns cols

int Matrix<Object>::GetCol() const
{
}
//Outputs the matrix in a tabular format (see Notes for example)

void Matrix<Object>::OutPut(ostream & out) const
{
}
//Operator+ is overloaded as a non-friend, non-member function. This

//function adds two Matrices (see Notes for example)
Matrix<Object> operator+(const Matrix<Object> & x, const
Matrix<Object> & y)
{
}
b) Test your implementation by coding a main function to perform the following:

(i) Declare three, 2 by 2 integer matrices, M1, M2, and M3;
(ii) Store the following values in M1:
1 2
3 4
(iii) Store the following values in M2:
5 6
7 8
(iv) Store the sum of M1 and M2 in M3 using operator+.
53
(v) Output all three matrices.
Notes:
In mathematics, a matrix (plural matrices) is a rectangular table of numbers or, more generally,
a table consisting of abstract quantities that can be added and multiplied. For example, a 4 by 3
matrix is represented as:
6 6 6
5 3 2
3 1 2
2 7 9
Two matrices can be added if, and only if, they have the same dimensions. (That is, both
matrices have matching numbers of rows and columns.) We define their sum by constructing a
third matrix whose entries are the sum of the corresponding entries of the original two matrices.
For example:
4 3 4 2 2 1 6 5 5
1 2 3 + 1 3 2 = 2 5 5
2 2 1 3 4 5 5 6 6
Question 6
Write a program that inputs two C string variables, first and last, each of which the user
should enter with his or her name. First, convert both C strings to lowercase. Your program
should then create a new C string that contains the full name in pig latin with the first letter
capitalized for the first and last name. The rules to convert a word into pig latin are as follows:
If the first letter is a consonant, move it to the end and add "ay" to the end.
If the first letter is a vowel, add "way to the end.
For example, if the user inputs "Erin" for the first name and "Jones" for the last name, then the
program should create a new string with the text "Erinway Onesjay" and print it.
Question 7
(a) Write a sorting function that is similar to Display 7.12 in Chapter 7 in Savitch, except that it
has an argument for a vector of ints rather than an array. This function will not need a
parameter like number_used as in Display 7.12, since a vector can determine the number
used with the member function size(). This sort function will have only this one
parameter, which will be of a vector type. Use the selection sort algorithm (which was
used in Display 7.12).
(b) Write a program that reads in a list of integers into a vector with base type int. Provide
the facility to either read this vector from the keyboard or from a file, at the user's option. If
the user chooses file input, the program should request a file name. The output is to be a
two-column list. The first column is a list of the distinct vector elements; the second
column is a count of the number of occurrences of each element. The list should be sorted
54
COS1512/101/3/2019
on entries in the first column, largest to smallest. Adapt the sorting function from (a) as
necessary.
For example, for the input
-12 3 -12 4 1 1 -12 1 -1 1 2 3 4 2 3 -12
The output should be

N Count
4 2
3 3
2 2
1 4
-1 1
-12 4
Question 8
Write a recursive function that returns the sum of the integers between any two integer numbers
inclusive. For example if we want to calculate the sum of integers between the integer numbers
13 and 17 then the sum will be 13 + 14 + 15 + 16 + 17 = 75. This recursive function will expect
two integer parameters and will return a double.
55
13 APPENDIX B: THE SOFTWARE FOR COS1512
1. Creating a project
Starting a new project
Launch the Project Wizard through File->New->Project. From the pre-configured templates for
various types of projects, select Console application and click Go.
The console application wizard will appear next. Continue through the menus,
selecting C++ when prompted for a language. In the next screen, give the project a name and
type or select a destination folder. As seen below, Code::Blocks will generate the remaining
entries from these two.
56
COS1512/101/3/2019
Finally, the wizard will ask if this project should use the default compiler (normally GCC) and the
two default builds: Debug and Release. All of these settings are fine. Press finish and the
project will be generated. The main window will turn gray, but that is not a problem, the source
file needs only to be opened. In the Projects tab of the Management panel on the left expand
the folders and double click on the source file main.cpp to open it in the editor.
This file contains the following standard code.

main.cpp
1. #include <iostream>
2.
3. usingnamespacestd;
4.
5. int main()
6. {
7. cout<<"Hello world!"<<endl;
8. return0;
9. }
57
Adding a file to your project
To add the new file to the project, bring up the file template wizard through either File->New-
>File... or Main Toolbar->New file (button)->File...
Select C/C++ source and click Go. Continue through the menus, same as what you have done
before. The last menu will present you with several options. Enter the new filename and location
(as noted, the full path is required). You can browse for the file by clicking the browse button
(see below) to display the file browser window to save the file's location. Checking Add file to
active project will store the filename in the Sources folder of the Projects tab of
the Management panel. Checking any of the build targets will alert Code::Blocks that the file
should be compiled and linked into the selected target(s). click Finish to generate the file.
Browse button
58
COS1512/101/3/2019
The newly created file should open automatically; if it does not, open it by double clicking on its
file in the Projects tab of the Management panel. You can now add code to the new file. Be
careful not to save your files with .c extension (this is not a C++ extension).
Adding a pre-existing file
Copy an existing file to your project folder or launch a plain text editor (for example Notepad),
and add the following code.
Interface.h
1. #ifndef INTERFACE_H_INCLUDED
2. #define INTERFACE_H_INCLUDED
3.
4. void hello();
5.
6. #endif // INTERFACE_H_INCLUDED
Save this file as a header (Interface.h) in the same directory as the other source files in this
project. Back in Code::Blocks, click Project->Add files... to open a file browser. Here you may
select one or multiple files (using combinations of Ctrl and Shift). (The option Project->Add files
recursively... will search through all the subdirectories in the given folder, selecting the relevant
files for inclusion.) Select Interface.h, and click Open to bring up a dialog requesting to which
build targets the file(s) should belong. For this example, select both targets.
59
Note: if the current project has only one build target, this dialog will be skipped.
Returning to the main source (main.cpp) include the header file and replace the cout function
to match the new setup of the project.
main.cpp
1. #include "Interface.h"
2.
3. int main()
4. {
5. hello();
6. return0;
7. }
Press Ctrl-F9 or File->Build, orCompiler Toolbar->Build (button - the gear) to compile the
project. If the following output is generated in the build log (in the bottom panel) then all steps
were followed correctly.
-------------- Build: Debug in MyFirst Project ---------------
Compiling: main.cpp
Linking console executable: bin\Debug\MyFirst Project.exe
Output size is 913.10 KB
Process terminated with status 0 (0 minutes, 1 seconds)
0 errors, 0 warnings
You can now “run” the project by either clicking the Run button or hitting Ctrl-F10.
Note: the option F9 (for build and run) combines these commands, and may be more useful in
some situations.
Removing a file
You can remove a file by simply right-clicking on the file name in the Projects tab of the
Management panel and selecting Remove file from project.
60
COS1512/101/3/2019
Note: removing a file from a project does not physically delete it.
2. Printing
To print a C++ program, choose the "Print" option on the "File" menu of Code::Blocks. (If you
are submitting an assignment via myUnisa, you don't need to print. Simply paste the code of
your program into a word processor file.)
Printing the output of a program is somewhat trickier. There are (at least) two ways to print the
output of a text-based program (a console application):
Method 1
To print the text from the I/O window after running your program, you can copy the text to a
word processor (an editor). The steps involved are as follows:
 Position the mouse over the console window (the output window). Right-click, and
choose Mark from the drop-down menu.
 Hold the Shift key down and use the arrow keys to mark (highlight) the text as a block.
 Press the Enter key to copy the highlighted text to the clipboard.
 You can now paste it in a word processor (editor) of your choice and print it.
Method 2
Sometimes the above method can be somewhat laborious and problematic, especially if there is
so much output that it scrolls off the top of the screen. In this case, you can send the output
directly to the printer (while the program is running) like this:
 Run your program, and when it has finished executing (and you are happy with the
output) close the console window.
 Open a separate DOS window (or Command window) and change the directory to where
your program is. (You'll need to type something like cd \unisa\cos1512.)
61
 Test whether your program is actually in the current directory by typing its name at the
DOS prompt, eg. first.exe followed by <Enter>. If you get the message "Bad command
or filename" you are either in the wrong directory or the name of the executable file is
incorrect. You must be able to run the program from the DOS prompt before proceeding.
 Make sure that your printer is switched on, is "On-line" and has paper in it, etc.
 Press <Ctrl+P> to ensure that all the output generated from now on is sent to the printer.
 Type the name of the executable file, eg. first.exe and press <Enter> to run your
program again.
 Enter any values that the program requires as input.
 When the program terminates, press <Ctrl+P> again to turn off the printing mode. All the
output (and input) of the program should have been sent to the printer.
 Now you can close the console window.

Unfortunately, this method won't help if you intend submitting your assignment via
myUnisa. You'll have to use Method 1.
14 APPENDIX C: SOURCE LISTINGS OF THE SAMPLE PROGRAMS IN

THE TEXTBOOK
The source code listings of the sample programs in the 8th, 9th and 10th edition of the text book
can be found at the Companion Website for the text book. Go to
www.pearsonglobaleditions.com/savitch, select the text book and then click on Companion
Website. Click on the Register button, and type in the student access code found beneath the
pull tab of the ONLINE ACCESS card in front of the text book.
The source code listings of the sample programs in the 7th edition of the text book can be found
at http://www.aw.com/cssupport. Click on S under “Author Search”, and then on “Savitch” in the
resulting list of authors. Follow the link provided for the text book. Now double-click on
“PSCPP6e-SourceCode.zip” and click on Open. A list of folders, one for each chapter, will be
displayed. Each folder contains the source listings for Displays in the chapter. Display 9.06 for
example will be listed as “09-06.cpp”. If you double-click on the file, the source listing will open
up in Code::Blocks.
15 APPENDIX D: GLOSSARY
The following link provides a glossary for English/Afrikaans IT terminology:
http://www.coetzee.org/woordelys/
62
COS1512/101/3/2019
16 APPENDIX E: Solution to assignment 3

Question 1
For this question you had to answer questions based on the following code fragment:
1: #include <iostream>
2: using namespace std;
3:
4: //------------------------------------------
5:
6: class A
7: {
8: private:
9: int x;
10: protected:
11: int getX();
12: public:
13: void setX();
14: };
15:
16: int A::getX()
17: {
18: return x;
19: }
20:
21: void A::setX()
22: {
23: x=10;
24: }
25:
26: //----------------------------------------------
27: class B
28: {
29: private:
30: int y;
31: protected:
32: A objA;
33: int getY();
34: public:
35: void setY();
37: };
38:
39: void B::setY()
40: {
41: y=24;
42: int a=objA.getX();
43: }
44:
45: //----------------------------------------------
46:
47: class C: public A
48: {
49: protected:
63
50: int z;
51: public:
52: int getZ();
53: void setZ();
54: };
55:
56: int C::getZ()
57: {
58: return z;
59: }
60:
61: void C::setZ()
62: {
63: z=65;
64: }
Answer the following questions based on the code fragment given above:
(a) Is line 18 a valid access? Justify your answer?
Yes.
The variable x is a private data member of the class A and therefore it can only be
accessed by other member functions and operators of the class A. getX() is a member
function of class A and therefore line 18 is a valid access.
(b) Is line 32 a valid statement? Justify your answer.

Yes.
An object of class A has been included as a protected data member of class B.
(c) Identify another invalid access statement in the code.
Line 42 (int a=objA.getX();) is invalid.
getx() is a protected member function of class A and can therefore only be

accessed by other member functions and operators of the class A and by classes
derived from class A.
(d) Class C has public inheritance with the class A. Identify and list class C’s private,
protected and public data members resulting from the inheritance.
With public inheritance, the public and protected members of the base class A are
inherited as public and protected members of the derived class C.
Private data members or member functions resulting from the inheritance: None
Protected data members or member functions resulting from the inheritance: getX()
Public data members or member functions resulting from the inheritance: setX()
(a) If class C had protected inheritance with the class A, identify and list class C’s
private, protected and public data members resulting from the inheritance.
64
COS1512/101/3/2019
With protected inheritance, public and protected members of the base class
become protected members of the derived class.
Private data members or member functions resulting from the inheritance: None
Protected data members or member functions resulting from the inheritance: setX()
and getX()
Public data members or member functions resulting from the inheritance: None
Discussion:
When deriving a class from a public base class, public members of the base class become
public members of the derived class and protected members of the base class become
protected members of the derived class. A base class’ private members are never directly
accessible from a derived class, but can be accessed through calls to the public and
protected members of the base class.
When deriving from a protected base class, public and protected members of the base
class become protected members of the derived class. When deriving from a private base
class, public and protected members of the base class become private members of the
derived class. Private and protected inheritance are not “is-a” relationships [Reference:
Study Guide (Tutorial Letter 102 available under Additional Resources on the COS1512 website
on myUnisa ), chapter 15].
Question 2
For this question you had to answer questions based on the following code fragment:
class Date
{
public:
private:
};
class Publication
{
public:
const string & t);
private:
string publisher;
Date date;
string title;
65
};
(a) Implement the Date and the Publication classes.
File Name: Date.cpp

#include <iostream>
#include "Date.h"
Date::Date(int y, int m, int d): year(y), month(m), day(d){}

ostream & operator<<(ostream & out, const Date & d)
{
out<<d.day<<"/"<<d.month<<"/"<<d.year<<endl;
}
File Name: Publication.cpp

#include <iostream>
#include <string>
#include "Date.h"
#include "Publication.h"
Publication::Publication( const string & p, const Date & d,

const string & t): publisher(p),date(d),title(t)
{ }
Date Publication::GetDate() const

{
return date;
}
string Publication::GetPublisher()const
{
return publisher;
}
string Publication::GetTitle() const

{
return title;
}
(b) Code the interface of a derived class Book for which the Publication class is the base
class. The Book class has two additional data members representing the ISBN number
and the author of a book. Furthermore, the Book class contains member functions
getISBN( ) and getAuthor( ) that returns the ISBN number and the author
respectively. The declaration must also include a constructor for the class Book.
#ifndef BOOK_H
#define BOOK_H
66
COS1512/101/3/2019
#include "Date.h"
#include <string>
class Book: public Publication

{
public:
Book(const string & p, const Date & d, const string & t,
const string & auth, const string & isbn);
string getAuthor()const;
string getISBN()const;
private:
string ISBN;
string author;
};
#endif
(c) Implement the Book class.

#include "Book.h"
#include <string>
Book::Book(const string & p, const Date & d, const string & t,
const string & auth, const string & isbn):
Publication(p,d,t),
ISBN(isbn), author(auth){}
string Book::getAuthor()const
{
return author;
}
string Book::getISBN() const

{
return ISBN;
}
Note, the constructors of the Book class call the Publication constructor (shown in bold) in
their initializer lists. Constructing a derived class object by first constructing its inherited portion
is a standard practice. (For a complete discussion on this subject - refer to pages 851 -853 (8th
ed) of Savitch / pages 865-868 (7th ed) of Savitch, under the section entitled "Constructors in
Derived Classes").
(d) Recode the following interface such that class Magazine, derives from class
Publication:
#ifndef MAGAZINE_H
#define MAGAZINE_H
67
class Magazine: public Publication
{
public:
Magazine(const string & p, const Date & d, const string & t,
int ipy);
private:
int issuesPerYear;
};
#endif
Note how the class requires less code due to inheritance.
(e) Implement the Magazine class.

#include "Magazine.h"
Magazine::Magazine(const string & p, const Date & d,
const string & t, int ipy):Publication(p,d,t), issuesPerYear(ipy)
{}
int Magazine::GetIssuesPerYear()const
{
return issuesPerYear;
}
(f) For this question you had to design a driver program to test your classes:
#include <iostream>
#include "Date.h"
#include "Book.h"

int main()
{
Date date1(2000,1,1);
Date date2(2005,2,2);
Book B("FisherKing", date1, "Global Warming", "123456789",

"Ann Miller");
cout<<B.GetTitle()<<endl;
cout<<B.GetPublisher()<<endl;
cout<<B.GetDate()<<endl;
cout<<B.getAuthor()<<endl;
cout<<B.getISBN()<<endl;
Magazine M("Blue Marlin", date2,
"TheEarth and the Environment",12);
cout<<M.GetTitle()<<endl;
cout<<M.GetPublisher()<<endl;
cout<<M.GetDate()<<endl;
cout<<M.GetIssuesPerYear()<<endl;
return 0;
68
COS1512/101/3/2019
(g) Write a statement to overload operator<< as a friend function to the class Book and
insert the following implementation to your code:
{
out<<B.title<<endl;
out<<B.publisher<<endl;
out<<B.date<<endl;
out<<B.author<<endl;
out<<B.ISBN<<endl;
}
You should obtain the following compiler errors:

In function `std::ostream& operator<<(std::ostream&,
const Book&)':
error: `std::string Publication::title' is private
error: `std::string Publication::publisher' is private
error: `Date Publication::date' is private
Suggest two ways to fix this compiler problem.

Method 1: Use the accessor functions as shown below:
{
out<<B.GetTitle()<<endl;
out<<B.GetPublisher()<<endl;
out<<B.GetDate()<<endl;
out<<B.getAuthor()<<endl;
out<<B.getISBN()<<endl;
}
Method 2: Change the member variables of Publication into protected access. As

they are now protected and not private they become accessible to the derived class
Book. The protected members of Publication become protected members of Book.
They now can be directly accessed by member functions and friend functions of Book.
class Publication
{
public:
const string & t);
protected:
string publisher;
Date date;
string title;
69
};
70
COS1512/101/3/2019
Full Programming Listing:

File name: Date.h
#ifndef DATE_H
#define DATE_H
#include <iostream>

class Date
{
public:
private:
};
#endif
File name: Date.cpp

#include <iostream>
#include "Date.h"
Date::Date(int y, int m, int d): year(y), month(m), day(d){}

ostream & operator<<(ostream & out, const Date & d)
{
out<<d.day<<"/"<<d.month<<"/"<<d.year<<endl;
}
File name: Publication.h

#ifndef PUBLICATION_H
#define PUBLICATION_H
#include <string>
#include "Date.h"

class Publication
{
public:
Publication(const string & p, const Date & d, const string & t);
private:
string publisher;
Date date;
string title;
};
71
#endif
File name:Publication.cpp
#include <iostream>
#include <string>
#include "Date.h"
string Publication::GetTitle() const

{
return title;
}
Publication::Publication( const string & p, const Date & d, const
string & t): publisher(p),date(d),title(t){}
Date Publication::GetDate() const

{
return date;
}
string Publication::GetPublisher()const
{
return publisher;
}
Filename: Book.h
#ifndef BOOK_H
#define BOOK_H
#include "Date.h"
#include <string>
class Book: public Publication

{
public:
friend ostream & operator << (ostream & out, const Book & B);
Book(const string & p, const Date & d, const string & t,
const string & auth,const string & isbn);
string getAuthor()const;
string getISBN()const;
private:
string ISBN;
string author;
};
#endif
72
COS1512/101/3/2019
Filename: Book.cpp
#include "Book.h"
#include <string>
Book::Book(const string & p, const Date & d, const string & t,

const string & auth, const string & isbn):
Publication(p,d,t),
ISBN(isbn), author(auth){}
string Book::getAuthor()const
{
return author;
}
string Book::getISBN() const

{
return ISBN;
}
{
out<<B.GetTitle()<<endl;
out<<B.GetPublisher()<<endl;
out<<B.GetDate()<<endl;
out<<B.getAuthor()<<endl;
out<<B.getISBN()<<endl;
}
Filename: Magazine.h
#ifndef MAGAZINE_H
#define MAGAZINE_H
class Magazine:public Publication
{
public:
Magazine(const string & p, const Date & d, const string & t,
int ipy);
private:
int issuesPerYear;
};
#endif
Filename: Magazine.cpp
Magazine::Magazine(const string & p, const Date & d, const string & t,

int ipy):Publication(p,d,t), issuesPerYear(ipy)
{}
73
int Magazine::GetIssuesPerYear()const
{
return issuesPerYear;
}
Filename: Test.cpp
#include <iostream>
#include "Date.h"
#include "Book.h"

int main()
{
Date date1(2000,1,1);
Date date2(2005,2,2);
Book B("FisherKing", date1, "Global Warming", "123456789",

"Ann Miller");
cout<<B.GetTitle()<<endl;
cout<<B.GetPublisher()<<endl;
cout<<B.GetDate()<<endl;
cout<<B.getAuthor()<<endl;
cout<<B.getISBN()<<endl;
Magazine M("Blue Marlin", date2,
"TheEarth and the Environment",12);
cout<<M.GetTitle()<<endl;
cout<<M.GetPublisher()<<endl;
cout<<M.GetDate()<<endl;
cout<<M.GetIssuesPerYear()<<endl;
return 0;
}
Question 3
Discussion:
For this question, you had to define a function template that searches an array for a specific
value and returns the index of the first occurrence of that value. The template should have
parameters for a partially filled array and for a value of the base type of the array. If the value is
in the partially filled array, then the function returns the index of the first occurrence of that
value, otherwise the function returns -1. The base type of the array is a type parameter.
Function templates are special functions that can operate with generic types. This allows us to
create a function template whose functionality can be adapted to more than one variable type or
class without repeating the code for each type. For instance, with this program we used the
same search() function for an array of doubles (Doubles), an array of characters
(Characters) and an array of integers (Integers). Without templates we would have had to
write a separate search() function for each type of array. (Section 17.1 of Savitch has
detailed explanations on the declarations of function templates.)
74
COS1512/101/3/2019
A template parameter is a special kind of parameter that can be used to pass a type as a
parameter. The function templates can use these parameters as if they were regular types.
The declaration for the search() function combined template parameters with a defined
parameter type:
template<class T>
int search(T array[], int n, T target)
Be cautious when using template parameters - you cannot apply it without considering all the
implications.
For example:
template<class T>
int search( T array[], T n, T target)
 This does not make sense as we want to run a loop n number of times to search the
array for our target element - n must certainly be of type integer. Hence it does not make sense
within this context to declare n as a template parameter.
Program Listing:
#include <iostream>
//Precondition: the array base type must have operator== defined,

//&& n <= declared size of the array argument.
//Postcondition: Function returns index of the first
//occurrence of target in array. If target is not in the
//array, the function returns -1
template<class T>
int search( T array[], int n, T target)
{
for ( int i = 0; i < n; i++ )
{
if (array[i] == target)
return i;
}
return -1;
}
int main(){
char Characters[14] = { 'M', 'A', 'P', 'C','E' };
int Integers[14] = { 1, 4, 3, 5, 3, 6, 8, 9, 10, 7};
double Doubles[14] = {2.99,8.77,4.88,6.44,3.45};
cout << " C found at index "

<< search( Characters,5,'C')
<< " in array of characters"
<< endl;
75
cout << " c found at index "
<< search( Characters,5,'c')
<< " in array of characters"
<< endl;
cout << " 5 found at index "
<< search( Integers, 10, 5)
<< " in array of integers"
<< endl;
cout << " 3.45 found at index "
<< search( Doubles, 10, 3.45)
<< " in array of doubles"
<< endl;
}
Output:
C found at index 3 in array of characters
c found at index -1 in array of characters
5 found at index 3 in array of integers
3.45 found at index 4 in array of doubles
Press any key to continue . . .
Question 4
Discussion:
For this question, you had to specify a template version of a search function to determine
whether an array contains a particular value. Here only two of the parameters had to be
template type parameters, namely the array type and the target (i.e. the element being
searched). As discussed, with the previous question, it does not make sense to alter the other
parameters into template type parameters. We also included a templatized Output() function
to output an array of any type and to call the search() algorithm to further promote reuse.
Program Listing:
#include <iostream>
#include <string>
//Precondition: the array base type must have operator== defined,

//Postcondition: Function returns true at the first
//occurrence of target in array. If target is not in the
//array, the function returns false
template<class T>
bool search( T array[], int n, T target)
{
for ( int i = 0; i < n; i++ )
{
if (array[i] == target)
return true;
}
return false;
76
COS1512/101/3/2019
}
//Precondition: the array base type must have operator<< defined,
template <class T>

void Output(T array[], int n, T target, string s)
{
if (search(array,n,target))
cout << s << "does contain " << target <<endl;
else
cout << s << "does not contain " << target <<endl;
}
int main()
{
char Characters[14] = { 'M', 'A', 'P', 'C','E' };
int Integers[14] = { 1, 4, 3, 5, 3, 6, 8, 9, 10, 7};
double Doubles[14] = {2.99,8.77,4.88,6.44,3.45};
Output( Characters,5,'C', "Array Characters ");

Output( Characters,5,'c', "Array Characters ");
Output( Integers, 10, 5 , "Array Integers ");
Output( Integers, 10, 15 , "Array Integers ");
Output( Doubles, 10, 3.45, "Array Doubles ");
Output( Doubles, 10, 3.455, "Array Doubles ");
}
Output:
Array Characters does contain C
Array Characters does not contain c
Array Integers does contain 5
Array Integers does not contain 15
Array Doubles does contain 3.45
Array Doubles does not contain 3.455
Question 5
For this question, you had to implement the operations of a Matrix class template.
(a) The code to be inserted shown in bold.

Discussion:
Until now, we have placed the definition of the class (in the header file) and the definition of the
member functions (in the implementation file) in separate files. However this does not work with
class templates. As shown below both the interface and implementation are within the header
file Matrix.h
File name: Matrix.h

#ifndef MATRIX_H
77
#define MATRIX_H
#include <iostream>
#include <vector>
#include <cassert>
class Matrix
{
public:
Matrix( int r = 0, int c = 0 );
void SetValue(Object value, int row, int col);
Object GetValue( int row, int col) const;
int GetRow() const;
int GetCol() const;
void OutPut(ostream & out) const;
private:
vector< vector<Object> > array;
int rows;
int cols;
};

Matrix<Object>::Matrix (int row, int col)
{
rows = row;
cols = col;
array.resize(row);
for (int r = 0; r < row; r++)
array[r].resize(col);

void Matrix<Object>::SetValue(Object value, int row, int col)
{
array[row][col] = value;
}

Object Matrix<Object>::GetValue(int row, int col) const
{
return array[row][col];
}
int Matrix<Object>::GetRow() const
{
return rows;
}
int Matrix<Object>::GetCol() const
{
return cols;
78
COS1512/101/3/2019

void Matrix<Object>::OutPut(ostream & out) const
{
for (int r = 0; r < rows; r++)
{
for(int c = 0; c < cols; c++)
{
out<<array[r][c]<<'\t';
}
cout<<endl;
}
}
Matrix<Object> operator+(const Matrix<Object> & x,
const Matrix<Object> & y)
{
int xrow = x.GetRow();
int xcol = y.GetCol();
assert( xrow == y.GetRow() && xcol == y.GetCol());
Matrix<Object> temp(xrow,xcol);
for (int r = 0; r < xrow; r++)
{
for(int c = 0; c < xcol; c++)
{
Object sum = x.GetValue(r,c) + y.GetValue(r,c);
temp.SetValue(sum, r, c);
}
}
return temp;
}
#endif
(b) For this question you had to write a test program for your Matrix class:
#include <iostream>
#include "Matrix.h"
int main()
{
Matrix<int> M1(2,2);
M1.SetValue(1,0,0);
M1.SetValue(2,0,1);
M1.SetValue(3,1,0);
M1.SetValue(4,1,1);
M2.SetValue(5,0,0);
79
M2.SetValue(6,0,1);
M2.SetValue(7,1,0);
M2.SetValue(8,1,1);
M3 = M1 + M2;
M1.OutPut(cout); cout<<endl;
M2.OutPut(cout);cout<<endl;
M3.OutPut(cout);cout<<endl;
return 0;
}
Output Produced:
1 2
3 4
5 6
7 8
6 8
10 12
Note:
As shown above - we also have the possibility to write class templates, so that a class can have
members that use template parameters as types. C++ class templates are used where we have
multiple copies of code for different data types with the same logic. If a set of functions or
classes have the same functionality for different data types, they become good candidates for
being written as templates. C++ class templates are ideal for container classes (a class of
objects that is intended to contain other objects). Examples of container classes will be the STL
classes like vector (chapter 8, Savitch), and list. Once the code is written as a C++ class
template, it can support all data types. (See section 17.2, Savitch for full explanations on Class
Templates.) For instance the Matrix template above can accommodate a Matrix of any
type, be it strings, doubles, ints, etc.
Savitch limits his discussion to popular member functions of the STL vector class, such as
push_back, size, capacity, reserve and resize. However there are other member
functions such as:
empty which returns true if the vector is empty and false otherwise
pop_back which removes the last element of a vector
back which returns the last element of the vector.
80
COS1512/101/3/2019
Question 6
Discussion:
In this program we use C-strings to read in the user's first and last name. Both C-strings are
then converted to lowercase before the full name is converted to pig latin.
C-strings use the '\0' character to indicate the end of a C-string. The C-string variables used to
store the first and last names for example are therefore declared as
char first[21], last[21];
to allow 20 characters each for the first and last names as well as one position for the '\0'.
The program uses two functions, convertToLowerCase() to convert a string to lowercase,

and pigLatin() to convert a string to pig latin.
In function convertToLowerCase() we use the null character '\0' as sentinel in the while
loop that converts each character to its lower case.
Program listing:
#include <iostream>
#include <cstring>
// void convertToLowerCase(char name[])

// Pre: name[] contains a C-string
// Post: name[] has been converted to lower case
void convertToLowerCase(char name[])
//void pigLatin(char name[])

// Pre: name[] contains a C-string
// Post: name[] has been converted to pig latin
void pigLatin(char name[])
int main()
{
char first[21], last[21], newName[41], copyFirst[21],copyLast[21];
cout << "Please enter your first name: ";
cin >> first;
cout << "Please enter your last name: ";
cin >> last;
//make a copy of the first and last name for output purposes
strcpy(copyFirst, first);
strcpy(copyLast, last);
//convert first and last name to lowercase
convertToLowerCase(first);
convertToLowerCase(last);
//convert first and last name to pig latin
pigLatin(first);
pigLatin(last);
//create new string with first and last name in pig latin
strcpy(newName, first);
strcat(newName, " "); //add space between first and last name
81
strcat(newName, last);
cout << "Dear " << copyFirst << " " << copyLast
<< " in pig latin your name is " << newName << endl;
return 0;
}
void convertToLowerCase(char name[])

{
int i = 0;
while (name[i] != '\0')
{
name[i] = tolower(name[i]);
i++;
}
}
void pigLatin(char name[])

{
char ch;
if ((name[0] == 'a') || (name[0] == 'e') || (name[0] == 'i')
|| (name[0] == '0') || (name[0] == 'u'))
{
name[0] = toupper(name[0]);
strcat(name, "way");
}
else
{
ch = name[0];
for (int i = 0; i <= strlen(name); i++)
name[i] = name[i+1];
name[strlen(name)] = ch;
strcat(name, "ay");
name[0] = toupper(name[0]);
}
}
Input and corresponding output:

Please enter your first name: Erin
Please enter your last name: Jones
Dear Erin Jones in pig latin your name is Erinway Onesjay
Question 7
7. (a) Discussion:
We adapted the sorting function to sort a vector from largest to smallest as follows:
The argument was changed from an array of ints to a vector of ints, as can be seen in
the function headings:
void sort(vector<int>& v) and
82
COS1512/101/3/2019
int index_of_largest(const vector<int> v, int start_index)
Note that in order to return the sorted vector, it should be a reference parameter. Also note that
since the size of a vector can be determined with the member function size(), the parameter
number_used can be omitted from both functions.
We want to sort in descending order while the sorting function in Display 7.12 sorts in ascending
order. Accordingly, both function and local variable names that refer to either 'smallest' or
'min' have been changed to 'largest' or 'max'. See for example function
index_of_largest below:
{
int max = v[start_index],
index_of_max = start_index;
for (int index = start_index + 1; index < v.size(); index++)
if (v[index] > max)
{
max = v[index];
index_of_max = index;
//max is the largest of v[start_index] through v[index]
}
return index_of_max;
}
While these name changes aid in understanding the sorting order of the sorting function, it does
not change the order in which the vector is sorted from ascending to descending. The crucial
change to ensure that the sorting is done in descending order instead of ascending order, lies in
changing the comparison
if (a[index] < min)
in function index_of_largest to
if (v[index] > max)
This change is highlighted in the code section above. The comments have also been adapted
to reflect the changed sorting order.
7. (b) Discussion:
In this question you should have provided a facility to allow the user to specify whether input
should be read from a file, or from the keyboard. Note that when input is read from the
keyboard, we indicate the end of file character with CTRL Z, followed by pressing 'enter':
{ //read input from the console
cout << "Please enter list of values. Press 'enter' "
<< "after each value. Use CTRL Z to end." << endl;
read_vector(list,cin);
}
In function read_vector() inheritance is used so that input can be done both from a file or
from the keyboard. The formal parameter corresponding either to cin (console input) or fin (file
input) therefore has to be of type istream:
83
void read_vector(vector<int>& v, istream& in_stream);
See Section 10.4 in Savitch for more detail.
The distinct elements in the vector are extracted by using a boolean function found() to
determine whether or not a specific element in the original vector (list) occurs in the vector of
distinct elements (distinct). Should a specific element not occur in the vector of distinct
elements, it is added to distinct.
//extract distinct elements in list into vector distinct
vector<int> distinct;
for (unsigned int i = 0; i < list.size(); i++)
{
if (!found(list[i], distinct))
distinct.push_back(list[i]);
}
The vector of distinct elements is then sorted, and a third vector (occurrences) with the same
number of elements as distinct is declared and initialised to 0.
//sort vector distinct
sort(distinct);
//declare a vector with distinct.size()elements and initialise

//each to 0
vector<int> occurrences (distinct.size());
A function count() is used to count the number of times each distinct element (stored in vector
distinct), occurs in the original list of elements (vector list).
//count occurrences for each element in vector distinct
for (unsigned int i = 0; i < distinct.size(); i++)
occurrences[i] = count(distinct[i], list);
Finally, the corresponding elements in vectors distinct and occurrences are output next to
each other to show the number of times each distinct element occurs in the original list. We
show output for input from the keyboard as well as for input from a file.
Program listing:
#include <iostream>
#include <fstream>
#include <string>
#include <vector>
#include <cstdlib>
#include <cstring>
void read_vector(vector<int>& v, istream& in_stream);

//to read input values from a stream (file or console) into vector v
bool found(int x, vector<int> v);
//to determine if x occurs in vector v
int count(int x, vector<int> v);

//to count the number of times x occurs in vector v
84
COS1512/101/3/2019
void sort(vector<int>& v);

//Precondition: number_used <= declared size of the vector v.
//The vector elements v[0] through v[v.size - 1] have values.
//Postcondition: The values of v[0] through v[v.size() - 1] have
//been rearranged so that v[0] >= v[1] >= ... >= v[v.size() - 1].
void swap_values(int& v1, int& v2);

//Interchanges the values of v1 and v2.
int index_of_largest(const vector<int> v, int start_index);

//Precondition: 0 <= start_index < v.size().
// Referenced vector elements have values.
//Returns the index i such that v[i] is the largest of the values
//v[start_index], v[start_index + 1], ..., v[v.size() - 1].
int main()
{
vector<int> list;
fstream fin;
char answer;
string filename;
int next;
cout << "Do you want to provide input via console or "
<< "using a file(c/f)?";
cin >> answer;
cout << endl;
if (answer == 'f') //read input from a file
{
cout << "Please enter filename: " << endl;
cin >> filename;
fin.open(filename.c_str());
if (fin.fail())
{
cout << "Input file opening failed. \n";
exit(1);
}
read_vector(list,fin);
fin.close();
}
else //read input from the console
{
cout << "Please enter list of values. Press 'enter' "
<< "after each value. Use CTRL Z to end." << endl;
read_vector(list,cin);
}
//extract distinct elements in list into vector distinct

vector<int> distinct;
for (unsigned int i = 0; i < list.size(); i++)
{
if (!found(list[i], distinct))
distinct.push_back(list[i]);
85
}
//sort vector distinct
sort(distinct);
//declare a vector with distinct.size()elements and initialise

//each to 0
vector<int> occurrences (distinct.size());
//count occurrences for each element in vector distinct

occurrences[i] = count(distinct[i], list);
//output
cout << endl << 'N' << '\t' << "Count" << endl;
cout << distinct[i] << '\t' << occurrences[i] << endl;
return 0;
}
void read_vector(vector<int>& v, istream& in_stream)

{
int next;
while (in_stream >> next)
{
v.push_back(next);
}
}
bool found(int x, vector<int> v)

{
for (unsigned int i = 0; i < v.size(); i++)
{
if (x == v[i])
return true;
}
return false;
}
int count(int x, vector<int> v)

{
int counter = 0;
for (unsigned int i = 0; i < v.size(); i++)
{
if (x == v[i])
counter += 1;
}
return counter;
}
void sort(vector<int>& v)
{
int index_of_next_largest;
86
COS1512/101/3/2019
for (unsigned int index = 0; index < v.size() - 1; index++)

{//Place the correct value in v[index]:
index_of_next_largest =
index_of_largest(v, index);
swap_values(v[index], v[index_of_next_largest]);
//v[0] >= v[1] >=...>= v[index] are the largest of the original
//vector elements. The rest of the elements are in the remaining
//positions.
}
}
void swap_values(int& v1, int& v2)

{
int temp;
temp = v1;
v1 = v2;
v2 = temp;
}

{
int max = v[start_index],
index_of_max = start_index;
for (int index = start_index + 1; index < v.size(); index++)
if (v[index] > max)
{
max = v[index];
index_of_max = index;
//max is the largest of v[start_index] through v[index]
}
return index_of_max;
}
Output using console input:

Do you want to provide input via console or using a file(c/f)?c
Please enter list of values. Press 'enter' after each value. Use CTRL
Z to end.
-12
3
-12
4
1
1
-12
1
-1
1
2
3
4
87
2
3
-12
^Z
N Count
4 2
3 3
2 2
1 4
-1 1
-12 4
Output using file input:

Do you want to provide input via console or using a file(c/f)?f
Please enter filename:

Q6.dat
N Count
4 2
3 3
2 2
1 4
-1 1
-12 4
Question 8
For this question you had to write a recursive function that returns the sum of the integers
between any two integer numbers inclusive. This recursive function expects two integer
parameters and returns a double.
Program Listing:
#include <iostream>
double sum (int m, int n)

{
if (m == n)
return m;
else
return (m + sum ( m + 1, n ) );
}
int main()
{
cout << "The sum between 13 and 17 is:";
cout << sum (13,17) <<endl;;
cout<< sum(13,13) <<endl;
88
COS1512/101/3/2019

cout<< sum(13,14) <<endl;
return 0;
}
Output:
The sum between 13 and 17 is:75
Discussion:
To solve this question, we need to determine the base case and the general case. The base
case is when the solution can be obtained directly.
The base case:
If m is equal to n then we can immediately determine the sum to be m. For example the sum
between 13 and 13 would be 13.
The general case on the other hand, is a little harder to deduce:
Consider the following example:
sum(13,17) = 13 + 14 + 15 + 16 + 17
A more general formula can be written as:

sum(m,n) = m+(m+1)+(m+2)+...+(n-2)+(n-1)+n
Recursively:
sum(m,n) = m + sum(m+1,n)
89
The diagram below represents the recursive calls that will take place if 13 and 17 were passed
as parameters to the sum() function. That is, we want to determine the sum between 13 and
17. The diagram shows that each sum(m,n) induces calls to sum(m+1,n). For instance,
sum(13,17) sum(13,17) = 75
since m!=n
return 13 + 62 = 75
step a return 13 + sum (14,17);
sum(14,17) = 62
sum(14,17)
since m!=n
return 14 + 48 = 62
step b return 14 + sum (15,17);
sum(15,17) = 48
sum(15,17)
since m != n
return 15 + 33 = 48
step c return 15 + sum(16,17)
sum(16,17) = 33
sum(16,17)
since m != n return16 +17 = 33

step d
return 16 + sum(17,17)
sum(17,17) = 17
sum(17,17)
since m = n return 17
step e
return 17
since sum(13,17) = 13 + sum(14,17) - this induces calls to sum(15,17), sum(16,17)

and finally sum(17,17). With regard to the diagram below, recursion works first along the
downward arrows until a given point is reached at which an answer is defined (the base case),
and then works along the dashed upward arrows, returning values back to the calling function.
For function sum(), the base case is when m == n.
So eventually the recursive calls will stop at sum(17,17) - because an answer of 17 can be
returned.
Hence sum(16,17) is:
sum(16,17) = 16 + 17 = 33 hence sum(16,17) returns 33
So sum(15,17) is:
sum(15,17) = 15 + sum(16,17) = 15 + 33 = 48 hence sum(15,17) returns 48
So sum(14,17) is:
sum(14,17) = 14 + Sum(15,17) = 14 + 48 = 62 hence sum(14,17) returns 62
Therefore sum(13,17) is:
sum(13,17) = 13 + sum(14,17) = 13 + 62 = 75 hence sum(13,17) returns 75
90
COS1512/101/3/2019
More on Recursion:
Understanding recursion is difficult. Let us consider an everyday example. Suppose you were
given a huge bag of coins and you had to determine how much money was in the bag.
As the bag is large, you prefer not to do the work by yourself. However, you have
many willing friends. You divide the bag of coins into two heaps of coins and ask
your friend "Could you please add up this one heap of coins? I've only given you
half, so there's half the work to do”. You, then give the other half to another
friend, and say the same thing. Once both are done, they will give their answer to
you, and you add their results.
Thus, you have broken down the problem into two smaller parts, and asked your friends to do
the work.
Now those friends are smart too, so they divide their heap of coins into two parts (now each has
two heaps of ¼ of the size) and each asks two of their friends to help. When their friends are
done, they return their answer, and the result is summed. Now assume that each of their friends
does the same and enlists more friends to help and this process goes on and on. Eventually,
there is a heap of only two coins, and these are divided once again and given to two more
friends, and those friends, seeing how silly the problem is now, just tell the first friend the only
value on the coin. There's no need to ask any more friends, because you're down to one coin
(this is the base case).
Thus, recursion is all about breaking a problem down, and solving that, and that smaller
problem is solved by breaking it down some more, and trying to solve that. Eventually, you
reach an easy solution (the base case), and return the solution.
©
Unisa 2019
91

COS1512 Tut Letter 101

Uploaded by

Copyright:

Available Formats

COS1512 Tut Letter 101

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

COS1512 Tut Letter 101

Uploaded by

Copyright:

Available Formats

COS1512/101/3/2019

Tutorial Letter 101/3/2019

8.2.2 Due dates for assignments ........................................................................................................... 19

1.1.1 About myUnisa

1.2 Tutorial Matter

 this tutorial letter, COS1512/101/3/2019;

 tutorial letter COSALLF/301/4/2019;

 a CD containing the prescribed C++ software (Disk2019);

2 OVERVIEW OF THE MODULE COS1512

 Through assignments, including multiple choice and written assignments and an

 interpret a problem description which specifies the requirements of a program;

 apply object-oriented principles during problem solving.

 write functions and use them in a program;

 define classes and use object-oriented principles to implement programming problems;

 recognise/locate errors in a program and correct them.

 define relevant programming concepts.

3 LECTURER(S) AND CONTACT DETAILS

Additional Additional tutorial letters such as solutions to assignments and the

4.3 Prescribed books

4.8 Additional Resources

5 STUDENT SUPPORT SERVICES FOR THE MODULE

Chapter Sections covered

Chapter 1 1.1 and 1.2

Chapter 4 Only 4.6

Chapter 5 Only 5.5

Chapter 6 All sections

Chapter 9 All sections excluding the optional subsections in 9.2

Chapter 10 All sections

Chapter 11 All sections, plus Appendixes 7 and 8

Chapter 12 12.1 and only the first two pages of 12.2

Chapter 14 14.1 and 14.2, thus excluding 14.3

Chapter 15 Only 15.1, thus excluding 15.2 and 15.3

Chapter 17 All sections

First semester Second semester

To get going with your studies, do the following:

 Read this tutorial letter (COS1512/101/3/2019) and Tutorial Letter

 Obtain a copy of the prescribed book.

Week Date (Monday) Activity Remark

Study programme for second semester registration:

Week Date (Monday) Activity Remark

4 29 Jul 2019 Complete Due date 5 August

6.3 Hints on studying this module

7 MODULE PRACTICAL WORK AND WORK-INTEGRATED LEARNING

Please note the following:

 Submit only one copy of a specific assignment.

Assignment number Weight

Mark Contribution to semester mark

1 75% 20% 75/100 * 20/100 0.15

2 80% 80% 80/100*80/100 0.64

Assignment Unique number

Assignment 1 Semester 1 845521

Assignment 2 Semester 1 796894

Assignment 1 Semester 2 844345

Assignment 2 Semester 2 764406

8.2.2 Due dates for assignments

Assignment Due Date Semester Due Date Semester Weight

01 18 February 2019 5 August 2019 20%

02 1 April 2019 16 September 2019 80%

03 29 Apr 2019 - do not 14 October 2019 - do Self Assessment

Due to regulatory requirements (imposed by the Department of National Education) the