C++ Notes for Java Programmers
This document is intended for Java programmers who are learning C++
Corrections made to this document March 11 are highlighted in yellow. [ link to corrections]

1. Class members
   • data members are the equivalent of Java fields, i.e., variables and constants.
     • data members may belong to an object (same as Java instance data)
     • data members may belong to the class (same as Java class data).  class members must be declared with the keyword static (same as Java).
     • data members may be declared as public, private, or protected (same as Java, but there is no package visibility)
   • function members (or member functions) are the equivalent of Java methods.
     • function members may belong to an object (same as Java instance method)
     • function members may belong to the class (same as Java class method).  class members must be declared with the keyword static (same as Java).
     • function members may be declared as public, private, or protected (same as Java, but there is no package visibility)
     • global functions may also be declared.  These are not members of any class and they are called without reference to a class or an object name.  For example, int main(int argc, char* argv[]) is a global function in C++, and main is required in all C++ programs.  A C++ program may contain one or more global functions and it may contain zero or more class functions.  A C program is essentially a C++ program consisting of only global functions with no class definitions nor object instanciations.
        
2. Source files: C++ program and class files normally consist of 2 separate source files
   • Specification, or header, file:
     • begins with class name and left brace, but no visibility modifier, e.g.,
           class Thing {
     • ends with right brace followed by a semi-colon, e.g.,
           };
     • contains object data member declarations (same as Java instance data)
     • contains class, or static, data member declarations (same as Java class data)
     • contains object member function prototypes (same as Java instance method signature)
       but, function body code not included here, e.g.,
           int doYourThing(int x, int y);
     • contains class, or static, member function prototypes (same as Java class method signature)
       but, function body code not included here
           static int doClassThing(int x, int y);
     • Specification, or header, file names end in .h
   • Implementation file:
     • contains header and body code for all object member functions
       (though function body code may alternately be defined inline in a header file)
     • contains header and body code for class, or static, member functions
     • function name must be preceded by class name and double colon (scope operator), e.g.,
           int Thing::doYourThing(int x, int y)
           {
               // code for doYourThing function
           }
     • The keyword static must NOT be used in the implementation file, e.g.,
           int Thing::doClassThing(int x, int y)
           {
               // code for doClassThing function
           }
     • Implementation file names end in .cpp, .c++, or .C (most compilers or IDEs have a preferred extension, e.g., .NET and Visual C++ use the .cpp extension).  Be careful not to name C++ source files with the .c extension because most C++ compilers will assume that file contains C language code and will invoke a C compiler instead of compiling it in C++.
        
3. public, private, and protected keywords used within a class definition block (curly braces)
   • Syntax:   public:
     followed on succeeding lines by one or more members (data members or function members) that are to be declared as public.
   • Syntax:   private:
     followed on succeeding lines by one or more members (data members or function members) that are to be declared as private.
   • Syntax:   protected:
     followed on succeeding lines by one or more members (data members or function members) that are to be declared as protected (same meaning as in Java).
   • These declarators appear inside a class block and may not  precede a class or member name as in Java. They may be used more than once within a class block, e.g., you could use private: followed by several private member functions, then use public: followed by several public member functions, then use private: followed by declarations of the class's private data members
      
4. Object name variables and object pointer variables
   • An object may have a name in C++ and a variable that is declared as an object actually "is" the object rather than being a reference to the object as in Java.
   • An object may also be referred to via a pointer variable, which is very similar to a Java object reference variable.  But, pointers are declared using the * operator, e.g.,
         Thing *thingPtr;
     declares a pointer variable that may be used to refer to an object.  In this example thingPtr has not been initialized.
   • Unassigned pointer variables should be initialized to the value null (same meaning as in Java), e.g.,
         Thing *thingPtr = null;
   • Pointer variables may be tested for equality or inequality to null (same as in Java), e.g.
         if ( thingPtr != null )
      
