CSCI 272 • Object-Oriented Programming (C++) | Spring 2026

Overview

This course builds practical C++ skills through object-oriented design: classes, composition, operator overloading, inheritance, and polymorphism — plus robust I/O with streams, stringstreams, and files. You’ll write clean, modular code and be able to explain your decisions.

Instructor: Avijit Roy • John Jay College of Criminal Justice (CUNY) | Office: L 6.63.29

Learning Outcomes

• Work confidently with functions, arrays, pointers, and vectors — including declaration, initialization, indexing, and memory-focused reasoning.
• Use function templates and generic techniques to write code that adapts to multiple data types.
• Create and manipulate strings (build, compare, concatenate, measure length, and convert between strings and other types).
• Design, implement, and use classes and objects with proper public/private access, member functions, data members, constructors, and destructors.
• Separate class interface and implementation across header and source files, and apply composition, the dot/arrow operators, the this pointer, friend functions, and static members where appropriate.
• Use streams for formatted and unformatted input/output, recover from bad input states, and employ stringstreams for parsing and building text.
• Read from and write to sequential text files and CSV files using robust, error-aware file I/O patterns.
• Overload unary and binary operators for custom class behavior, including cases that involve dynamic memory management.
• Implement inheritance with base and derived classes, including use of the protected access specifier.
• Apply polymorphism using virtual functions, pure virtual functions, and abstract classes to enable runtime method selection.
• Compare and reason about linear vs. binary search and different sorting algorithms for efficient data retrieval and ordering.
• Handle errors using exception handling (try/catch/throw), and design custom exception types for specific error scenarios.

Weekly Plan (Snapshot)

This is the detailed, week-by-week plan from the official syllabus. Minor adjustments may occur; any changes will be announced in class and on Brightspace.

Assessments

Participation & Quizzes

Short checks to reinforce weekly topics; start on time. No make-ups for late arrival unless documented emergencies.

• Weekly knowledge checks as class participation & attendance
• In-class discussion & code walk-throughs
• Two announced quizzes + brief pop quizzes

Assignments

Frequent, focused practice. Expect clean headers, comments, and testable examples. Submit on time.

• 4–5 individual assignments (see syllabus) covering key topics.
• 2 Group assignments

Midterm

• Written exam on concepts & code analysis.
• Individual take-home OOP project (Weeks 1–6).

Final — Exam + Team Capstone

• Written exam on concepts & code analysis.
• Plan (UML encouraged), implement, and present a complete OOP app.
• Clear division of work; everyone explains their code.

Grading Breakdown

Letter grades follow standard CUNY grading scale.

Grading of assignments and exams can be reviewed in person to confirm that the submitted work is your own and to clarify any questions about how your solutions work.

Programming Projects

Throughout the semester you will complete a series of programming projects that apply the course concepts: object-oriented design, class and object implementation, inheritance, polymorphism, operator overloading, exception handling, and file I/O. These projects are designed to mirror real-world problem solving and to strengthen your ability to design and build complete C++ applications.

Extra Credits

Students will have multiple opportunities throughout the semester to earn extra credit. These may include optional assignments, short quizzes, or practice activities. Please note the following:

• 100% Attendance Bonus: Students who maintain perfect attendance for the entire semester will receive an additional 5% extra credit toward their final grade.
• Deadline Policy: All extra credit work must be submitted by the posted due dates.
• No Extensions: Extra credit deadlines cannot be extended under any circumstances.
• No Retroactive Credit: Missed or expired extra credit opportunities cannot be completed or submitted later.

Responsibilities & Policies

Course Expectations

This course meets twice per week in person. You are expected to keep up with weekly materials, participate in activities, and monitor course updates regularly. Brightspace will be your central hub for announcements, assignments, quizzes, project descriptions, sample code, and grades.

• Check Brightspace several times a week for new content and updates.
• Submit assignments through the method specified for each task (Brightspace or GitHub).
• Receive email responses within 24 hours, Monday–Friday.
• You may see optional practice activities in modules — these are not graded but strongly recommended.

Student Responsibilities

• Attend class lectures regularly and arrive on time.
• Take quizzes, exams, and in-class activities at the scheduled times.
• Complete assigned readings, exercises, and programming projects on time.
• Bring code that compiles and runs, and be ready to explain your design choices.
• Back up your work and verify submissions (build, run, and test locally).

Participation Expectations

You are expected to engage respectfully and professionally with your classmates. Participation includes asking questions during demos, offering ideas, discussing debugging strategies, and contributing to group work. You are encouraged to explain your logic and collaborate conceptually without sharing full solutions.

• Participate actively in discussions and coding walkthroughs.
• Focus on explaining concepts rather than sharing full code with others.
• Practice clearly communicating your reasoning and design decisions.
• Respect the diverse experience levels of your classmates.

Attendance

Regular attendance is crucial. More than 3 unexcused absences may lower your final grade by two letter grade.

• Notify in advance for planned absences.
• Document emergencies as soon as possible.
• Missed quizzes/participation cannot be made up without valid medical emergencies.
• If you are late 20 minutes, you will be counted as absent.

