Introduction to C++ For Java Programmers

Contents

• Basic Terminology and C++ Functions
  • Simple Example C++ Program
  • Test Yourself #1
  • Another Example C++ Program (multiple functions and forward declarations)
• Compiling and Running a C++ Program
• C++ Types
  • primitive types
  • constants
  • arrays
    • Test Yourself #2
  • enumerations
  • structures
    • Test Yourself #3
  • unions
  • pointers
    • Test Yourself #4
    • Test Yourself #5
  • typedef
• Summary
• Answers to Self-Study Questions

In Java, we refer to the fields and methods of a class. In C++, we use the terms data members and member functions. Furthermore, in Java, every method must be inside some class. In contrast, a C++ program can also include free functions - functions that are not inside any class.

Every C++ program must include one free function named main. This is the function that executes when you run the program.

Here's a simple example C++ program:

# include <iostream>

int main() {
    cout << "Hello world!" << endl;
    return 0;
}

Things to note:

1. Function main should have return type int; you should return zero to indicate normal termination and any non-zero value to indicate that an error occurred (e.g., bad data was read, an attempt to open a non-existent file was made).

2. Function main is not required to have any parameters. However, if you intend your program to be run with command-line arguments, you should declare main as follows:
   int main( int numargs, char *args[])
   The first parameter is the number of command-line arguments, including the name of the executable itself (more about executable files below). The second parameter is an array of C-style strings (a C-style string is a sequence of characters, terminated with a special null character). Note that, like all formal parameters, you can use any names you want in place of "numargs" and "args". For historical reasons, some programmers use "argc" and "argv", but those are not very informative names.

3. To write to the standard output (usually the computer screen) use:
   cout << value-to-be-written
   Use endl (or '\n' or "\n") to write a newline.

4. The output operator (<<) is overloaded; you can use it to write a value of any of the primitive types. For example:

          int k = 2;
          double d = 4/5;
          char c = 'x';
          
          cout << k << endl;  // write an int
          cout << d << endl;  // write a double
          cout << c << endl;  // write a char
          

5. Note that the output operator can be chained (just like the assignment operator). For example, assuming that x, y, and z are declared variables, both of the following are legal C++:

          x = y = z = 0;
          cout << x << y << z;
          

   The assignment operator is right associative, so the chained assignment statement is evaluated right-to left (first z is set to 0, then y is set to 0, then x is set to 0). The output operator is left-associative, so the chained output statement is evaluated left-to-right (first x is output, then y, then z).

