CISC-2000-E01 is CRN (course reference number) 51197, 3 credits.
CISC-2010-E01 is CRN (course reference number) 51198, 1 credit.
The home page for these two courses is
https://markmeretzky.com/fordham/2000/
Students must know how to use variables,
control structure (loops and if statements),
arrays, and functions in the C++ programming language.
These topics are covered in the following courses:
The student has to be able to proofread his or her own work, and to compare their work on a character by character basis with the exmples presented in class. In this business, a typographical error of even a single keystroke can kill you.
In Computer Science, an object is a group of functions (pieces of executable code) packaged together with variables that hold values. We will begin by learning to combine functions and variables to form an object in the language C++. There are many different classes of objects, each offering a different service to the rest of the program.
Programming is the art of building bigger pieces of software out of smaller ones. In the days before Object-Oriented programming, we did this by having bigger functions call smaller ones. Today, we do it by building bigger classes out of smaller ones.
This course will introduce the two most important ways of combining smaller classes into bigger ones in the language C++. First, we will use inheritance and polymorphism to build a new class whose objects automatically inherit all the functionality of the objects of an existing class, while also offering additional functionalities. Second, we will use templates to plug a choice of existing classes into a new class under construction.
The course will also touch on low-level topics closer to the computer’s hardware. We will use pointers, address arithmetic, and dynamic memory allocation to directly access the data in the computer’s memory. We will manipulate the binary values there by means of bitwise operators.
CISC-2010 is the hands-on lab that goes with CISC-2000. All our work will be done using the GNU C++ compiler on a Fedora Linux server. Students will connect to this computer via a Windows PC or an Apple Macintosh.
Mark Meretzky
has no office or office hours.
But you can Zoom him, or email him at
mmeretzky@fordham.edu.
Please contact him when you need help;
he wants to hear your story.
If the students desire,
the instructor can arrive on the Rose Hill campus an hour before class
to offer individual help.
We’ll talk about this once the course begins.
According to the Rose Hill calendar, we meet on 15 Thursday evenings:
The final examination is on Thursday, May 8, 2025.
2025
January February March
Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa
1 2 3 4 1 1
5 6 7 8 9 10 11 2 3 4 5 6 7 8 2 3 4 5 6 7 8
12 13 14 15 16 17 18 9 10 11 12 13 14 15 9 10 11 12 13 14 15
19 20 21 22 23 24 25 16 17 18 19 20 21 22 16 17 18 19 20 21 22
26 27 28 29 30 31 23 24 25 26 27 28 23 24 25 26 27 28 29
30 31
April May June
Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa
1 2 3 4 5 1 2 3 1 2 3 4 5 6 7
6 7 8 9 10 11 12 4 5 6 7 8 9 10 8 9 10 11 12 13 14
13 14 15 16 17 18 19 11 12 13 14 15 16 17 15 16 17 18 19 20 21
20 21 22 23 24 25 26 18 19 20 21 22 23 24 22 23 24 25 26 27 28
27 28 29 30 25 26 27 28 29 30 31 29 30
CISC-2000-E01 meets from 6:00 to 8:45 pm,
with a 10-minute intermission at the halfway point (7:17 to 7:27 pm).
CISC-2000-E01 meets from 8:50 to 9:55 pm.
In practice, however, both time slots will have a mixture of
lecture and lab work.
That’s the advantage of having a computer
on each desk in the classroom.
CISC-2000-E01 meets in room 214, and CISC-2010-E01 meets in room 318, of Keating Hall, in the Rose Hill (Bronx) campus of Fordham University. Take the B or D subway to the Fordham Road station in the Bronx. Or take the Harlem or New Haven line of Metro North to the Fordham station.
Each student’s desk in the lab room KE 318 has a Microsoft Windows PC.
We will use these machines to connect to the Fedora Linux server
storm.cis.fordham.edu.
This is the computer that will actually execute our C++ programs.
We will use the
GNU
C++ compiler
/usr/bin/c++
(version 14.2.1)
to translate each C++ program
into terms that
storm
can understand and execute.
If a student has acces to a computer at home or at work,
he or she should connect to
storm.cis.fordham.edu
during the week between classes.
ssh jsmith@storm.cis.fordham.edu
jsmith
is their Fordham ID (the first part of their Fordham email address).
Terminal
application and give the same command,
ssh jsmith@storm.cis.fordham.edu
In fact, if the student’s own computer is portable, he or she can bring it to class and use it instead of the Microsoft Windows PCs in KE 317. Most people are more comfortable using their own computer.
For personal sanity, the third floor of Keating Hall also offers the Blue Chapel, with stained glass windows facing west out onto the Edwards Parade.
The textbook is the many examples of C++ programs on the web at
https://markmeretzky.com/fordham/2000/src/.
Each homework will be a C++ program. There will be one or two assignments per week, each one due in six days. Don’t fall behind. A student should expect to spend at least three hours per week outside class on homework.
A student will submit his or her homework by posting it in the
public_html
directory of their account
on the Linux server
storm.cis.fordham.edu.
This means that every student will be able to
see the work
of every other student.
The midterm and final exam will be answered on paper. If the student has done their own homework reasonably successfully all semester, they will have no trouble with the midterm or final: it will just be more of the same. But if the student has plagiarized their homework all semester, or has been massively absent, they will fail the midterm and final. That’s obvious, isn’t it? Coming in late will severely damage your grade. Read the Fordham policy on lateness, absences and plagiarism.
Reliable indications that a student has plagiargized their work include
0
instead of
EXIT_SUCCESS
from the
main
function..cpp
instead of (uppercase) .C.
Students will get the same grade for CISC-2000-E01 and CISC-2010-E01.
The grade for the these courses will be taken
50% from the homeworks
25% from the midterm
25% from the final exam
In practice,
a student’s grade for the homeworks and the grade for the final exam
will almost always be very similar.
If you’ve been working hard all semester,
it will show on the final.
Academic integrity is the pursuit of scholarly activity in an honest, truthful and responsible manner. Fordham students are expected to accept the responsibility to be honest and to respect ethical standards in completing their academic assignments, assessments, and other requirements. Students are expected to adhere to academic integrity by completing all assignments and other requirements on their own without assistance from external resources (including any artificial intelligence or machine-learning tools) unless directly authorized by the instructor. It is the student’s responsibility to give credit to any quotation, idea, or data used from an outside source. Students who fail to meet the responsibility for academic integrity subject themselves to sanctions ranging from a reduction in grade, course failure in the assignment, or expulsion from the University.
Some members of the Fordham community are known by a name
other than their legal name.
Students who wish to be identified by a chosen name can
email the instructor at
mmeretzky@fordham.edu
to request that their chosen name and pronoun be used.
Please also let the instructor know
if he accidentally spelled your name wrong when creating your
computer account on
storm.cis.fordham.edu.
You can check this by typing the following Linux command on storm.
awk -F: '$1 == "jsmith"' /etc/passwd
where jsmith
is your Fordham ID.
The tutoring center is in room 310 of JMH (John Mulcahy Hall), south of Keating Hall in the Rose Hill (Bronx) campus of Fordham. It is open Monday through Friday, 11:30 am to 3:45 pm. Drop in, no reservations are required.
There’s a Fordham Computer Science Society, which has been known to give out free pizza.
Here are links to the
Fordham Emergency
Medical Services
Fordham Counseling and Psychological Services
Fordham
Office of Disability Services
We have 14 × 2.75 = 38.5 classroom hours, plus 14 lab hours, to explore the following topics, in approximately the following order.
A pointer is a variable that contains the address of some other variable. Pointers let us access the bits and bytes in memory directly. (We will use bitwise operators such as “and” and “or” to manipulate the individual bits.) In particular, a function can receieve a pointer which gives the function access to a whole group of variables in memory. This will be how a “member function” of an object will access the “data members” of the object.
In three situations, a C++ program may have to request blocks of memory directly from the operating system itself:
If the operating system can satisfy the C++ program’s request; it will deliver to the program a pointer containing the address of the requested block of memory. This will give us another opportunity to play with pointers.
An object
is a group of functions (the member functions)
bundled together with
a group of variables (the data members).
An invisible pointer (called the this pointer)
gives the member functions acces to the variables.
The programmer can create many classes of objects.
We will start with a simple example:
a date object containing data members to hold the
object’s
year,
month,
and
day.
The data members will accessed by the member functions attached to the object
to perform simple calendar arithmetic.
Creating a class of objects will require several different kinds of packaging. On the physical level, for example, different parts of the C++ program will have to be written in different files. On the security level, we will have to decide which functions will have access to which variables, and which pieces of data will be the private property of the class as a whole or of the individual objects of the class.
An object has well-defined boundaries in time as well as in space: it is born at a certain point during the execution of the C++ program, and dies at a certain point. The birth and death of an object can automatically trigger the execution of certain designated functions (the constructor and destructor), causing events that come in pairs and in nested pairs.
In the language C++, an operator is a symbol such as
+
-
*
/
&
that performs arithmetic and/or other tasks such as input and output.
An operator used for two or more different purposes is said to be
overloaded.
This is more natural than it sounds.
For example, we use the same symbol (the plus sign +)
for adding whole numbers and adding fractions,
even though these two types of addition
are very different operations deep inside the machine.
When we invent a new class, it may be convenient to allow the programmer to apply the familiar operator symbols to the objects of the class. We will learn how to further overload the operators to make this possible.
When we build a simple class of objects from scratch, we have to list all the member functions and data members that will belong to each object. But after doing that, we can construct an additional class with a head start. Using inheritance, we can create a new class that is automatically endowed with all the features of an existing class or classes (via single or multiple inheritance), plus some additional features. In this way, more and more complicated classes can be built up in a series of layers.
Often when we use inheritance to extend a simple class into a more elaborate one, the simple member functions of the original class are no longer capable of servicing the more advanced objects of the new class. In this case, we have to write new versions of the functions that have been superseded. The technique for making sure that the correct functions are matched with the correct objects is called polymorphism.
C++ templates give us a syntax for “plugging in” a choice of simple classes and other types of data into a more complicated class that we are creating. A temmplate will also let us plug in a simple class or another type of data into a function. This “plugging in” is expecially useful in allowing us to make a flexible choice of which container classes we will use to hold our data structures: a vector, list, set, map, etc.