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. Fortunately for us, Nachos uses a restricted subset of C++ that excludes many (but not all) of the hazardous features. This document should give you a basic understanding of the subset of C++ that Nachos uses. This should help you read the existing Nachos code. You will certainly need 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³².

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. This is bad programming style and should be avoided, but you might run into this in the existing Nachos code. It would be better to say:

    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. 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. You should avoid using them, but the existing Nachos code does use them so you need to recognize what they are.

    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()

The syntax for declaring a subclass is different in C++:

    class SubClass : public SuperClass {
      ...
    };

Input and Output

    char month [4];
    int year;
    strcpy (month, "Sep");  // Assigns a value to a string variable.
    year = 1998;
    printf ("The month is %s.  The year is %d.\n", month, year);

scanf is the input function from C. Its format is similar to printf. The first argument is a string often exclusively consisting of control sequences and whitespace. For each control sequence, there must be an argument that is the address of a variable of the appropriate type. The memory must be allocated already. sscanf is a variant of scanf with an additional first argument representing a string to parse instead of reading from standard input. sscanf is typically used to convert a string to an integer. For example, suppose s contains "1998",

    sscanf(s, "%d", &year);

The second (and preferred) way of doing input and output in C++ is using streams. Nachos uses printf rather than streams so I will not discuss them here.

(There is also an sprintf function that places the formatted output in a string and a fscanf function that reads input from a file, but these are not used in Nachos.)

Features Unique to C++ (and used in Nachos)

Constants and Macros

    #define MAX_SIZE 10

    #define min(a,b)  (((a) < (b)) ? (a) : (b))

    min (i, 4)

    (((i) < (4)) ? (i) : (4))

Compiler Directives

    #ifdef HOST_SPARC
    #include 
    #endif

Life Outside of a Class

If a data declaration is to be global and shared between multiple files, it is declared in one file and declared to be an extern in the other files. We all know that global variables are bad, so we shouldn't do this, however, there are some instances of this in Nachos. A function can also be declared this way, but it is better style to put the function declaration in a .h file and #include the .h file rather than extern the function declaration. Occasionally you will see something like:

    extern "C" {
      <a list of declarations>
    }

The main program for a C++ program is called main, but it is declared externally to any class. Its signature is:

void main (int argc, char **argv);

The first parameter is the number of arguments. The second parameter is an array of strings, each string containing one command-line argument.

Struct Types

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

struct Date someDate;

Typically, when declaring a type one gives the type a name. Oddly enough, creates a type named struct Date. To give it a simple type name, a slightly different syntax is required:

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

Date someDate;

You will find quite a few struct declarations in existing Nachos code. You should not create any new struct declarations. Instead you should create a class whose data members are like the struct fields.

Enumerated Types

enum PrimaryColor {
  red,
  yellow,
  blue
};

PrimaryColor c;
c = red;

Enumerated types are simulated in Java in the following way. The programmer declares a class (equivalent to the enumerated type) that provides a number of public constants (representing the enumerated values).

Union Types

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 = *anInt;

    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);

Memory Management

    delete list1;

    delete [] objArray;

    ~MyClass();

    sizeof (some_type)

    some_struct = (some_struct_type *) malloc (sizeof (some_struct_type));

free (some_struct);

    int *intArray;
    intArray = (int *) calloc (10, sizeof (int));

    char *someString;

    char *month;	    // Declare the string
    month = malloc (4);     // Allocate memory for string ending in null.
    strcpy (month, "Sep");  // Assigns a value to a string variable.

In a few places in Nachos, you will syntax like the following:

    char **stringArray;