6. The line:

          # include <iostream>
          

   is similar to an import statement in Java (but note that the #include does not end with a semicolon). The #include is needed to provide the definitions of cout and endl, which are both used in the example program.

Write a C++ program that uses a loop to sum the numbers from 1 to 10 and prints the result like this:

    The sum is: xxx

solution

Another example program (multiple functions and forward declarations)

Usually, when you write a C++ program you will write more than just the main function. Here's an example of a program with two functions:

# include <iostream>

void print() {
    cout << "Hello world!" << endl;
}

int main() {
    print();
    return 0;
}

# include <iostream>

void print();

int main() {
    print();
    return 0;
}

void print() {
    cout << "Hello world!" << endl;
}

By convention, C++ source code is put in a file with the extension ".C" or ".cc" or ".cpp". The name itself can be whatever you want (there is no need to match a class name as in Java).

To create an executable file named a.out for the C++ program in foo.C, type:

g++ foo.C

g++ foo.C -o foo

To run your program, just type the name of the executable. For example, to run the executable named foo, just type foo at the prompt.

If your program is in more than one file, you can create an executable by compiling the whole program at once; e.g., if your program is in the two files, main.C and foo.C:

g++ main.C foo.C

g++ -c main.C

g++ main.o foo.o

The advantage of creating individual object files is that you don't need to recompile all files if you change just one.

C++ Types

C++ has a larger set of types than Java, including: primitive types, constants, arrays, enumerations, structures, unions, pointers, and classes. You can also define new type names using the typedef facility.

C++ classes will be discussed in a separate set of notes. The other types are discussed below.

Primitive (built-in) types
The primitive C++ types are essentially the same as the primitive Java types: int, char, bool, float, and double (note that C++ uses bool, not boolean). Some of these types can also be qualified as short, long, signed, or unsigned, but we won't go into that here.

Unfortunately, (to be consistent with C) C++ permits integers to be used as booleans (with zero meaning false and non-zero meaning true). This can lead to hard-to-find errors in your code like:

if (x = 0) ...

if (0 == x) ...

if (0 = x) ...

Constants
You can declare a variable of any of the primitive types to be a constant, by using the keyword const. For example:

  const int MAXSIZE = 100;
  const double PI = 3.14159;
  const char GEE = 'g';
  

Arrays
Unfortunately, C++ arrays lack many of the nice features of Java arrays:

• There is no length operation.
• There is no runtime check for an out-of-bounds index.
• It is not possible to assign from one array to another, and there is no arraycopy operation.
• It is not possible to change the size of an array dynamically.

Here's an example C++ array declaration:

  int A[10];
  

Because in C++ an array declaration includes its size, there is no need to call new as is done in Java. Declaring an array causes storage to be allocated.

Multi-dimensional arrays are defined using one pair of brackets and one size for each dimension as in Java; for example, the following declares M to be a 10-by-20 array of ints:

  int M[10][20];
  

As mentioned above, array parameters are declared without a size. This allows a function to be called with actual array parameters of different sizes. However, since there is no length operation, it is usually necessary to pass the size of the array as another parameter. For example:

  void f(int A[], int size)
  

Write a C++ function named ArrayEq that has 3 parameters: two arrays of integers, and their size (the same size for both arrays). The function should return true if and only if the arrays contain the same values in the same order.

solution

Enumerations
New types with a fixed (usually small) set of possible values can be defined using an enum declaration, which has the following form:

  enum type-name { list-of-values };
  

  enum Color { red, blue, yellow };
  

  Color col;
  col = blue;
  

Structures
A C++ structure is:

• a way to group logically related values together
• very similar to a C++ class

  struct Student {
      int id;
      bool isGrad;
  };                    // note that decl must end with a ;
  

  Student s1, s2;
  

  s1.id = 123;
  s2.id = s1.id + 1;
  

  struct Address {
      string city;
      int zip;
  };
  
  struct Student {
      int id;
      bool isGrad;
      Address addr;
  };
  

  Student s;
  s.addr.zip = 53706;
  

• The type of s is Student, so it makes sense to be able to follow s with ".addr" (since addr is a field of struct Student).
• The type of s.addr is Address, so it makes sense to be able to follow the expression "s.addr" with ".zip" (since zip is a field of struct Address).
• The type of s.addr.zip is int, so it makes sense to be able to assign 123 to s.addr.zip.

Assume that the declaration of Student given above has been made. Write a C++ function named NumGrads that has 2 parameters: an array of Students, and the size of the array. The function should return the number of students in the array who are grad students.

solution

Unions
A union declaration is similar to a struct declaration, but the fields of a union all share the same space; so really at any one time, you can think of a union as having just one "active" field. You should use a union when you want one variable to be able to have values of different types. For example, assume that only undergrads care about their GPA, and only grads can be RAs. In that case, we might use the following declarations:

  union Info {
      double GPA;
      bool   isRA;
  };
  
  struct Student {
      int id;
      bool isGrad;
      Info inf;
  };
  

It is important to realize that it is up to you as the programmer to keep track of which field of a union is currently valid. For example, if you write the following bad code:

  Info inf;
       
  inf.GPA = 3.7;
  if (inf.isRA) ...
  

Pointers
In Java, every array and class is really a pointer (and you need to use the "new" operator to allocate storage for the actual object). This is not true in C++ -- in C++ you must declare pointers explicitly, and it is possible to have a pointer to any type (including pointers to pointers!).

A pointer variable either contains an address or the special value NULL (note that it is upper-case in C++, not lower-case as in Java). Also, the value NULL is defined in stdlib.h, so you must #include <stdlib.h> in order to use NULL.

A valid non-NULL pointer can contain:

• the address of a variable
• the address of some dynamically allocated memory
• the address of a function

Here are some examples of how to declare pointers:

  int *p;     // p is a pointer to an int, currently uninitialized
  double *d;  // d is a pointer to a double, currently uninitialized
  int *q, x;  // q is a pointer to an int; x is just an int
  

There are several ways to give a pointer p a value:

1. Assign p the special value NULL:

     p = NULL;
     

2. Assign p the address of some variable, using the "address-of" operator: &. For example:

     p = &x;  // p points to x
     

3. Assign p to be the (first) address in a chunk of storage allocated dynamically using the "new" operator:

     p = new int;  // p points to newly allocated (uninitialized) memory
                   // note that the argument to the new operator is just the
   		// type of the storage to be allocated; there are no
   		// parentheses after the type as there would be in Java
     

4. Assign p to be the value currently stored in another pointer of the same type:

     int *p, *q;
     q = ...
     p = q;   // p and q both point to the same location
     

  x = 3;
  p = &x;      // p points to x
  cout << *p;  // the value in the location pointed to by p is output;
               // since p points to x, it is x's value, 3, that is output
  *p = 5;      // the value in the location pointed to by p is set to 5;
               // since p points to x, now x == 5
  

  int *p, *q;
  p = new int;
  q = new int;
  *p = 3;
  *q = 3;
  

In C++ there is no garbage collection (as there is in Java). This means that if you allocate memory from the heap (using new), that memory cannot be reused unless you deallocate it explicitly. Deallocation is done using the delete operator. For example:

  int *p = new int;   // p points to newly allocated memory
  ...
  delete p;           // the memory that was pointed to by p has been
                      // returned to free storage
  

Beware of the following:

1. Never dereference an uninitialized pointer:

         int *p; // p is an uninitialized pointer
         *p = 3; // bad!
         

2. Never dereference a NULL pointer:

         int *p = NULL;  // p is a NULL pointer
         *p = 3;         // bad!
         

3. Never dereference a deleted pointer:

         int *p = new int;
         delete p;
         *p = 5;              // bad!
         

4. Never dereference a dangling pointer (a pointer to a location that was pointed to by another pointer that has been deleted):

         int *p, *q;
         p = new int;
         q = p;           // p and q point to the same location
         delete q;        // now p is a dangling pointer
         *p = 3;          // bad!
         

5. If p is the only pointer that points to dynamically allocated memory, and you reassign p without first deleting it, that memory will be lost (your code will have a storage leak):

         int *p = new int;
         p = NULL;            // reassignment to p without freeing the storage
                              // it pointed to -- storage leak!
         

In the following code, identify each expression that includes a dereference of a pointer that may be uninitialized, may be NULL, may be deleted, or may be a dangling pointer. Also identify the uses of new that are potential storage leaks (i.e., the memory that is allocated may not be returned to free storage).

    int x, *p, *q;
    p = new int;
    cin >> x;
    if (x > 0) q = &x;
    *q = 3;
    q = p;
    p = new int;
    *p = 5;
    delete q;
    q = p;
    *q = 1;
    if (x == 0) delete q;
    (*p)++;
    

solution

A common use of pointers in C++ is to point to a dynamically allocated structure. If variable p points to a structure with a field named f, there are two ways to access that field:

1.  (*p).f    // *p is the structure itself; (*p).f is the f field 

2.  p->f      // this is just a shorthand for (*p).f 

  struct ListNode {
      int data;
      ListNode *next;  // pointer to the next node in the list
  };
  ListNode *head = NULL;  // head points to the list of nodes, initially empty
  int k;
  while (cin >> k) {

    // create a new list node containing the value read in
      ListNode *tmp = new ListNode; 
      tmp->data = k;

    // attach the new node to the front of the list
      tmp->next = head;
      head = tmp;
  }
  

1. Write a function named PrintList that has one parameter of type "pointer to ListNode", that points to the first node in a linked list of integers like the one created by the code fragment given above. PrintList should print (to cout) each value in the list, one per line.

2. Write a recursive function PrintReverse that has one parameter of type "pointer to ListNode", that points to the first node in a linked list of integers. PrintReverse should print (to cout) each value in the list in reverse order, one per line.

solution

Another common use of pointers in C++ is to point to a dynamically allocated array of values. The new operator can be used to allocate either a single object of a given type or an array of objects. For example, to allocate an array of integers of size 10, and to set variable p to point to the beginning of the array, use:

  int *p = new int [10];
  

  delete[] p;
  

  int *p = new int[10];  // p points to an array of 10 ints
  p[0] = 5;
  p[1] = 10;
  

  int *p = new int [10];
  *p = 5;         // same as p[0] = 5 above
  p++;            // changes p to point to the next item in the array
  *p = 10;        // same as p[1] = 10 above
  

Typedef
You can define a new type with the same range of values and the same operations as an existing type using typedef. For example:

  typedef double Dollars;
  Dollars hourlyWage = 10.50;
  

Summary

Solutions to Self-Study Questions

Test Yourself #1

Test Yourself #2

Test Yourself #3

Test Yourself #4

Test Yourself #5