Session 1: Introduction

This module: more object-oriented programming, in C++

Assuming that you are currently a reasonably skillful Java programmer, by the end of this course you should be able to

• read and modify substantial well-written C++ programs

• create classes and small programs in C++ that are correct, robust, clear and reusable

• use various object-oriented features, including genericity, inheritance and multiple inheritance

This session: non-OO programming in C++

This session introduces the philosophy of C++, and some simple non-OO programs.

We will touch on the following features of C++:

• Operator overloading
• Constants
• Initialization vs. assignment
• Parameter passing by value and reference
• Some library classes

All will be explored in greater detail later.

A bit of language history

1960

Algol 60: block structure, static typing

1967

Simula: Algol plus object-orientation (for simulation)

1970

C: statically typed procedural language with low-level features

1972

Smalltalk: object-orientation (for graphical interfaces), no static types

1985

C++: C plus object-oriented features and (later) genericity

1995

Java: C++ greatly simplified

Java design criteria

• object orientation

• (moderate) simplicity (fewer variant ways of doing things)

• robustness and security (type-safe, automatic memory allocation)

• architecture-neutral (fairly high level)

• syntax based on C++

C++ design criteria

• support a variety of programming styles, including object oriented (give the programmer more choices)

• powerful (give the programmer more control)

• enable efficient implementation (shift some implementation concerns to the programmer)

• extension of C (machine-level access)

  Often C features coexist with newer, cleaner versions.

A small C++ program

    #include <iostream>

    using namespace std;

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

• The first two lines make available names from the standard library, like cout.

• In C++ (like C), a function can exist outside of any class.

Accessing names from standard libraries

• In Java, classes are collected in packages, and accessed with import declarations.
• In C++, there are two (mostly) independent ways of controlling access to names:

  header files

  like iostream contain collections of related definitions (in this case for I/O streams). A typical program will begin with several #include lines.

  namespaces

  like std are collections of names, which must usually be qualified, unless there is a using command. Namespaces are a relatively recent addition to C++. Each source file will include the above using line, but we will not make any other use of namespaces.

Text output

    cout << "Hello world!\n";

• The iostream header defines three standard streams:

  cin

  standard input (cf. Java's System.in)

  cout

  standard output (cf. Java's System.out)

  cerr

  error output (cf. Java's System.err)

• The « operator, when applied to an output stream and a string, writes the string the stream.

• When applied to integers, it performs a left shift (as in Java): the « operator is overloaded.

Input and output

    int i;
    cout << "Type a number: ";
    cin >> i;
    cout << i << " times 3 is " << (i*3) << '\n';

• The » operator reads from an input stream.
• The « operator associates to the left, and returns the stream; the above is equivalent to

  (((cout << i) << " times 3 is ") << (i*3)) << '\n';
  

• It is also overloaded for int and char.
• The » operator is similar.

Strings

    #include <string>

The standard library provides a string type:

    string s = "fred";
    cout << s;
    cin >> s;    // reads a word

The + operator is overloaded on strings:

    s = s + " and bill";
    s = s + ',';

So are +=, ==, <, etc.

Unlike in Java, strings are modifiable:

    s.erase();   // makes s empty

Breaking the input into words

    #include <string>
    #include <iostream>
    using namespace std;

    int main() {
            string s;
            while (cin >> s)
                    cout << s << '\n';
            return 0;
    }

• The » operator on strings reads words.
• The stream returned by the » operator can be used in a conditional, to test if the read was successful.

Vectors

    #include <vector>

C++ has arrays, but we'll use vectors instead:

    vector<int> vi(5);  // vector of 5 ints
    vector<string> si;  // empty vector of strings

Vectors can be accessed just like arrays:

    vi[1] = x;
    vi[2] = vi[1] + 3;

Vectors can also be extended:

    si.push_back(s);

The current length of si is si.size()

Language notes

• string is a class

• vector is a template (generic) class

• C++ has pointers (corresponding to Java's references), but we won't use them till later:

      string s1 = "bill", s2;
  

  declares (and initializes) string objects, not pointers.

• assignments like

      s1 = s2;
  

  copy the objects.

Note: the syntax looks like Java, but the meaning is very different.

Initialization vs. assignment

Initialization of variables:

    string s1;
    string s2 = "bill";

Objects are always initialized; variables of primitive type aren't.

Assignment replaces an existing value:

    s1 = s2;

Initialization defines a new variable:

    string s3 = s2;

Passing parameters by value

Formal parameters are new variables, initialized from actual parameters.

        void f(int i) {
                i = i + 5;
        }

        void g() {
                int j = 3;
                f(j);   // no effect on j
        }

Parameter passing in Java

• In Java, all parameters are passed by value, even references.
• That is, the method is given a copy of the parameter, and any changes have no effect on the original.
• If the parameter is a reference, the copy naturally refers to the same object, so it is possible to change the object referred to, but not the original reference.

Limitations of value parameters

• We might wish to change an actual parameter from inside the function.
• The actual parameter might be large (e.g. an object) and therefore expensive to copy.
• A solution (Fortran, Pascal, C++, etc) is reference parameters.
• You can get a similar effect with value parameters and pointers (C, C++).

Passing parameters by reference

A reference formal parameter is another name (an alias) for the actual parameter.

    void f(int &i) {
            i = i + 5;
    }

    void g() {
            int j = 3;
            f(j);   // j is updated
    }

Note: There is no relationship to Java's references.

Passing large values by reference

Reference parameters are also used to avoid copying large values:

    int last(vector<int> &v) {
            return v[v.size() - 1];
    }

    void g() {
            vector<int> x(100);
            ...
            int n = last(x);   // don't copy x
    }

Constant parameters

We can indicate that the function doesn't change the parameter with the keyword const:

    int last(const vector<int> &v) {
            return v[v.size() - 1];
    }

    void g() {
            vector<int> x(100);
            ...
            int n = last(x);   // don't copy x
    }

This makes programs safer, and can help the compiler.

Constants

• The C++ keyword const introduces a constant:

      const int days_per_week = 7;
  

• Constants may (and must) be initialized, but cannot be assigned to.

• const parameters are a special case.

• C programmers: use const instead of #define, or definitions inside enum.

• A different use of const will be mentioned later.

References

• The C++ symbol & after a type defines a reference, which will be another name (or alias) for a piece of storage.

• Initialization defines the reference as an alias:

      int x;
      int &y = x;
  

• Assignment assigns to the original storage:

      y = 3;
  

  is the same as assigning to x.

An example function (from iostream)

istream& getline(istream& in, string &s) {
        s.erase();
        char c;
        while (in.get(c) && c != '\n')
                s += c;
        return in;
}

Note that

• get also uses pass-by-reference.

• There is no copying here: the argument in is returned by reference. (You can't return a local by reference.)

Prefixing lines with their lengths

#include <iostream>
#include <string>

using namespace std;

int main() {
        string s;
        while (getline(cin, s))
                cout << s.size() << '\t' << s << '\n';
        return 0;
}

Next session

• Classes in C++: very similar to Java, but with important differences.

• Reading:
  • Absolute C++ by Walter Savitch, Addison-Wesley Longman, Reading, Mass, 2002. Chapter 1, sections 6.2 and 7.1.

  • The C++ Programming Language (3rd edition) by Bjarne Stroustrup, Addison-Wesley Longman.
    • For this week: sections 2.1-3 (except 2.3.3), 3.2-6 (except 3.5.1), 3.7.1.

    • For next week: sections 2.5.3-4, 2.6, 10.2.1-6.