Riverside Community College District
Integrated Course Outline of Record

Prerequisite: CIS-5 or CSC-5

Course Credit Recommendation: Degree Credit

The application of software engineering techniques to the design and development of large programs; data abstraction, structures, and associated algorithms. A comprehensive study of the syntax and semantics of the C++ language and the methodology of Object-Oriented program development. 54 hours lecture and 18 hours laboratory. (TBA option) (Same as CIS-17A)

Object-Oriented program development using C++. (Same as CIS-17A)

1. Fundamental Data Structures:
1. write programs that use each of the following data structures: such as arrays, records, strings, linked lists, stacks, queues, and hash tables,  
2. discuss the representation and use of primitive data types and built-in data structures
3. describe how arrays, stacks, queues, trees, and hash tables are allocated and used in memory
4. describe common applications for each data structure,
5. compare alternative implementations of data structures with respect to performance,
6. compare and contrast the costs and benefits of dynamic and static data structure implementations, and
7. choose the appropriate data structure for modeling a given problem. 
1. The coverage of the fundamental data structures shall include the following:
1. Primitive types
2. Arrays
3. Records
4. Strings and string processing
5. Data representation in memory
6. Static, stack, and heap allocation
7. Runtime storage management
8. Pointers and references
9. Linked structures
10. Implementation strategies for stacks, queues, and hash tables
11. Implementation strategies for trees
12. Strategies for choosing the right data structure
2. Recursion:
1. implement, test, and debug simple recursive functions and procedures
2. describe the concept of recursion and give examples of its use,
3. identify the base case and the general case of a recursively defined problem,
4. compare iterative and recursive solutions for elementary problems such as factorial,
5. describe the divide-and-conquer approach,
6. describe how recursion can be implemented using a stack,
7. discuss problems for which backtracking is an appropriate solution, and
8. determine when a recursive solution is appropriate for a problem. 
1. The coverage of recursion shall include the following:
1. The concept of recursion
2. Recursive mathematical functions
3. Simple recursive procedures
4. Divide-and-conquer strategies
5. Recursive backtracking
6. Implementation of recursion
3. Declarations and Types:
1. evaluate tradeoffs in lifetime management (reference counting vs. garbage collection), 
2. explain the value of declaration models, especially with respect to programming-in the-large,
3. identify and describe the properties of a variable such as its associated address, value, scope, persistence, and size,
4. discuss type incompatibility,
5. demonstrate different forms of binding, visibility, scoping, and lifetime management, and
6. defend the importance of types and type-checking in providing abstraction and safety. 
1. The declaration and types shall include the following:
1. The conception of types as a set of values together with a set of operations
2. Declaration models (binding, visibility, scope, and lifetime)
3. Overview of type-checking
4. Garbage collection
4. Abstraction Mechanisms:
1. explain how abstraction mechanisms support the creation of reusable software components,
2. demonstrate the difference between call-by-value and call-by-reference parameter passing,
3. defend the importance of abstractions, especially with respect to programming-in-the-large, and
4. describe how the computer system uses activation records to manage program modules and their data. 
1. Abstraction mechanisms shall include the following concepts:
1. Procedures, functions, and iterators as abstraction mechanisms
2. Parametrization mechanisms (reference vs. value)
3. Activation records and storage management
4. Type parameters and parametrized types - templates or generics
5. Modules in programming languages
5. Software Design:
1. design, implement, test, and debug simple programs in an object-oriented programming language,
2. compare and contrast object-oriented analysis and design with structured analysis and design,
3. compare and contrast the notions of overloading and overriding methods in an object-oriented language,
4. justify the philosophy of object-oriented design and the concepts of encapsulation, abstraction, inheritance, and polymorphism,
5. describe how the class mechanism supports encapsulation and information hiding,
6. design, implement, and test the implementation of “is-a” relationships among objects using a class hierarchy and inheritance,
7. explain the relationship between the static structure of the class and the dynamic structure of the instances of the class, and
8. describe how iterators access the elements of a container. 
1. Software design concepts shall include the following:
1. Fundamental design concepts and principles
2. Design strategy
6. Object Oriented Programming:
1. justify the philosophy of object-oriented design and the concepts of encapsulation, abstraction, inheritance, and polymorphism,
2. design, implement, test, and debug programs in an object-oriented programming language,
3. describe how the class mechanism supports encapsulation and information hiding,
4. design, implement and test the is-a relationships among objects using a class hierarchy and inheritance,
5. compare and contrast the notions of overloading and overriding methods in an object-oriented language,
6. explain the relationship between the static structure of the class and the dynamic structure of the instances of the class, and
7. describe how iterators access the elements of a container. 
1. OOP concepts shall include the following:
1. Object-oriented design
2. Encapsulation and information-hiding
3. Separation of behavior and implementation
4. Classes and subclasses
5. Inheritance (overriding, dynamic dispatch)
6. Polymorphism (subtype polymorphism vs. inheritance)
7. Class hierarchies
8. Collection classes and iteration protocols
9. Internal representations of objects and method tables
7. Classes and members
1. Creating classes with Declaration and Implementation Sections
   1. Encapsulating Class Components
   2. Designing Classes
   3. Implementing Class Functions
