Lab 0: Practice with C++
CS 445 Computer Graphics, Fall 2014

Goals

1. Familiarize yourself with Codeblocks (or whatever IDE you prefer using)
2. Familiarize yourself with the main differences between Java and C++
3. Practice declaring arrays and objects, creating classes, passing parameters, pointers, etc

Note, this course is not a course in c++ and so it is not expected to give you a thorough and in-depth understanding of the language. Instead, we will focus primarily what you will need to do the assignments. However, you are encouraged to dig into the language as much as you can. Many references are provided below and there are many more available online. Your textbook was chosen because it provides many examples of how to use the language. These examples will be invaluable when you find yourself staring at code wondering why your syntax is not correct and what you are doing wrong. However, to get started, you may be better off reading through some of the simpler explanations in the other references below.

Resources

• See the book excerpts on the drive gorr-classes in the folder CS445Fa14\BooksReference\cplusplus
• See the Codeblocks and C++ links on the Links Page:
  • Your textbook: C++ Primer (5th Edition), by Stanley B. Lippman, Josée Lajoie, Barbara E. Moo
  • Course handouts on memory management.
  • Some additional detail on writing classes : C++ How to Program, 7/e, Deitel & Deitel (pdf): Chapter 9. This is an older version of Deitel & Deitel but the material is basically the same.
  • C++ Reference
  • C++ Language Tutorial
  • C++ tutorial

It isn't Java

Compilation process: simple and slightly more detail .

Since you know how to program in Java, much of C++ will be familiar. However, there are some crucial differences. Concepts that may be new include

• File structure - not everything is a class! Here is a simple structure without classes. For a more complex example with a class, we will look at the example you are to download in the "Hand-in" section.
• Memory management: Chapter 12 (Lippman) discusses memory management. Before reading this, please read the handout on memory management, comparing the stack (automatic storage) vs heap (dynamic storage). Note, both share memory
• Pointers and references - please carefully read section 2.3 (p. 50) of Lippman
• Dynamic Allocation (using "new") and Garbage collection (using "delete") - read handouts on memory management along with section 12.1.2 (p. 458) of Lippman. Other references include cplusplus and notes from Bob Meyers
• Structs

The following concepts should be familiar but will trip you up because of the slightly different syntax or because the way they are handled in regard to memory, pointers, reference passing:

• Passing parameters by reference (vs by value). See chapter 6 (p. 201) of Lippman for a general discussion of functions in c++. Section 6.2 (p. 208) is on Argument Passing, including pass by value, pass by reference, and array parameters.
• Strings (C++ strings vs c-style strings) See Section 3.2 (p. 84) of Lippman.
• Abstract Data Types, e.g. Vector class (p. 96) (note, how they are declared - not the same as Java!)
• Arrays: See Section 3.5 Arrays (p. 113) of Lippman
  • One dimensional
  • Multi-dimensional Arrays (Also see arrays).
  • Pointers to variables and pointers to arrays
• Interfaces (.h files)
• common libraries
• Classes and Objects. See cplusplus. We will also go over this in class.

Practice

• Begin by creating a new project of type "console application" in codeblocks. Build and run the program (main.cpp). Compare this to the basic structure of a C++ program shown in class.

• In main(), try the following:
  • declare, set, modify and print different types of variables (ints, floats, strings). Note as in Java strings are objects, not primitive types but there are subtle differences in how they are used. See p. 98
  • print out (cout) these variables
  • read in values for these variables (cin)

• In class, we will practice declaring and manipulating strings and pointers. Try this on your own. Does it make sense?

• In class, we will go over writing functions:

  • what is a function prototype?
  • writing a function without parameters
  • writing a with one or multiple primitive parameters
  • writing a with object/string parameters
  • writing a with one and multi-dimensional array parameters (See arrays)
  Try these on your own. Identify whether the variable is passed by reference or value - test this in your code by looking at the values before, in, and after the function call.

• In class, we will go over writing classes and creating objects. Also see p. 341, classses and Deitel & Deitel. We will see much more of c++ classes when we cover ray tracing.

To Hand In

Download and run this Codeblocks project which contains a class for storing RGB colors. Note the use of overloaded operators. Add code to test more of the RGBColor functions.

Once you are convinced you understand how RGBColor is implemented, add a second class to the project: Vector3D.h and Vector3D.cpp which stores 3 float values x, y, and z. (These files are already in the project folder and are partially implemented - you just need to add them to the project and finish the implementation. If you want to challenge yourself, start from scratch!) The following functions should be implemented:

Vector3D(void);                                 // default constructor
Vector3D(double a);                             // constructor
Vector3D(double _x, double _y, double _z);      // constructor
Vector3D(const Vector3D& v);                    // copy constructor
~Vector3D (void);                               // destructor
Vector3D& operator= (const Vector3D& rhs);      // assignment operator
Vector3D operator- (void) const;                // unary minus
double length(void);                            // length
double len_squared(void);                       // square of the length
Vector3D operator* (const double a) const;      // multiplication by a double on the right
Vector3D operator/ (const double a) const;      // division by a double
Vector3D operator+ (const Vector3D& v) const;   // addition
Vector3D& operator+= (const Vector3D& v);       // compound addition
Vector3D operator- (const Vector3D& v) const;   // subtraction
double operator* (const Vector3D& b) const;     // dot product
Vector3D operator^ (const Vector3D& v) const;   // cross product
void normalize(void);                           // convert vector to a unit vector
Vector3D& hat(void);                            // return a unit vector, and normalize the vector

Demonstrate your program in lab no later than the end of lab on Tues, Sept 2. Zip together the entire Codeblocks project (minus the obj and bin folders) and submit via WISE assignments. If you are not using Codeblocks, then zip together all of your source code.

Remember: Assignments are due by the end of lab on the due date. Assignments turned in after this are considered late. Assignments that are late by 1 week or less are penalized by 25%, and by 50% after that. (Note, if lab time runs out before you can demo your program, then be sure to submit your code to wise on time and demo as soon as possible. In this case you won't incur a late penalty)

---