Computer Programming I (C++ / Object-Oriented)
CSC 201 (Computer Programming I - C++ & Object-Oriented Paradigms) is a core sophomore-level computer science course at Delta State University (DELSU). It transitions students from procedural scripting to industry-standard Object-Oriented Programming (OOP) using C++. The course focuses on typed variable structures, pointer arithmetic, dynamic memory allocation, class design, encapsulation, inheritance hierarchies, runtime polymorphism, templates, and exception handling.
Credit Units
3 Units (NUC Standard)
Academic Level
200 Level (First Sem)
Assessment
30% CA + 70% Exam
Syllabus Scope
5 Detailed Modules
What This Course Is All About
Academic importance, curriculum placement & degree purpose
C++ provides unmatched low-level hardware access coupled with high-level object-oriented abstractions. Mastering C++ in CSC 201 prepares you for systems engineering, game engine development, high-frequency finance, and performance-critical software systems.
Topics include basic C++ syntax and control structures, function overloading, pointers, memory references, dynamic memory (`new`/`delete`), class declarations, constructor/destructor lifecycles, friend functions, operator overloading, single and multiple inheritance, virtual functions, abstract classes, templates, and the Standard Template Library (STL).
Prerequisites & Entry Expectations
Pass in prerequisite 100-level departmental foundational courses and minimum academic standing.
Official Syllabus & Modular Breakdown
Comprehensive unit-by-unit curriculum topics taught at Delta State University
C++ Syntax, Types, Functions & Memory Basics
Foundations of strongly-typed compiled languages, compilation pipelines, and scope management.
Key Topics Covered:
- Compilation model: Preprocessor, Compiler, Assembler, and Linker
- Data types, type casting, references (`&`), and variable scope/lifetimes
- Control structures: Selection (`if-else`, `switch-case`) and iteration (`for`, `while`, `do-while`)
- Functions: Parameter passing by value, by pointer, and by reference
- Function overloading, default arguments, and inline functions
Pointers, Pointer Arithmetic & Dynamic Memory Management
Low-level memory address manipulation and heap memory lifecycle in C++.
Key Topics Covered:
- Memory model: Stack vs Heap allocation
- Pointer declaration, dereferencing (`*`), and the address-of operator (`&`)
- Pointer arithmetic and relationship between arrays and pointers
- Dynamic memory allocation using `new` and `delete` operators
- Common memory bugs: Dangling pointers, memory leaks, and segmentation faults
Classes, Objects & Encapsulation
Building custom user-defined types with data abstraction and access control.
Key Topics Covered:
- Defining classes and declaring objects (instances)
- Access specifiers: `public`, `private`, and `protected`
- Constructors: Default, parameterized, and copy constructors; initialization lists
- Destructors and resource cleanup lifecycles (RAII principle)
- The `this` pointer, `const` member functions, `static` members, and `friend` functions
Inheritance, Polymorphism & Virtual Functions
Code reuse, hierarchical object modeling, and dynamic runtime method dispatch.
Key Topics Covered:
- Inheritance types: Single, multilevel, multiple, hierarchical, and hybrid inheritance
- Constructor and destructor execution order in derived classes
- Function overriding vs function overloading
- Runtime polymorphism: Virtual functions, vtables, and pure virtual functions (`= 0`)
- Abstract classes and interface design patterns in C++
Operator Overloading, Generic Templates & STL
Extending operator behavior for custom objects and leveraging generic programming.
Key Topics Covered:
- Overloading unary and binary operators (e.g., `+`, `-`, `==`, `<<`, `>>`)
- Function templates and class templates for generic programming
- Standard Template Library (STL) overview: `std::vector`, `std::list`, `std::map`, and iterators
- Exception handling: `try`, `catch`, and `throw` blocks for robust error recovery
- File stream I/O (`std::ifstream`, `std::ofstream`) for persistent data handling
Core Theoretical Concepts & Mechanisms
Key academic principles, equations, and methodologies students must master in CSC 201
Pointers & Memory Addresses
A pointer variable holds the raw hexadecimal memory address of another variable rather than the data value itself.
Exam Significance: Essential for efficient data structure implementation (linked lists, trees) and bypassing heavy copy overheads.
Encapsulation & Data Hiding
Bundling data attributes and methods that operate on them within a single class unit, while restricting direct outside access via private access specifiers.
Exam Significance: Protects internal object state from unauthorized modification and enforces interface contracts.
Virtual Functions & Dynamic Binding
A member function declared with the `virtual` keyword in a base class, whose execution is resolved dynamically at runtime based on the actual object type rather than the pointer type.
Exam Significance: The engine enabling true runtime polymorphism in C++ systems architecture.
RAII (Resource Acquisition Is Initialization)
A C++ programming paradigm where holding a resource (heap memory, open file, mutex) is strictly bound to the lifespan of an object.
Exam Significance: Prevents catastrophic memory leaks and ensures guaranteed resource deallocation when objects go out of scope.
Expected Learning Outcomes
Skills, competencies, and practical capabilities you will acquire upon completion
Write, compile, debug, and execute robust C++ programs using GNU g++ or Microsoft Visual C++ compilers.
Manage stack and heap memory accurately using pointers, references, and dynamic `new`/`delete` operations without causing memory leaks.
Design complex class hierarchies implementing single, multiple, and multilevel inheritance with correct constructor chaining.
Implement runtime polymorphism using virtual functions, abstract classes, and virtual destructors.
Build generic, reusable algorithms using C++ function and class templates alongside STL containers (`vector`, `map`).
Grading Structure & Exam Success Guide
DELSU official grading breakdown and tested strategies to score an 'A' grade
Continuous Assessment (CA — 30%)
- •15 Marks: Practical C++ coding laboratory examination.
- •10 Marks: Mid-semester written test on OOP theory, pointers, and memory diagrams.
- •5 Marks: Lab reports and regular attendance.
Semester Examination (70%)
Rigorous 3-hour written and code-tracing examination: Section A (Code tracing, pointer output prediction, bug identification) and Section B (Full C++ class implementation and algorithm coding questions).
Top Strategies for Scoring an 'A' in CSC 201
- Always trace pointer operations and memory diagrams by hand on scratch paper before writing output answers.
- Remember to include copy constructors and destructors whenever a class manages raw heap pointers (Rule of Three).
- Practice coding complete class definitions with headers and implementation syntax under timed conditions.
Recommended Textbooks & Literature
C++ How to Program (Late Objects Version)
By Paul Deitel & Harvey Deitel
Pearson
The C++ Programming Language
By Bjarne Stroustrup
Addison-Wesley
Object-Oriented Programming in C++
By Robert Lafore
Sams Publishing
Career Relevance & Professional Pathways
How this course applies to professional careers and accreditations
Systems Software Engineer
Operating Systems & NetworkingDevelops low-level system services, device drivers, and high-throughput network engines.
Game Engine Programmer
Gaming & GraphicsCreates real-time rendering pipelines, physics simulations, and 3D games in Unreal Engine.
Quantitative Developer
Fintech & Algorithmic TradingBuilds ultra-low latency execution engines and algorithmic financial trading models.
Semester Study Roadmap
Recommended weekly pacing for lectures, CA assignments, and final exam revision
Weeks 1-4: Pointers & Memory Management
Mastering pointers, references, dynamic arrays, and memory layout.
- Write 10 small programs allocating dynamic arrays with `new` and `delete[]`.
- Trace pointer-to-pointer output puzzles.
Weeks 5-8: Classes, Constructors & Encapsulation
Implementing custom classes with copy constructors and friend functions.
- Build a BankAccount and Matrix class with operator overloading.
- Prepare for mid-semester practical coding test.
Weeks 9-12: Inheritance, Polymorphism & STL
Virtual functions, abstract base classes, vectors, and exam revision.
- Build an employee payroll polymorphism hierarchy (Manager, Engineer, Intern).
- Solve past 4 years of DELSU CSC 201 examination code questions.
Lecture Notes & Handouts
Official study materials and departmental slides for CSC 201
CSC 201 Course Outline & Official Lecture Guide: Computer Programming I (C++ / Object-Oriented)
Past Examination Papers
Verified DELSU past semester question papers for CSC 201
2023/2024
First SemesterFrequently Asked Questions about CSC 201
Answers to common student questions on course registration, difficulty, and exams
Is CSC 201 mostly practical coding or theoretical examination at DELSU?
CSC 201 is balanced between practical laboratory programming and rigorous theoretical exam tracing. You must be able to write functional code on a computer and also trace pointer/class outputs on paper during exams.
What is the difference between passing by pointer and passing by reference in C++?
Passing by pointer passes the memory address explicitly using `*` syntax (which can be `nullptr`), whereas passing by reference uses `&` syntax to create an alias to the original variable without explicit pointer dereferencing.