2. Data Hiding and Encapsulations
   1. Using Public Functions to Alter Private Data
3. Using Private functions
4. Considering Scope When Defining Member Functions
5. Using Static Class Members
   1. Defining Static Data Members
   2. Using Static Functions
6. Understanding the this Pointer
   1. Using the this Pointer Explicitly
   2. Using the Pointer-to Member Operator
7. Understanding Polymorphism
8. Class Features and Design Issues
   1. Using member functions
   2. Understanding Constructors
      1. Writing Constructors
      2. Overriding the constructor’s default Arguments
      3. Overloading Constructors
   3. Using Destructors
   4. Using Classes Within Classes
      1. Considering Reusability and Maintenance Issues
      2. Using #ifndef, #define, and #endif
   5. Improving Functions
      1. Selecting Member Data and Function Names
      2. Reducing Coupling Between Functions
      3. Increasing Cohesion Within a Function
9. Friends
   1. How to Declare a Function as a friend
   2. Using a friend Function to Access Data from Two Classes
   3. Using a Forward Reference
   4. Making a friend of a Member of Another Class
   5. Making a friend of Another Class
10. Overloading Operators
    1. Using Operators Polymorphically
    2. Overloading Math Operators
    3. Overloading Operators to work with Class Objects
    4. Overloading Input
    5. Overloading Output
11. Inheritance
    1. Understanding the Advantages Provided by Inheritance
    2. Creating a Derived Class
    3. Inheritance Restrictions
    4. Choosing the Class Access Specifier
    5. Overriding and Overloading Parent Class Functions
    6. Using Constructor Initialization Lists
    7. Providing for Base Class Construction
    8. Overriding Inherited Access
    9. Using Multiple Inheritance
    10. Using Virtual Base Classes
12. Advanced Input and Output
    1. Using istream and ostream Member Functions
    2. Creating Manipulator Functions
    3. Using Built-in Manipulators
    4. Writing and Reading Objects
13. Templates
    1. Understanding the Usefulness of Function Templates
    2. Creating Function templates
    3. Using Multiple Arguments to Function Templates
    4. Overloading Function Templates
    5. Using More than one Parametrized Type in a Function Template
    6. Explicitly Specifying the Type in a Function Template
    7. Using Function Templates with Class Objects
    8. Using Template Classes
    9. Creating a Complete Class Template
    10. Using Container Classes
14. Handling Exceptions
    1. Throwing and Catching Exceptions
    2. Throwing Objects
    3. Using the Default Exception Handler
    4. Using Exception Specifications
    5. Handling Memory Allocation Exceptions

Additional Laboratory Content