5. Constructing objects (instance of a class) and using object variables or object pointer variables
   • C++ can construct an object that is stored in heap memory (same as in Java) or in the stack, i.e. local memory within a block.
   • An object may be declared without calling a constructor, but the object will be constructed automatically and this results in a variable that "is" the name of the object.  When no constructor is invoked C++ actually invokes the class's default constructor.  The object will be stored in local stack memory.  When the block exit is reached that object and its memory will be deleted.  Thus,
          Thing thingObject;
     constructs a Thing object on the stack whose name is thingObject.  This produces the same result as invoking the default constructor,
          Thing thingObject = Thing();
     The object name may be used directly to invoke member functions, such as
          thingObject.doYourThing(x, y);
   • An object may be declared using a call to a constructor.  The object will be stored in local stack memory. When the block exit is reached that object and its memory will be deleted.  Thus,
          Thing thingObject = Thing(param1, param2);
     constructs a Thing object on the stack whose name is thingObject.
   • A pointer to an object may be declared using a constructor and the new operator.  The object will be stored in heap memory and new returns a pointer value that points to the object's location in heap memory.  If a new object is constructed within some block, when the block exit is reached that object and its memory will be retained, though a local pointer variable that points to the object would be deleted if it were declared within the block.  Thus,
          Thing *thingPtr1 = new Thing;
          Thing *thingPtr2 = new Thing(param1, param2);
     both construct a Thing object in the heap.  These objects have no name, but the pointer variables, thingPtr1 and thingPtr2, contain the value that refers to the objects' locations (or addresses) in heap memory.
   • To use a pointer to an object to invoke a member function for that object you must dereference the pointer with the *  operator.  Thus, if thingPtr is a variable that points to a Thing object, then using *thingPtr means using the object itself.  C++ would require you to invoke a member function with the following syntax (parentheses are required because the "dot" or "member of" operator has higher precedence than the "star" or dereference operator),
         (*thingPtr).doYourThing(x, y);
     Since this is such a commonly used operation, there is a shortcut syntax,
         thingPtr->doYourThing(x, y);
   • An object may be deleted from heap memory using the delete operator, but delete may only be used with a pointer variable, not an object name variable, e.g.,
           delete thingPtr;
     Because an object name variable and its object are constructed in stack memory, they will be deleted when the local block is exited so invoking delete is unnecessary.
      
6. Passing objects or references to objects as function parameters
   • An object may be passed as a function parameter. The object will be passed by value and a copy of the object will be made on the stack for use within the function body block. Modifications to the object by statements within the function body only affect its copy, not the original argument object in the calling function. This differs from Java, and there is no equivalent to this form of parameter passing for objects in Java.  The function declaration (prototype) must declare the parameter as an object type. Statements in the function use the parameter name just as if it were an object constructed as a local variable, e.g.,
         void changeObject(Thing objectByReference)
         {
             objectByReference.setValueInTheObject(10);
         }
     A call to this function must pass an object "by value", e.g.,
         Thing myThingObject;          // constructs object
         changeObject(myThingObject);   // passes copy of the object
   • A reference to an object may be passed as a function parameter. The object will be passed by reference and use of the parameter name in the function body refers directly to the original object argument in the calling function. Modifications to the object by statements within the function body will affect the original argument object in the calling function (pass by reference also can also be used with primitive types such as int, double, and char). There is no exact equivalent to this form of parameter passing for objects in Java though it is similar to passing a reference variable in Java. However, in C++ special syntax is required. The function declaration (prototype) must declare the parameter as a reference type with the "address of" operator. Statements in the function use the parameter name just as if it were an object constructed as a local variable, e.g.,
         void changeObject(Thing& objectByReference)
         {
             objectByReference.setValueInTheObject(10);
         }
     A call to this function must pass an object "by reference", e.g.,
         Thing myThingObject;          // constructs object
         changeObject(&myThingObject); // passes address of the object
   • A pointer to an object may be passed as a function parameter. The pointer will be passed by value and a copy of the pointer will be made on the stack for use in the function body. Modifications to the pointer by statements within the function body have no effect on the pointer argument in the calling function, but modifications to the object referenced by the pointer made will affect the original argument object in the calling function. This is (almost) equivalent to Java's passing an object reference variable as a method parameter. However, the syntax is different. The function declaration (prototype) must declare the parameter as a pointer type with the "star" operator, and statements in the function body must use the "star" operator to dereference the pointer, e.g.,
         void changeObject(Thing* ptr)
         {
             ptr->setValueInTheObject(10);
             // i.e., same as, (*ptr).setValueInTheObject(10);
         }
     A call to this function must pass a pointer value, e.g.,
         Thing* myThingPtr = new Thing(); // constructs object and pointer
         changeObject(myThingPtr);        // passes pointer to the object
      