Late Work & Make-Up Policy

• Quizzes, labs, and participation tasks: You must submit these on time. They cannot be made up because feedback is required before the next module starts.
• Projects and major assignments: You may submit work up to 3 days late only if you contact me before the due date. Late submissions may receive up to a 20% deduction. You will need to email me for approval, as all submission portals will close automatically after the due date.
• Midterm and final exams: You must complete these on the scheduled dates unless you have a documented emergency.

Academic Integrity

All submitted work must be your own. Sharing solutions, copying code without attribution, or submitting generated work as your own violates course and college policy and may result in a zero and further action.

• Credit any external help (peers, forums, snippets) in your README.
• Be prepared to orally explain any code you submit.

Please review the college's policies on Plagiarism and Cheating

Use of AI Tools (ChatGPT, Copilot, etc.)

• Use AI tools to learn and explore ideas — not as a substitute for your own work.
• Cite all use: if AI helps you solve a problem or write code, clearly note which tool you used and what you asked.
• No copy-paste code without citation: submitting AI-generated code as your own work is considered plagiarism.
• Be ready to share the prompts and responses you used from AI tools if requested. Do not delete the conversation history.
• You must be able to explain your code in person if asked. Inability to do so may result in loss of credit.
• AI is here to support your learning, not replace it.

Example citation: “Used ChatGPT on March 12, 2025, to understand operator overloading syntax. Prompt: ‘How to overload + operator in C++?’”

Accessibility Services

If you are a student with a disability (temporary or permanent), please reach out to the Office of Accessibility Services (OAS) at accessibilityservices@jjay.cuny.edu. OAS works in partnership with the entire John Jay community to ensure access to all areas of campus life and to arrange appropriate academic adjustments, programs, and services.

Students seeking accommodations should coordinate through the John Jay Office of Accessibility Services (OAS) and contact the instructor early in the semester so approved adjustments can be implemented promptly.

Tools & Setup

Primary IDE

• Embarcadero Dev-C++ (Windows) — this is the primary IDE used in class. All demos, screenshots, and walkthroughs will use Dev-C++.
• Visual Studio Code — optional editor (requires a working C++ toolchain).

  VS Code setup guides:

  • How to enable C++ in VS Code on Windows
  • How to enable C++ in VS Code on macOS

You may use a different C++ toolchain if you already have one configured, but make sure you can compile, run, and debug your programs reliably. Dev-C++ is the recommended and supported setup for this course.

Note for students using online compilers: You may face issues when we begin working with files, file streams, input/output redirection, and stringstreams. Online C++ compilers often block or sandbox file I/O, which will cause some assignments to fail. A local IDE (Dev-C++ or VS Code with C++ enabled) is strongly recommended.

Quick References

• cppreference.com (language/library lookups)
• ISO C++ FAQ

Using GitHub for Version Control & Submissions

GitHub will be our shared workspace and code archive. It helps you track every change, back up projects safely, and practice professional version control workflows. You’ll also use it to build your coding portfolio — and later, submit assignments when instructed. Practice and share only your learning repos (like CSCI-272-<semester>), not graded assignments, to avoid revealing answers to others.

Note: Not all assignments will be submitted via GitHub. Follow the submission method listed on Brightspace for each assignment.

Get Started

• Create an account on github.com.
• Follow: Create your first repository (GitHub Docs)
• Install Git (if needed) and configure your name/email.

Course Repo Pattern

• Create a personal practice repo named CSCI-272-<semester> (e.g., CSCI-272-Spring-2026).
• Use this repo to share practice code, notes, and experiments.
• Do not post full assignment solutions before grading is completed; you may be asked to submit privately.

Assignments & Submission

• When instructed, submit via GitHub (private repo) by sharing access to the instructor; otherwise submit on Brightspace.
• Keep .h and .cpp files separate; include clear comments.
• Commit regularly with meaningful messages (e.g., “add input validation for withdrawals”).
• Do not commit binaries or IDE build folders.

README Expectations

• Short problem summary and how to build/run.
• Reflection: what you learned, tricky parts, known issues.
• Sample I/O or screenshots when helpful.

Books & References

Required / Main Text

• C++ How to Program (10th Edition), Deitel & Deitel — ISBN-13: 978-0134448237

Optional References

• Programming: Principles and Practice Using C++ (2nd Ed.), Bjarne Stroustrup — ISBN-13: 978-0321992789
• The C++ Programming Language (4th Ed.), Bjarne Stroustrup — ISBN-13: 978-0321563842
• Effective Modern C++, Scott Meyers — ISBN-13: 978-1491903995

Any recent printing is acceptable. Library/ebook access is fine for reading and study.

Important Websites

• Brightspace — course announcements, submissions, grades.
• GitHub — repositories for practice and (when instructed) submissions.
• Dev-C++ — IDE (Windows).
• VS Code — optional editor.
• cppreference.com — C++ language & library reference.

Quick FAQs

Contact & Office Hours

You can reach me at ARoy [AT] jjay [DOT] cuny [DOT] edu

Office: NB 6.63.29 • Office hours by appointment.

Scheduling is flexible — email to coordinate a time.