Course Title

Programming Principles 2

Course Number

10671102

Instructor Name

MOAMIN BURHAM JAMIL ABUGHAZALA

Contact Information

[email protected]

Semester(s) and academic year(s)

First Semester 2024

Compulsory / Elective

Compulsory

This course provides a comprehensive exploration of C++ programming, focusing on advanced concepts such as pointers, dynamic memory allocation, object-oriented programming (OOP), file handling, and inheritance. Designed for students with a foundational understanding of C++, the course builds on core principles to enhance their ability to write efficient and structured code.

Course Modules:

1. Pointers and Memory Management (Weeks 1-2)

   • Quick review of memory layout and pointer operations
   • Understanding reference (&) and dereference (*) operators
   • Pointer arithmetic, comparisons, and their relationship with arrays
   • Dynamic memory allocation and deallocation

2. Advanced Pointer Operations (Weeks 3-4)

   • Void and constant pointers
   • Memory management for primitive and array data types
   • Passing parameters (by value, reference, and address)
   • Handling pointers in function arguments

3. Working with 2D Arrays (Weeks 5-6)

   • Static and dynamic 2D arrays
   • Passing 2D arrays to functions for modular programming

4. C-Style Strings (Week 7)

   • Understanding C-style strings and their limitations
   • Using standard library functions for string manipulation
   • Numeric conversion techniques

5. Structures and Abstract Data Types (Weeks 8-9)

   • Defining and using struct in C++
   • Working with arrays of structures and structure aggregation
   • Passing and returning structures in functions

6. Introduction to Object-Oriented Programming (OOP) (Weeks 10-11)

   • Transition from procedural to OOP paradigms
   • Defining and implementing classes
   • Encapsulation, access specifiers, and class scope
   • Constructors, destructors, and operator overloading

7. Advanced OOP Concepts (Weeks 12-13)

   • Instance vs. static members
   • Friend functions and classes
   • Copy constructors and member-wise assignment
   • Operator overloading for binary and unary operations

8. File Handling with C++ Streams (Weeks 14-15)

   • File input and output operations
   • Handling text and binary files
   • File stream manipulation and error handling

9. Inheritance and Class Hierarchies (Weeks 16-17)

   • Principles of inheritance and code reuse
   • Constructor and destructor behavior in inheritance
   • Method overriding and access control

By the end of this course, students will be able to:

1. Understand and Apply Pointer Concepts:

   • Explain memory layout and how pointers interact with memory.
   • Use pointer operators (* and &) for referencing and dereferencing.
   • Perform pointer arithmetic and comparisons.
   • Implement dynamic memory allocation and deallocation.

2. Work with Advanced Pointer Operations:

   • Utilize void and constant pointers effectively.
   • Manage memory dynamically for primitive types and arrays.
   • Pass parameters efficiently using pointers (by value, reference, and address).

3. Manipulate 1D and 2D Arrays Using Pointers:

   • Work with static and dynamic 2D arrays.
   • Pass arrays to functions and manipulate data structures.

4. Use and Manipulate C-Style Strings:

   • Handle C-style strings and apply standard string manipulation functions.
   • Convert numeric values using appropriate functions.

5. Implement and Utilize Structures in C++:

   • Define and manipulate structures (struct).
   • Work with arrays of structures and nested structures.
   • Pass and return structures in functions.

6. Understand and Apply Object-Oriented Programming (OOP) Principles:

   • Differentiate between procedural and object-oriented paradigms.
   • Define classes with proper encapsulation.
   • Implement constructors, destructors, and function overloading.

7. Work with Advanced OOP Features:

   • Utilize static and instance members in classes.
   • Implement friend functions and classes.
   • Perform member-wise assignment and use copy constructors.
   • Overload binary and unary operators.

8. Handle File I/O Operations in C++:

   • Read from and write to text files using C++ streams.
   • Work with binary file handling (optional).
   • Manage file operations effectively with error handling.

9. Implement Inheritance and Class Hierarchies:

   • Understand and implement inheritance in C++.
   • Apply protected access and function overriding.
   • Design and implement multi-level inheritance structures.

10. Explore Polymorphism and Virtual Functions (Optional):

    • Implement polymorphism using virtual functions.
    • Design abstract base classes with pure virtual functions.

By achieving these objectives, students will gain the necessary skills to develop complex applications using C++ and apply object-oriented principles effectively in software development.

Intended Learning Outcomes (ILOs) and Competencies

Knowledge & Understanding:

By the end of the course, students will be able to:

1. Explain memory management concepts, including pointers, dynamic memory allocation, and deallocation.
2. Understand the principles of object-oriented programming (OOP) and their application in C++.
3. Differentiate between procedural and OOP paradigms, including class design, inheritance, and polymorphism.
4. Describe the mechanisms for file handling in C++, including text and binary files.

Cognitive Skills (Problem-Solving & Analysis):

5. Analyze and debug pointer-related errors and memory leaks in C++ programs.
6. Design and implement efficient data structures using pointers, arrays, and structures.
7. Apply OOP principles such as encapsulation, inheritance, and polymorphism to solve real-world programming problems.
8. Develop modular and reusable code through effective class design and operator overloading.

Practical & Professional Skills:

9. Write, compile, and execute C++ programs that use pointers, dynamic memory, and structures.
10. Implement complex OOP features such as constructors, destructors, friend functions, and operator overloading.
11. Use file handling techniques for data storage and retrieval.
12. Apply best coding practices, debugging techniques, and memory management strategies.

Communication & Teamwork Skills:

13. Document and explain code effectively using comments and structured programming practices.
14. Work collaboratively on programming tasks and projects, applying version control practices where necessary.
15. Present and discuss programming solutions and design choices with peers.

Summary of Competencies Gained:

• Programming Proficiency: Strong command of advanced C++ concepts, including memory management, OOP, and file handling.
• Software Development Skills: Ability to design, implement, and optimize modular and efficient programs.
• Debugging & Optimization: Capability to identify, debug, and resolve memory and logic errors.
• Problem-Solving: Applying structured programming and OOP principles to complex software problems.
• Collaboration & Communication: Ability to document, explain, and present code effectively while working in teams.

This course ensures that students develop both the theoretical understanding and practical skills required for professional software development using C++.

• gaddis: Starting Out with C++: From Control Structures through Objects, 9th edition
• malik: c++ programming from problem analysis to program design, D.S.Malik, 8th edition, 2017