7. Returning objects or references to objects as function return values
   Note: a function return value is passed "by value", i.e., it is a copy of the return value defined within the function block.
   • An object may be returned as a function return value. The object will be returned by value and a copy of the object will be constructed and be placed on the stack for use in the calling function. This differs from Java, and there is no equivalent to this form of return values for objects in Java.  The function declaration (prototype) must declare the return value as an object type, and the value returned must be an object, e.g.,
         Thing returnAThingObject(void)
         {
             Thing myThing;  // construct an object on stack (local)
             return myThing; // return copy of local object
         }
   • A reference to an object may be returned as a function return value. The object will be returned by reference and a copy of the object reference value will be placed on the stack for use in the calling function. This is somewhat equivalent to returning a reference to an object in Java. The function declaration (prototype) must declare the return value as a reference type with the "address of" operator, and the value returned must be a reference to an object, e.g.,
         Thing& returnRefToANewThingObject(void)
         {
             Thing* myThing = new Thing(); // construct an object on heap
                                           // myThing is local var. (stack)
             return myThing;               // return copy of local ptr var.
         }
   • A pointer to an object may be returned as a function return value. A pointer to an object will be returned by value and a copy of the pointer will be placed on the stack for use in the calling function. This is somewhat equivalent to returning a reference to an object in Java. The function declaration (prototype) must declare the return value as a pointer type with the "star" operator and the value returned must be a pointer to an object, e.g.,
         Thing* returnPtrToANewThingObject(void)
         {
             Thing* myThing = new Thing(); // constructs object on heap
                                           // myThing is local var. (stack)
             return myThing;               // return copy of local ptr var.
         }
   • The difference between a return type that is a reference and one that is a pointer is the way in which the calling function may use the returned value. A reference type is somewhat like a constant, it may be used to reference the object, but it's value may not be changed. A pointer type may be used to reference the object and it may also be reassigned a new value.
   • WARNING: A pointer variable can become a dangling pointer, i.e., a pointer that refers to an object that has been deleted (no longer exists in stack or heap memory). Here are two examples of incorrect return of a pointer value,
         Thing* returnRefToAThingObject(void)
         {
             Thing myThing; // Constructed as local object on the stack.
             return &myThing; // The memory this pointer value references
                              // will be deallocated from the stack after
                              // the function's stack frame is deleted. At
                              // some later time that memory will probably
                              // be reused, and the address to which the
                              // pointer refers will be overwritten.  So,
                              // the calling function's pointer var. will
                              // no longer point to the myThing object, and
                              // it may point to memory that is not even a
                              // Thing object at all!
         }
     
         Thing* returnRefToAThingObject(void)
         {
             Thing* myThing = new Thing(); // constructed on the heap
             ...
             delete myThing; // delete the object
                             // (i.e., free the memory for this object)
             ...
             return myThing; // The memory this pointer value references
                             // has been deallocated from the heap. At
                             // some later time that memory will probably
                             // be reused, and the address to which the
                             // pointer refers will be overwritten.
         }
     
     
