Spring 2026 CISC-2000-E01
is CRN (course reference number) 51197, 3 credits.
Spring 2026 CISC-2010-E01
is CRN (course reference number) 51198, 1 credit.
The home page for these two courses is
https://markmeretzky.com/fordham/2000/
The student must know how to use the following features of the C++ programming language.
if
statements)
CISC-2000 will begin with a fast review of the prerequisite topics covered in CISC-1600, and then move on to various low-level topics close 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 on a byte-by-byte basis. We will manipulate the binary values there by means of bitwise operators on a bit-by-bit basis. We will learn to write these value in binary (base 2) and hexadecimal (base 16) notation.
The main goal of CISC-2000 will be to create and use objects in the language C++. In Computer Science, an object is a group of functions (pieces of executable code) packaged together with the variables (little containers) that hold the values manipulated by these functions. There are many different classes of objects, each offering a different service to the rest of the program. We will equip our classes with overloaded operators to provide a familiar notation for manipulating the objects of each class.
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 higher level functions call lower level functions. Today, we do this by building bigger classes out of smaller classes.
This course will introduce the two most important ways of building bigger classes out of smaller 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 one or more existing classes, while also offering additional functionality. Second, we will use templates to plug a choice of existing classes and other types of data into a new class under construction.
CISC-2010 is the hands-on lab that goes with CISC-2000.
All our work will be done using the GNU C++ compiler
on the Fedora Linux server
storm.cis.fordham.edu.
Students will connect to this server
via a Windows PC or an Apple Macintosh.
We will review the basic housekeeping facts about files and directories
(how to create, copy, move, and rename a file),
and will set up a simple shellscript to automate the process of
compiling
(translating) a program from C++ into the native language
of the computer.
We have 14 × 2.75 = 38.5 classroom hours, plus 14 lab hours, to explore the following topics, in approximately the following order.
We will review C++
variables,
starting with their data types, lifespans,
and various flavors
(consts
and references).
Variables can be grouped into arrays (single and multi-dimensional),
structures, and arrays of structures.
Then we will review control structure
statements such as loops
(while and for)
and conditional statements
(if/else and switch),
and how to nest them inside of each other.
We will review the declaration and definition of
functions,
and the two ways of passing arguments to functions
(by value vs. by reference).
We will use the commands of the Linux operating system to type in, edit, compile (translate), and run our C++ programs. We will learn to create, move, copy, rename, and remove the files that hold these programs and their input and output. We will also need to create directories (folders) to hold these files. A rudimentary Linux shellscript will automate the process of compilation.
A pointer is a variable that contains the memory address of some other variable. The value of a pointer is conventionally written in binary (base 2) or hexadecimal (base 16) notation. Pointers will give us direct acces to the bytes of data in the computer’s memory. (We will also use bitwise operators such as “and”, “or”, and “shift” to manipulate the individual bits of those bytes.) For example, a function can receive a pointer giving the function access to a 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 runnning 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 give the program a pointer containing the address of the requested block of memory. This will provide us with another application for pointers, and an opportunity to throw and catch “exceptions” when something goes wrong. Finally, the program is responsible for returning the block of memory back to the operating system so that other programs can use it.
An object
is a group of functions (the
member functions
of the object)
bundled together with
a group of variables (the
data members
of the object).
An invisible pointer argument (called the
this
pointer in C++)
is the hidden machinery
that gives the member functions access to the data members.
The programmer can create many
classes
of objects.
We will start with the simple example of a
date
object containing data members to hold the
object’s
year,
month,
and
day.
These data members will accessed
by the member functions belonging to the object
to perform simple calendar arithmetic.
Creating a class of objects will require several different kinds of packaging. On the physical level, different parts of the C++ program will have to be written in separate files. On the security level, we will have to decide which functions will have access to which variables, and which variables will be the private property of the class as a whole or the private property of an individual object 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 later point. The birth and death of an object can automatically trigger the execution of a pair of functions called the constructor and destructor, causing events to happen in pairs and in nested pairs.
In the language C++, an operator is a symbol that performs arithmetic or another operation such as input and output. Familiar examples include
+
add-
subtract*
multiply/
divide+)
for adding two
ints
(whole numbers)
and adding two
doubles
(numbers with fractions),
even though these two types of addition
are very different operations deep inside the hardware of the computer.
The users of a new class expect to be able to apply the familiar operator symbols to the objects of the class. We will overload the operators so as not to disappoint them.
When we create a new class of objects from scratch, we have to create all the member functions and data members that will belong to the objects of the class. Or we can use inheritance to create the new class by building on the work we have already put into one or more existing classes. (This is called single or multiple inheritance, respectively.) Our new class will be born with a head start, automatically inheriting the features of an existing class or classes, as well as having additional features that were not present in its parent(s). This new class can have children of its own, resulting in grandchild classes. In this way, more complicated classes can be built up as 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 template will also let us plug in a simple class or another type of data into a function.
For example,
the template syntax lets us create different flavors of the
container classes
in the C++ Standard Library.
We can create a
list
of numbers, strings, dates,
or of almost any data type we wish to plug in.
The container classes we will see in this course are
list,
vector,
set,
and
map.
We will use the latter to let a C++ program
retrieve data from an HTML
form
containing
widgets
such as buttons and checkboxes.
Mark Meretzky’s office is 340 JMC
(John Mulcahy Hall).
He has no office hours.
But you can Zoom him, or email him at
mmeretzky@fordham.edu.
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 1 2 3 4 5 6 7 1 2 3 4 5 6 7
4 5 6 7 8 9 10 8 9 10 11 12 13 14 8 9 10 11 12 13 14
11 12 13 14 15 16 17 15 16 17 18 19 20 21 15 16 17 18 19 20 21
18 19 20 21 22 23 24 22 23 24 25 26 27 28 22 23 24 25 26 27 28
25 26 27 28 29 30 31 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 1 2 1 2 3 4 5 6
5 6 7 8 9 10 11 3 4 5 6 7 8 9 7 8 9 10 11 12 13
12 13 14 15 16 17 18 10 11 12 13 14 15 16 14 15 16 17 18 19 20
19 20 21 22 23 24 25 17 18 19 20 21 22 23 21 22 23 24 25 26 27
26 27 28 29 30 24 25 26 27 28 29 30 28 29 30
31
CISC-2000-E01 meets from 6:00 to 8:45 pm,
with a 10-minute intermission in the middle.
CISC-2010-E01 meets from 8:50 to 9:55 pm.
CISC-2000-E01 and CISC-2010-E01 meet in room 318 of Keating Hall, the architectural centerpiece of the Rose Hill (Bronx) campus of Fordham University. Here’s the Google Map. Three ways to get there:
Each student’s desk in room 318
has a Microsoft Windows PC.
We will use these PC’s to connect to the Fedora Linux server
storm.cis.fordham.edu,
which is the computer that will actually store and execute our C++ programs.
We will use the
GNU
C++ compiler
/usr/bin/c++
(version 15.1.1 this semester)
to translate each C++ program
into terms that
storm
can understand and execute.
If a student has a computer (PC, Mac, or Linux) at home or at work,
he or she should connect to
storm.cis.fordham.edu
during the week between classes.
In fact, if the student’s own computer is portable,
he or she can bring it to class and use it instead of the PCs
in the classroom.
Most people are more comfortable using their own computer.
For your personal sanity, the third floor of Keating Hall also offers the historic Blue Chapel. Its stained glass windows face 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/
No loginname or password is required.
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. If you hand in all or most of your homework in one big lump at the end of the semester, it will be ignored. A student should expect to spend at least three hours per week outside of class on homework.
A student will submit his or her homework by posting it in the
public_html
directory of their account
on the Fedora 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 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 late and/or absent, they will fail the midterm and final. That’s obvious, isn’t it? Read the Fordham policy on lateness, absences and plagiarism.
Attendance will be taken when the class begins at 6:00 pm. If you are not present at that time, you will be marked “absent” for that week. Lateness and/or absence will have a devastating effect on your grade. For example, as per Fordham policy, you will fail the caourse if you are absent two or more times.
Reliable indications that a student has plagiarized their work include
=
instead of with
{curly
braces}.
endl
instead of outputting a simple
"\n"
character.
0
instead of
EXIT_SUCCESS
from the
main
function.
.cpp
or (lowercase)
.c
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 performance on the homeworks, midterm, and final
will almost always be very similar.
Most students deliver consistent product.
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.
CISC offers tutoring at both campuses.
There’s also a Fordham Computer Science Society, which has been known to give out free pizza. Google for it.
Here are links to the
Fordham Emergency
Medical Services
Fordham Counseling and Psychological Services
Fordham
Office of Disability Services
If you are unable to attend class or do any work this semester, contact the dean of your school.
Under the Americans with Disabilities Act,
all members of the campus community
are entitled to equal access to the programs and activities
of Fordham University.
If you have (or think that you might have) a disability
that may impact your participation in the activities, coursework,
or assessment of this course,
you may be entitled to accommodations through the
Office of
Disability Services.
You can contact them at 718-817-0655,
disabilityservices@fordham.edu,
or by visiting the lower level of O’Hare Hall on the Rose Hill campus.
Whether or not you have documentation for accommodations,
your success in this class is important to me.
If there are aspects of the course that are not accessible to you,
please let me know as soon as possible so that we can work together to
develop strategies to meet both your needs and the requirements of the course.