This course includes 18 hours of lab instruction. There will be assignments or projects to be submitted on various topics such as:

1. Fundamental Data Structures
   1. Choose the appropriate data structure for modeling a given problem.
2. Recursion
   1. Implement, test, and debug simple recursive functions and procedures.
3. Software Design
   1. Design, implement, test, and debug simple programs in an object-oriented programming language.
4. Object Oriented Programming
   1. Design, implement, test, and debug programs in an object-oriented programming language,
5. Overloading Operators
   1. Implement Math Operators
6. Inheritance
   1. Create derived classes
7. Templates
   1. Create Complete Class Templates
8. Handling Exceptions
   1. Throwing and Catching Exceptions
   2. Serialize Data

Methods of instruction used to achieve student learning outcomes may include, but are not limited to, the following activities:

• Presentation of class lectures/discussions/demonstrations in order to clarify the principles of object oriented programming, computer problem solving, and software design concepts.
• Web-based/web-enhanced/online/distance learning tasks/activities to reinforce understanding of concepts related to object oriented programming skills, computer problem solving, and software design.
• Online and Laboratory activities and application assignments in order to address areas of improvement in object oriented programming, computer problem solving, and software design.
• Projects in order to facilitate and demonstrate the acquisition of skills required to create object oriented programs.
• Collaborative projects/cooperative learning tasks in order to encourage students to develop and apply object oriented programming, computer problem solving, software design, and team work skills.
• Pair and small group activities/discussion to enhance student understanding of programming concepts.
• Class exercises to write small compact programs demonstrating the topics per each chapter.
• Handouts to assist student learning and to capture critical ideas.
• Individual conferences.
• Guest lecturers to emphasize certain critical topics plus  expose students to current programming trends.

Students will be evaluated for progress in and/or mastery of student learning outcomes using methods of evaluation which may include, but are not limited to, the following activities:

• Computer programs designed to demonstrate the acquisition of object oriented programming, computer problem solving, and software design concepts and skills.
• Quizzes/examinations designed to measure students’ degree of mastery of fundamental object oriented programming and software design concepts and terminology.
• Collaborative projects designed to demonstrate successful understanding and application of object oriented programming, computer problem solving, software design, and team work skills.
• Computer Laboratory assignments/projects designed to clarify students’ individual object oriented programming, computer problem solving, software design strengths and areas of improvement related to these skills.
• Final examination designed to evaluate students’ overall achievement of course objectives in object oriented programming, computer problem solving, and software design concepts.

Outside-of-Class Reading Assignments

• The primary assignments for this course involve the creation of programs using C++. To support that, students will be assigned textbook reading and/or other resource reading that covers programming concepts and demonstrates usage of C++.

Outside-of-Class Writing Assignments

• Assignments for this course involve writing C++ programming statements to form complete programs that carry out specific tasks.
• Students will also be asked to document their work with written explanations that clarify their programming code.

Other Outside-of-Class Assignments

• The primary assignments for this course involve the creation of programs using C++.

All materials used in this course will be periodically reviewed to ensure that they are appropriate for college level instruction. Possible texts include the following:

• Deitel, H. M. and P. J. Deitel. C++ How to Program . 10th Pearson, 2016.
• Gaddis, Tony. Starting Out with C++ from Control Structures to Objects. 10th Pearson, 2017.
• Savitch, Walter. Problem Solving with C++. 10th Pearson, 2017.
• Cygwin. Software. 2.9. http://www.cygwin.com/, C++ Compiler.
• Draw.IO. Software. 2017. https://www.draw.io/, Online Flow-charting/UML Tool.
• Netbeans. Software. 8.2. http://netbeans.org/, IDE.
• GIT. Software. 2.14. https://git-scm.com/, Git Client.
• Github. Software. 2017. https://github.com/, Repository.

CB05 NOR Transfer Status: Transfers to Both UC/CSU (A)
CB05 RIV Transfer Status: Transfers to Both UC/CSU (A)