8. Arrays of objects and arrays of pointers to objects
   • WARNING: C++ arrays have no length member, so it is required that the program keep track of the number of array elements. This is especially important when using a pointer to an array that can be reassigned from an array with one length to point to another array with a different length.
   • WARNING: C++ does not throw an exception if array bounds are violated (no equivalent to Java's ArrayIndexOutOfBoundsException). If your program exceeds an array's bounds, it might abort (crash) with a segmentation fault error message. But, it's also possible that an array index error will not cause a program to abort and will allow it to continue but produce incorrect results. Or in some cases it could even continue and produce correct results, though the same program might abort if run again with different input data!
   • Here is a link to a C++ file that demonstrates the 4 different types of arrays.
   • C++ can construct a static array of objects (static in this context means non-dynamic, not static in the context of static class or static data members, as opposed to instances of a class or instance members).  E.g.,
         Thing thingArray[10];
     constructs an array with size = 10 Thing objects in local stack memory. The array variable is the array, and each element is a Thing object (not a reference to an array that contains references to Thing objects, as in Java).  So, the actual size of the array is 10 * (the size of a Thing object), not 10 * (the size of a Thing reference variable).  The default constructor is automatically invoked for all 10 objects.  There is no way to construct a static array of objects without invoking the default constructor (see arrays of pointers to objects, below). After this declaration,
         thingArray[0].doYourThing();
     is a valid member function call.
     A disadvantage of a static array, is that its identifier (name) is actually a constant, not a variable, thus it may not be reassigned to reference another array (see dynamic arrays, below).
   • C++ can construct a dynamic array of objects.  E.g.,
         Thing* thingArrayPtr;
     constructs a pointer in local stack memory that may be assigned to an array of Thing objects, but with no initial value assigned to the pointer.  Values that may be assigned to this pointer can be:
     the address of a static array (i.e., another pointer value), e.g.,
         thingArrayPtr = &thingArray[0]; // "address of" a static array
     or the pointer to a previously constructed array in (either in stack or heap memory), e.g.,
         thingArrayPtr = ptrToArrayOfThingObjects;
     or the pointer to a newly constructed array in heap memory, e.g.,
         thingArrayPtr = new Thing[10];
     Note (DANGER): This pointer could also be assigned to point to a single Thing object that is NOT the first object in an array!!!  In that case using thingArrayPtr[i] or *(thingArrayPtr+i) for i != 0 probably will not access an address that is the start of a Thing object and it could cause a program to crash.  Such an assignment effectively sets the pointer to reference an array of length 1.
     In the latter case the default constructor would automatically be invoked. Members of the array referenced by this pointer may be used to invoke member functions on each object as follows. Extra parentheses are required in the second example because the "member of" operator has higher precedence than the "star" or dereference operator and would be performed first without the outer parentheses.
         thingArrayPtr[i].doYourThing();
         (*(thingArrayPtr+i)).doYourThing();
         (thingArrayPtr+i)->doYourThing();  // alt. syntax for previous line
     The advantage of using a dynamic array is that its pointer may be reassigned to point to another array.
   • C++ can construct a static array of pointers to objects.  E.g.,
         Thing *thingPtrArray[10];
     constructs an array of size 10 in local stack memory. The array variable is the array, and each element is a pointer to a Thing object, but with no initial value.  Each array element could be assigned a value by a loop or a sequence of constructor call statements, such as,
         for ( int i = 0; i < 10; i++ )
             thingPtrArray[i] = new Thing();
     Members of the array may be used to invoke member functions on each object as follows (note, order of operations is: index the array, dereference its pointer value, then call the member function),
         (*thingPtrArray[i]).doYourThing();
         thingPtrArray[i]->doYourThing();
     The advantage of using an array of pointers to objects is each array element pointer value may be reassigned to point to another object (or to null). This is nearly the same as a Java array of objects except that the array variable may not be reassigned (it's not a reference variable as in Java).
   • C++ can construct a dynamic array of pointers to objects.  E.g. each of these,
         Thing* *thingPtrArray[];
         Thing* thingPtrArray*[];
         Thing* thingPtrArray**;
         Thing** thingPtrArrayPtr;
     constructs a pointer in local stack memory that may be assigned to an array of Thing objects, but the pointer has no initial value and no array has been constructed.  The value that may be assigned to this pointer can either be:
     the address of (i.e., a pointer value) a static array, e.g.,
         thingPtrArrayPtr = &thingPtrArray[0]; // the "address of" a static array
     or the pointer to a previously constructed array in (either in stack or heap memory), e.g.,
         thingPtrArrayPtr = ptrToArrayOfThingObjects;
     or the pointer to a newly constructed array of pointers in heap memory, e.g.,
         thingPtrArrayPtr = new *Thing[10]; // construct an array of 10 Thing pointers
     Each array element could be assigned a value by a loop or a sequence of constructor call statements, such as,
         for ( int i = 0; i < 10; i++ )
             (*thingPtrArrayPtr)[i] = new Thing();
     Members of the array may then be used to invoke member functions on each object as follows,
         (*(*thingPtrArray)[i]).doYourThing();
         (*thingPtrArray)[i]->doYourThing();
         (*thingPtrArrayPtr)[i].doYourThing();
         (*(*thingPtrArrayPtr+i)).doYourThing(); // alt. syntax for line above
         (*thingPtrArrayPtr+i)->doYourThing();   // alt. syntax for line above
         (**thingPtrArrayPtr).doYourThing();     // = (*thingPtrArrayPtr)[0]
     
     
9. Global and static variables
   • Any variable declared in a module (source file or compiled file) outside the scope of all blocks is a global variable in C++ and may be accessed in all blocks within that module (source file) as well as in any other module that is linked with the declaring module.
   • However, use of an undeclared external global variable results in the linker assuming its data type is int. C++ and C provide the extern statement for declaring a variable with a given data type that will be bound at linking time to an externally defined variable. Example,
         double price;        // declared in this file
         extern double price; // declared in some other file
     Note: an extern statement and correct statements that correctly refer to the external variable will always compile without error.  However, if during program linking time there is no other module that declares that variable, there will be a link error.
   • Any variable declared in a module (source file or compiled file) outside the scope of a block with the static modifier is global to all blocks within that module (source file), but is restricted to use in that file only and may not be used externally. Example,
         static double price; // only accessible in this file
     
     
10. static class members and static member functions
    • Any variable declared within a class with the static modifier is a member of the class and all objects (instances) of the class. The value assigned to it is common to all instances of the class. This is identical to the concept of a class variable in Java.
    • Any function declared within a class with the static modifier is a member of the class and all objects (instances) of the class. All other member functions of the class may invoke a static function, and any function in any class may also invoke a static function, but the syntax for the function call is className::functionName( <param list> ); (:: is the scope resolution operator). This is identical to the concept of a class method in Java.
    • static functions may only access static variables of a class (not member data variables). This is identical to the accessibility rule in Java.
    • Initializing a static class variable
      • A static class variable may be initialized inside a static class function.
      • A static class variable may be initialized outside of all function blocks in the class implementation file (.cpp file) with a static initializer statement. The required syntax is, <data_type> className::variableName = expression;
        Example, in the class specification file (header or .h file),
            class Scene {
               private:
               static Scene* theScenePtr; // all Scene objects have this member
               ...
            };
        in the class implementation file (.cpp file),
            Scene* Scene::theScenePtr = new Scene();
        This is somewhat similar to a static initializer block in Java, though the syntax is different.
      • This example constructs an object that is referenced by the static class member, and thus is accessible to all static class functions as well as all member functions of class instances (objects). This is often called a singleton object.
        
        
11. Example specification file: Thing.h

    #ifndef _THING_H_  // Use to avoid including the same file more than once.
    #define _THING_H_  // Note: #ifndef matches with #endif at the end of file.
                       // The first time this file name appears in a #include
                       // statement _THING_H_ is undefined, so #ifndef is true,
                       // and the C++ preprocessor includes all statements
                       // between the #ifndef and #endif. #define causes
                       // _THING_H_ to become defined. Thus, any subsequent
                       // executions of #include Thing.h will skip the statements
                       // between #ifndef and #endif because_THING_H_ will have
                       // been previously #define'd.

    #include <glut.h>

    class Thing
    {
        public:        // member function prototypes
                       // Normal coding style convention is that public function
                       // member declarations are placed at the start of a header
                       // file.
          Thing();         // default constructor
          Thing(int x);    // another constructor

          void setSize(int size);
          void setColor(float r, float g, float b);
          void draw();

        private:       // data member declarations
                       // Normal coding style convention is that data member
                       // declarations are placed at the end of a header file.
          int size:
          float color[3];
    };
    
    #endif _THING_H_
     
     

12. Example implementation file: Thing.cpp
    
    #include "Thing.h"

    
    Thing::Thing()
    {
          // code for default constructor
    }

    Thing::Thing(int x)
    {
          // code for another constructor
    }

    void Thing::setSize(int s)
    {
          // code for setSize
    }

    void Thing::setColor(float r, float g, float b)
    {
          // code for setColor
    }

    void Thing::draw()
    {
          // code for draw
    }
    
    

13. Use of static class members and static member functions with GLUT callback functions
    • The GLUT call back registration functions, such as, glutKeyboardFunc and glutDisplayFunc, require that callback functions have specific prototypes, such as, void keyboardCallback( unsigned char key, int x, int y ); or, void displayCallback( void ); Thus, an instance member function may not be used as a GLUT callback, because it has an extra "implicit parameter" (the "this" parameter). An instance member function with the prototype of keyboardCallback as shown here would actually pass 4 parameter values when called and the displayCallback as shown here would actually be pass 1 parameter value. Also, they would require an object of the class for which they are to be invoked and GLUT is not designed to use an object. static member functions, however, have no implicit parameter and may be designed to meet the GLUT prototype requirements. But, static functions cannot access instance data members (gotcha!).
    • Here's the solution (though admittedly somewhat of an awkward kludge):
      • In the class specification file (header or .h file) declare a static data member of the class, e.g.,
        class Scene {
          private:
          static Scene* theScenePtr; // all Scene objects have this member
          ...
        };
      • In the class implementation file (.cpp file), construct a singleton object and assign the static pointer member to reference it. This must be done outside all function blocks, e.g.,
        Scene* Scene::theScenePtr = new Scene();
      • In the class specification file declare a static function that meets the GLUT callback prototype requirements and an instance member function that will implement the callback by using access to instance variables, e.g.,
        static void draw( void ); // the GLUT display callback
        void sceneDraw( void ); // the Scene class instance function for the callback
      • In the class implementation file define the body of the instance member function. Then define the body of the static callback function so that it calls the instance member function. The static function uses only the static class variable theScenePtr, but that pointer references an instance of the class (the singleton object) and that instance can invoke the member instance function, e.g.,
        void Scene::sceneDraw( void )
        {
          // code for the instance function callback
          // may use instance and class variables
        }
        
        void Scene::draw( void )
        {
          // code for the static function callback (GLUT callback)
          theScenePtr->sceneDraw();
        }
      • To register the callback function, e.g., in the main function or an initialization function, use the name of the static callback function with the class name and scope resolution operator, e.g.,
        glutDisplayFunc( Scene::draw );
        glutKeyboardFunc( Scene::keyboardCallback );
      • C++ allows a function to be both declared and defined in a specification file as an inline function by following its declaration with the code for the body of the function. This is useful and it's more efficient for very short functions. When the compiler processes the source code for a call to an inline function, it uses the code directly (inline) without actually generating code for a function call and return. Thus, the shortcut for GLUT callback functions is:
        • In the class specification file:
          void sceneDraw( void );
          static void draw( void )
          {
            theScenePtr->sceneDraw();
          };
          // Note the semi-colon after closing function block brace
          // but NOT at the end of the function declaration line!
        • In the class implementation file:
          void Scene::sceneDraw( void )
          {
            // code for the instance function callback
          }
          
          // No code body for the static function is necessary.