C++ for Java Programmers

Besides the desire for backwards compatibility, C++ also maintained the philosophy that performance was critical. Many design decisions of C++ were done to allow programmers to get maximum performance out of their programs at the cost of making the code more difficult to understand and more error-prone.

Java was originally developed as a programming language for programs embedded in electronic devices, such as microwave ovens, CD players, telephones, etc. Since this was a new marketplace, there was not a lot of legacy code that the Java designers needed to maintain compatibility with. Also, since the performance of architectures has improved substantially and the computing demands of these devices were not great, performance of the language was much less of a concern, but productivity of the programmers was considered quite important.

The end result is that Java is much more programmer-friendly than C++. James Gosling, the creator of Java, quips that Java is C++ without the guns, knives, and clubs. We will try to avoid most of the dangerous weapons. This document should give you a basic understanding of the subset of C++ needed for your graphics work. This should help you read the C++ code that I provide. You might want to supplement this with a C++ text to get all the details. This document assumes that you already know Java.

Differences among Features Common to C++ and Java

Low-level Syntax

The boolean data type consisting of the values true and false is called bool in C++.

In C++, the data type char is an 8 bit value capable of representing an ASCII character. An instance of the char type can also be treated as an 8 bit integer. Therefore, you can do arithmetic on variables declared as char.

In C++, you can declare any of the numeric data types to be unsigned. This results in the lower bound for the type being 0. For example, int normally ranges from -2³¹ to 2³¹. An unsigned int ranges from 0 to 2³².

Unsigned types are often used for specifying color information in the form of RGB values for color lookup tables. Note: In Java, the sizes of the built-in types are defined by the language. For example, an int is always 32 bits long. In C++ this is not the case. Many of the numeric types are implementation-defined. In C++, = is the assignment operator just as in Java. In C++, = can also be used as an expression that returns the value being assigned. This allows the following convenient way of initializing two variables to the same value:

    a = b = 1;

C++ allows the condition controlling an if-statement or while-statement to be an integer expression. If the integer expression evaluates to 0, this is treated the same as the boolean value false. A non-zero value is treated the same as true. I prefer to write

    if (someInt != 0)

    if (someInt)

Combining these last two paragraphs shows one of the most common syntactic errors in C++ programs:

    int a = 0, b = 1;
    if (a = b) {
      ...
    }

In C++, you must declare the size of an array when you declare the array (actually, some compilers are more lenient---but you shouldn't depend on it). Memory is allocated for the array when the array is declared:

    int intArray[10];

In C++, it is possible to declare that a variable should be kept in a register. This is typically done to improve performance but is really unnecessary with modern compilers. Compilers are smart about recognizing which variables are used most often and keeping those values in registers. If not used extremely carefully, register declarations actually degrade performance. avoid using them for now, but for the curious, here's the syntax.

    register int i;

Classes

    class Pair {
      public:
        Pair (int x, int y);  // The constructor
        int getX();
        int getY();
        void setX (int newValue);
        void setY (int newValue);
    
      private:
        int x;
        int y;
    };

Also, note that C++ requires a semicolon at the end of a class declaration.

To make this class visible to another file, it must be included in that file:

    #include <pair.h>

The member definitions appear in the .cc file as mentioned earlier. Since they appear outside the class declaration, each definition needs to declare which class it is in using the class_name:: syntax:

    int Pair::getX() {
      return x;
    }

If you want to specify a particular member from a specific class when doing a function call, for example, you use the :: operator, as in

    SomeClass::someMethod()

This syntax is used toaccess static member functions of classes, and member functions of ancestor classes. The syntax for declaring a subclass is different in C++:

    class SubClass : public SuperClass {
      ...
    };

Input and Output

    int a;
    float x;
    cout << "Enter an int and a float separated by whitespace: "
    cin >> a >> x;
    cout << "You entered " << a << " and " << x << ", correct?" << endl;

    Enter an int and a float separated by whitespace: 3 7.1
    You entered 3 and 7.1, correct?

    const int MAX_SIZE 10

    #ifdef HOST_SPARC
    #include 
    #endif

    #include "Sphere3D.h"

    #ifndef SPHERE3D_H
    #define SPHERE3D_H
    // Your header file code goes here
    #endif SPHERE3D_H

int main (void); // or you could say int main();

struct Date {
  char *month;
  int date;
  int year;
};

struct Date someDate;

typedef struct {
  char *month;
  int date;
  int year;
} Date;

Date someDate;

enum RenderMode {
  wireFrame,
  solid,
  rayTrace
};

RenderMode rm;
rm = rayTrace;

union String_or_int {
  char *someString;
  int someInt;
};

struct S_or_i {
  bool containsInt;
  union String_or_int x;
};

    Date *someDate;         // Variable containing a pointer to a Date

    typedef Date *DatePtr;  // Type defining a pointer to a Date
    DatePtr date2;	    // Variable containing a pointer to a Date

    date2 = someDate;

    Date someDate;
    Date date2;

    date2 = someDate;

    some_pointer->some_field

    this->member

    int *IntPtr;
    int anInt;

    anInt = 1;
    intPtr = &anInt;

    int *intPtr;
    int anInt, int2;

    anInt = 1;
    intPtr = &anInt;
    int2 = *intPtr;

    void increment (int * anInt) {
        (*anInt)++;
    }

    int i = 0;
    increment (&i);

    void doSomething (const int * anInt) {...}

    int *intArray;
    // Assume the array has been allocated and given memory.
    doSomething (intArray);

    delete list1;

    delete [] objArray;

    ~MyClass();

    int *intArray;
    intArray = new int[10]
    // or
    Sphere *sphereArray = new Sphere[maxSize];