|1. Description - |
|This course is a systematic treatment of intermediate concepts in computer science through the study of C++ object-oriented programming (OOP) intended for Computer Science majors as well as non-majors and professionals seeking intermediate-level C++ experience. Coding topics include C++ derived classes, class templates, function templates, virtual functions, operator overloading, an introduction to the Standard Template Library, multiple inheritance, pointers, dynamic memory allocation and file I/O. Concept topics include OOP project design, inheritance, polymorphism, method chaining, functional programming, linked-lists, FIFOs, LIFOs, events in GUIs and guarded code.|
|Prerequisite: C S 2A.|
|Advisory: Eligibility for ENGL 1A or ESLL 26.|
|2. Course Objectives - |
|The student will be able to: |
- Configure an Integrated Development Environment (IDE) appropriate for advanced C++ programming.
- Use both instance members and static members, as appropriate, in class design.
- Analyze and demonstrate the use of dynamic and static C++ multi-dimensional arrays.
- Design, implement, and test C++ programs that use class inheritance, and explain why this is an example of the ‚ƒúis-a‚ƒù relationship.
- Demonstrate the use of function chaining between derived class and base class methods, and give examples of the C++ syntax used for chained constructors.
- Apply unary and binary operator overloading to different situations and explain how it simplifies syntax.
- Describe declaration models for run-time storage allocation, garbage collection, deep memory copies and type checking.
- Explain how guarded code is implemented in C++ through exceptions.
- Express numbers in decimal, binary and hexadecimal representations and use bitwise logical operators to process data at the bit and byte level.
- Demonstrate a working knowledge of basic abstract data types (ADTs) and produce examples of each.
- Explain what abstract classes and pure virtual functions are and how they are used.
- Name the "Big Three" class methods in C++ and discuss the role of each.
- Write code that makes effective use of the Standard Template Library.
- Define various types of C++ template classes and show how each is specialized to a class by the client program.
- Explain the use of multiple inheritance.
- Demonstrate how files are written-to and read-from in C++.
- Design, implement, test, and debug intermediate-level C++ programs that use each of the following fundamental programming constructs: string processing, numeric computation, simple I/O, arrays and the C++ API.
- Write applications that solve problems in one or more application area: mathematics, physics, chemistry, cellular automata, 3-D simulation, astronomy, biology, business, Internet.
|3. Special Facilities and/or Equipment - |
- Access to a computer laboratory with C++ compilers.
- Website or course management system with an assignment posting component (through which all lab assignments are to be submitted) and a forum component (where students can discuss course material and receive help from the instructor). This applies to all sections, including on-campus (i.e., face-to-face) offerings.
- When taught via Foothill Global Access on the Internet, the college will provide a fully functional and maintained course management system through which the instructor and students can interact.
- When taught via Foothill Global Access on the Internet, students must have currently existing e-mail accounts and ongoing access to computers with internet capabilities.
|4. Course Content (Body of knowledge) - |
- Setting up a complete C++ environment.
- The Standard Template Library (C++ collections)
- Configuring the IDE for advanced C++ programming
- The proper use of class members and methods
- When to use instance members and methods
- When to use static members and methods
- Implicit and explicit use of the "this" pointer
- The context-sensitive meanings of "const"
- Multi-dimensional arrays
- Dynamic allocation pointer-based arrays
- 2-D arrays
- Arrays of pointers
- The "is a" relationship
- Base classes
- Derived classes (subclasses) and class heirarchy
- Virtual functions
- Derived class constructors and destructors
- Member method overriding vs. simple overloading
- Private, protected and public members
- Encapsulation and Polymorphism
- Function Chaining
- Chaining in constructors using initializers
- Member method chaining
- Operator Overloading
- Unary operators
- Binary operators
- Member vs. global-scope operators
- Storage Allocation Methods and Deep vs. Shallow Memory Copies
- Run time binding and storage management of activation records.
- Declaration consequences of pointers, references and value parameters.
- Strong type-checking and run-time vs. compile time error detection.
- Effect of declaration strategy on binding, visibility and lifetime of variables.
- Effect of declaration strategy on scope and persistence of variables.
- Instantiation of member objects in constructors
- Copy constructors and deep copies of objects
- Exception Handling and Event-Driven Programming
- Built-in C++ exception classes
- User-defined exceptions
- When to re-throw and when to handle an exception
- Alternatives to exceptions
- GUI API (instructor's choice) and event-handling techniques
- Non-decimal arithmetic
- Bitwise numeric operators
- Bitwise logical operators
- Binary and hexadecimal constants
- Topics in Abstract Data Types (ADTs)
- The vector ADT and C++'s Vector
- The linked-list ADT and C++'s List
- The Stack and Queue ADT
- Implementing ADTs through inheritance
- Using existing ADTs from STL
- Abstract Classes
- Defining and using abstract classes
- Pure virtual functions
- Deep Copies and the "Big Three"
- The Copy Constructor
- The Assignment Operator
- The Destructor and cleaning up
- C++ Standard Template Library
- C++ Vectors
- C++ Lists and Iterators
- C++ Templates
- Class Templates
- Function Templates
- Type Parameters
- Multiple Inheritance
- Common grandparent classes
- Distinct grandparent classes
- Other combinations
- Topics in C++ File I/O
- Input Streams
- Output Streams
- Essential examples and Assignment Areas
- String/text processing
- Numeric computation
- User interaction
- Multi-class projects and compound data types
- Inheritance-based projects
- Representative GUI project with event-driven design
- Applications used throughout course in selected areas
- Business and finance
|5. Repeatability - Moved to header area.|
|6. Methods of Evaluation - |
- Tests and quizzes
- Written laboratory assignments which include source code, sample runs and documentation.
- Final examination
|7. Representative Text(s) - |
|Savitch, Walter. Absolute C++, 3rd Edition, Addison Wesley, 2008. |
|8. Disciplines - |
|Computer Science |
|9. Method of Instruction - |
- Lectures which include motivation for syntax and use of the C++ language and OOP concepts, example programs, and analysis of these programs.
- On-line labs (for all sections, including those meeting face-to-face/on campus) consisting of
- A programming assignment web-page located on a college-hosted course management system or other department-approved Internet environment. Here, the students will review the specification of each programming assignment and submit their completed lab work.
- A discussion web-page located on a college hosted course management system or other department-approved Internet environment. Here, students can request assistance from the instructor and interact publically with other class members.
- Detailed review of programming assignments which includes model solutions and specific comments on the student submissions.
- In person or on-line discussion which engages students and instructor in an ongoing dialog pertaining to all aspects of designing, implementing and analyzing programs.
- When course is taught fully on-line:
- Instructor-authored lecture materials, handouts, syllabus, assignments, tests, and other relevant course material will be delivered through a college hosted course management system or other department-approved Internet environment.
- Additional instructional guidelines for this course are listed in the attached addendum of CS department on-line practices.
|10. Lab Content - |
- Familiarization with the intermediate-level online lab environment
- Modify and customize project-specific and global settings of an Integrated Development Environment (IDE).
- Use the IDE to create multi-file programming projects.
- Organize projects within an IDE so as to support easy project-switching and orderly submission of labs.
- Gain experience with the steps needed to edit a complex program.
- Modify IDE settings to produce an industry standard code style.
- Organizing and debugging multi-class projects
- Demonstrate the ability to debug programs that contain multiple classes.
- Distinguish between interface and implementation in projects by creating classes that are independent of I/O modality.
- Write individual component classes that are independent of client use and can serve several client programs.
- Incorporate symbolic constants, statics and instance members into classes in a way that demonstrates a mature understanding of object-oriented programming (OOP) in a lab project.
- Debug a multi-class project to produce a working program.
- Exploring advanced array constructs in class design
- Gain experience in effectively using single and multi-dimensional arrays as class members.
- Apply nested loops to process multi-dimensional arrays.
- Use the IDE to debug errors in multi-dimensional arrays.
- Solve problems using fixed-size and dynamic sized arrays, as appropriate.
- Demonstrating competence in intermediate level algorithm design using classes within the IDE
- Use the IDE to implement a multi-faceted algorithm and/or simulation that makes effective use of OOP.
- Evaluate and comment on other students' algorithms.
- Utilize a combination of string processing and numeric processing to address various aspects of the algorithm implementation.
- Produce clear program runs which demonstrate that the algorithm addresses a variety of cases and/or input states.
- Incorporate bitwise and logical operations to address binary logic tasks within an algorithm.
- Building a program that uses class inheritance to demonstrate how re-use is handled in OOP.
- Create a project that contains at least one class intended to be used as a base class.
- Derive (sub-class) one or more classes from the base class.
- Use function chaining to avoid code duplication between base classes and derived classes.
- Differentiate between, and document in your lab, the distinct use of method overloading and method overriding.
- Incorporating basic abstract data types in programming projects
- Implement a fundamental abstract data type (ADT) such as a queue or stack in a programming lab.
- Use a previously written ADT from the programming language's application programmer interface (API) .
- Incorporate inheritance in a project that uses ADTs.
- Provide a client program that tests and demonstrates the correct behavior of the ADT.
- The proper use of deep and shallow copies in conjunction with inheritance and other advanced techniques learned in previous labs
- Create the proper set of methods within a class that enables an object to be cloned (copied deeply) correctly.
- Utilize inheritance to reinforce the segregation of data into base- and derived-level behavior.
- Utilize at least one other lab concept previously, such as binary logic or multi-dimensional arrays to further improve integration of intermediate concepts.
- Separate I/O and implementation in advanced programs.
- Building projects that use generics (A.K.A. templates)
- Demonstrate the difference in a lab project between deriving from a base class and specializing a generic.
- Practice writing a generic as well as using a language-defined generic (template) in a project.
- Use generics to exercise some aspect of ADTs such as specializing a generic ADT to make its behavior specific to an assigned project specification..
- Employ debugging techniques to solve problems that arise when designing with generic (template) classes.
- Exceptions and File I/O in Programming
- Write a class that has methods which use exception handling to report errors to the client.
- Write a test client that uses try/catch blocks to detect exceptions.
- Implement an algorithm or simulation that reads from and/or writes to files rather than the user screen
- Demonstrate various ways errors are handled and reported besides exceptions.
|11. Honors Description - No longer used. Integrated into main description section.|
|12. Types and/or Examples of Required Reading, Writing and Outside of Class Assignments - |
- Textbook assigned reading averaging 30 pages per week.
- Reading the supplied handouts and modules averaging 10 pages per week.
- Reading on-line resources as directed by instructor though links pertinent to programming.
- Reading library and reference material directed by instructor through course handouts.
- Writing technical prose documentation that supports and describes the programs that are submitted for grades.
- Writing specifications using prose to connect natural English language to the formulaic programming languages.
|13. Need/Justification - |
|This course is a required core course for the AS Degree in Computer Science. |