Introduction to C++

Hello World
Simple Input, Output and Arithmetic
Built-In C++ Data Types
C++ Literal Constants
C++ Identifiers
Enumerations
C++ Operators
The if ... else Statement The ? : Operator
The switch Statement
Loops The while loop The do ... while loop The for loop
Functions in C++ Function Prototypes
C++ Arrays
C++ Structures
Pointers in C++ Pointers and Structures Pointers and Arrays The Null Pointer
Command-Line Arguments to Programs

Hello World


/* File:      hello.cpp
 *
 * Purpose:   Hello world application in ANSI C++.
 *
 * Version:   1.0
 *
 * Date:      August 28, 2000
 *
 * Author:    Colin Flanagan
 *
 */

#include <iostream>
using namespace std;

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

The above are source file contents:
- You should name the source file with extension .cpp (or .C) on Unix.
- The name of the source file for the above should be hello.cpp on Windows and Hello.C on Unix (but C++ does not enforce this).
cout is the standard output stream, usually connected to a terminal window (MS-DOS prompt under Windows).
<< is the put-to operator.
endl is a stream manipulator. It means "send a newline character to the output stream and flush it if it is buffered" (the cout stream normally is buffered).
Note the #include <iostream> and using namespace std directives. These are needed so that C++ recognises cout, the put-to operator and the endl stream manipulator.
1. #include <iostream> is an include directive. It instructs the C++ preprocessor to read the contents of a file called iostream and include it in the compilation of this program. iostream is a header file. It is part of ANSI standard C++ and includes declarations for cout, << and endl, telling the compiler how these may legally be used in a program.
2. cout, << and endl are names defined as part of a C++ namespace. The using namespace std directive tells the compiler to assume that names are part of this namespace unless otherwise instructed.
Every standard C++ program includes exactly one function called main. A C++ program starts executing by calling main.
- Note: Windows and MFC (Microsoft Foundation Classes) programs do not start with main.
Note that the program returns a value, of type int (simple signed integer), to the operating system. Value 0 means that the program completed correctly, any other value indicates some sort of failure.
Comments in C++ are enclosed between the delimiters /* and */. There is also a comment marker //, but it is not used in the above.
The body of a C++ function is made up from Statements, which are terminated by semicolons. There are two statements in the above program:
1. cout << "Hello World" << endl;
2. return 0;
The body of a C++ function is delimited by the markers { and }.
C++ is very largely a free-format language, i.e., the layout of the program source file makes no difference as far as the compiler is concerned.
- N.B., there is one notable exception to the free-format rule: you cannot have more than one #include directive on a line. In fact, most compilers will ignore everything following the name of the included file on a line with an #include directive.
It is recommended that you choose a formatting convention (like the above) and stick to it.
Notes for C programmers:
1. main should return a value. C-style void main is not good C++.
2. main() means that main does not expect any arguments. It is equivalent to C-style main(void).
3. Note that the include file iostream does not have a .h extension (ANSI C++).
4. The using namespace std directive is also new with ANSI C++.
Under Visual C++:
1. Create a new project, type Win32 Console Application. Name the project HelloWorld.
2. When Visual C++ asks you what type of Console Application you want, make sure the Empty Project radio button is checked.
3. Now add a C++ Source file to the project called hello.cpp and paste the code shown above into it.

Back to Contents

Simple Input, Output and Arithmetic


// File:      quadratic.cpp                            
//                                                     
// Purpose:   Finds the roots of the quadratic equation
//            ax^2 + bx + c = 0, using the formula     
//            x = (-b +- sqrt( b^2 - 4ac )) / 2a       
//
// Version:   1.1
//
// Date:      October 6, 2000
//
// Author:    Colin Flanagan
//
//

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

int main() 
{
    double a, b, c;
                  
    cout << "Please enter values for a, b and c --> ";
    cin >> a >> b >> c;

    double x = b * b - 4.0 * a * c;

    if ( x < 0 )
        cout << "Roots are imaginary";
    else {
        double sq = sqrt( x );
        cout << "Root 1 = "   << (-b + sq) / (2.0 * a);
        cout << ", Root 2 = " << (-b - sq) / (2.0 * a);
    }
    cout << endl;
    return 0;
}

Note the variables a, b, c, and sq. They are all of type double, a predefined C++ data type used to represent double precision floating-point values.
All variables in a C++ program must be declared before use.
- This is the purpose of the statement double a, b, c; near the top of main.
- It is also the purpose of the code double x = b * b - 4.0 * a * c;.
  Note that this statement both declares x to be a double variable and also initialises it to the value of the expression b * b - 4.0 * a * c.
- Similarly, the code double sq = sqrt( x ); both declares and initialises sq.
>> is the get-from operator. It instructs C++ to read values from the input stream cin. This is usually connected to the keyboard.
- C++ will read three double values from cin because the data type of the variables into which data is to be read is double. The >> operator understands C++ data types.
sqrt is a C++ library function. It computes the positive square root of its (positive) argument. The include directive #include <cmath> is needed at the start of the code to tell C++ about the sqrt function, how to use it and how to find it in the standard library. <cmath> contains definitions for all the standard mathematical functions.
The code section:
if ( sq < 0 ) cout << "Roots are imaginary"; else { cout << "Root 1 = " << (-b + sq) / (2.0 * a); cout << ", Root 2 = " << (-b - sq) / (2.0 * a); }
illustrates a basic C++ decision statement. If the condition evaluates as true, that section of the code delimited by the if is executed (shown in red). If the condition evaluates as false, that section of the code delimited by the else code is executed (shown in green).
- Note that the if action consists of a single statement, so doesn't require brace delimiters. The else action, on the other hand, consists of multiple statements, so has to be grouped within a pair of braces.
- In general, in C++, where a single statement is allowed, it is legal to insert a block of statements. Blocks consists of multiple statements delimited by braces ({ & }).
Arithmetic expressions in C++ are fairly similar to those in languages like Pascal and Fortran. C++ differs mainly in having many more operators than other languages (it inherits its large number of operators from its parent, C). In the above program simple operators are used, with straightforward meanings:

* multiply / divide
+ add - subtract/negate
Parentheses are used for grouping and to enforce precedence.
Note the use of the new "//" comment delimiter. A comment introduced by "//" continues to the end of the current line. The "//" comment delimiter is useful for short comments. If a multi-line comment is needed, it is necessary to repeat the delimiter at the start of each line. The decision about which sort of comment delimiter to use is largely a matter of taste.
Notes for C programmers:
1. In C all variables in a function must be declared at the start of that function. In C++ variable declarations are statements, they can appear anywhere a statement is valid. It is considered good C++ style to declare a variable as close as possible to its first use. Hence the declaration of variable sq in the middle of the function. This is good C++ but is illegal in C.
2. The << and >> operators are the C++ alternative to printf and scanf. They are a considerable improvement over the old stdio.h functions because they are type-safe (they automatically match arguments at compile-time, instead of interpreting a format string at run-time).
3. Note the new form of comment, "//".

Back to Contents

Built-In C++ Data Types

Integral Types
Type	What it is	Typical size (bits)
`bool`	Boolean truth value	8
`int`	standard-width signed integer	32
`unsigned`	standard-width unsigned integer	32
`long`	wide-width signed integer	32-64
`unsigned long`	wide-width unsigned integer	32-64
`short`	narrow-width signed integer	16-32
`unsigned short`	narrow-width unsigned integer	16-32
`char`	character	8
`unsigned char`	unsigned character	8
`signed char`	signed character	8

These Integral Types are so-called because they all behave like integers when they appear in an arithmetic expression.
The width of an int is the "natural" width for an integer on a given machine. Hence, it can vary. It is typically 32 bits on current microprocessors, but is 64 bits on 64-bit machines.
The only guarantee that C++ makes about a long is that it is no shorter than an int.
The only guarantee that C++ makes about a short is that it is no longer than an int.

Notes for C programmers:

The bool type is new. C++ programmers don't have to resort to typedefs or #define to create a Boolean data type, it is built-in.
The new keywords true and false are the values it is legal to store in a variable of type bool.
A bool value of true behaves like 1 in an arithmetic expression, a bool value of false behaves like 0.

It is legal to assign an integral value to a variable of type bool. Any non-zero value results in true being assigned to the variable, a zero value results in the assignment of false.

The behaviour of the `bool` type
/* * File: bool.cpp * * Purpose: Illustrates the behaviour of the C++ bool type in * integral arithmetic expressions, and how integral * expressions may be converted to bool values. * * Version: 1.0 * * Date: September 20, 2000 * * Author: Colin Flanagan * */ #include <iostream> #include <iomanip> // Needed for formatting flag "boolalpha" using namespace std; int main() { bool b; cout << boolalpha; // Force bool values to be output in a // text-format (instead of 0 and 1). The // actual text output depends on the // current locale. In the standard locale // "true" and "false" are used. b = true; cout << "The value of b is " << b << endl; cout << "The value of 1 + b is " << 1 + b << endl; b = false; cout << "The value of b is now " << b << endl; cout << "The value of 1 + b is " << 1 + b << endl; b = 245; cout << "The value of b is now " << b << endl; b = 0; cout << "The value of b is now " << b << endl; return 0; }

The behaviour of the bool type


/*
 * File:      bool.cpp
 *
 * Purpose:   Illustrates the behaviour of the C++ bool type in
 *            integral arithmetic expressions, and how integral
 *            expressions may be converted to bool values. 
 *
 * Version:   1.0
 *
 * Date:      September 20, 2000
 *
 * Author:    Colin Flanagan
 *
 */
#include <iostream>
#include <iomanip>      // Needed for formatting flag "boolalpha"
using namespace std;

int main()
{
    bool b;

    cout << boolalpha;  // Force bool values to be output in a
                        // text-format (instead of 0 and 1). The
			// actual text output depends on the
			// current locale. In the standard locale
			// "true" and "false" are used.
    b = true;
    cout << "The value of b is     " << b << endl;
    cout << "The value of 1 + b is " << 1 + b << endl;

    b = false;
    cout << "The value of b is now " << b << endl;
    cout << "The value of 1 + b is " << 1 + b << endl;

    b = 245;
    cout << "The value of b is now " << b << endl;

    b = 0;
    cout << "The value of b is now " << b << endl;
    
    return 0;
}

Back to Contents

Floating-Point Types
Type	What it is	Typical size (bits)
`float`	single-precision floating-point value	32
`double`	double-precision floating-point value	64
`unsigned`	extended-precision floating-point value	80

Single-precision floating-point is the shortest floating-point type supported by the hardware. This is usually IEEE-754 single-precision : 32-bits, 23-bit significand (normalised, with a hidden-bit), 8-bit exponent, 1 sign-bit.
The only guarantee that C++ makes about double-precision floating-point is that it is no shorter than single-precision. However, it is usually IEEE 754 double-precision (64-bits).
Again, the only guarantee that C++ makes about extended-precision floating-point is that it is no shorter than double-precision. However, it is usually IEEE 754 80-bit.

Back to Contents

Declaring the Built-In Types
/* * File: datatypes.cpp * * Purpose: Illustrates how to declare all the essential C++ * built-in data types, and prints out a table of * their sizes (in terms of bits of memory needed for * each). * * Version: 1.0 * * Date: September 20, 2000 * * Author: Colin Flanagan * / #include <iostream> #include <climits> // needed for value of constant CHAR_BIT using namespace std; int main() { bool b; // boolean, values "true" or "false". int i; // standard width signed integer unsigned ui; // standard width natural number long l; // wide width signed integer unsigned long ul; // wide width unsigned integer short s; // narrow width signed integer unsigned short us; // narrow width unsigned integer char c; // character (signed or unsigned) unsigned char uc; // unsigned character signed char sc; // signed character float f; // single-precision floating-point double d; // double-precision floating-point long double ld; // extended-precision floating-point cout << " Data Type \| Size in Bits\n"; cout << "----------------+-------------\n"; cout << " bool \| " << sizeof(b) CHAR_BIT << '\n'; cout << " int \| " << sizeof(i) * CHAR_BIT << '\n'; cout << " unsigned int \| " << sizeof(ui) * CHAR_BIT << '\n'; cout << " long \| " << sizeof(l) * CHAR_BIT << '\n'; cout << " unsigned long \| " << sizeof(ul) * CHAR_BIT << '\n'; cout << " short \| " << sizeof(s) * CHAR_BIT << '\n'; cout << " unsigned short \| " << sizeof(us) * CHAR_BIT << '\n'; cout << " char \| " << sizeof(c) * CHAR_BIT << '\n'; cout << " unsigned char \| " << sizeof(uc) * CHAR_BIT << '\n'; cout << " signed char \| " << sizeof(sc) * CHAR_BIT << '\n'; cout << " float \| " << sizeof(f) * CHAR_BIT << '\n'; cout << " double \| " << sizeof(d) * CHAR_BIT << '\n'; cout << " long double \| " << sizeof(ld) * CHAR_BIT << endl; return 0; }

Declaring the Built-In Types


/*
 * File:      datatypes.cpp                            
 *
 * Purpose:   Illustrates how to declare all the essential C++
 *            built-in data types, and prints out a table of
 *            their sizes (in terms of bits of memory needed for 
 *            each).
 *
 * Version:   1.0
 *
 * Date:      September 20, 2000
 *
 * Author:    Colin Flanagan
 *
 */
#include <iostream>
#include <climits>     // needed for value of constant CHAR_BIT
using namespace std;

int main()
{
    bool           b;  // boolean, values "true" or "false".
    int            i;  // standard width signed integer
    unsigned       ui; // standard width natural number
    long           l;  // wide width signed integer
    unsigned long  ul; // wide width unsigned integer
    short          s;  // narrow width signed integer
    unsigned short us; // narrow width unsigned integer
    char           c;  // character (signed or unsigned)
    unsigned char  uc; // unsigned character
    signed char    sc; // signed character

    float          f;  // single-precision floating-point
    double         d;  // double-precision floating-point
    long double    ld; // extended-precision floating-point

    cout << "   Data Type    | Size in Bits\n";
    cout << "----------------+-------------\n";
    cout << " bool           |   " << sizeof(b)  * CHAR_BIT << '\n';
    cout << " int            |   " << sizeof(i)  * CHAR_BIT << '\n';
    cout << " unsigned int   |   " << sizeof(ui) * CHAR_BIT << '\n';
    cout << " long           |   " << sizeof(l)  * CHAR_BIT << '\n';
    cout << " unsigned long  |   " << sizeof(ul) * CHAR_BIT << '\n';
    cout << " short          |   " << sizeof(s)  * CHAR_BIT << '\n';
    cout << " unsigned short |   " << sizeof(us) * CHAR_BIT << '\n';
    cout << " char           |   " << sizeof(c)  * CHAR_BIT << '\n';
    cout << " unsigned char  |   " << sizeof(uc) * CHAR_BIT << '\n';
    cout << " signed char    |   " << sizeof(sc) * CHAR_BIT << '\n';
    cout << " float          |   " << sizeof(f)  * CHAR_BIT << '\n';
    cout << " double         |   " << sizeof(d)  * CHAR_BIT << '\n';
    cout << " long double    |   " << sizeof(ld) * CHAR_BIT << endl;
    return 0;
}

CHAR_BIT is a constant declared in header file climits. It defines the number of bits used by a char in a C++ implementation.
sizeof() is a C++ operator which returns the amount of storage occupied by a variable (or data type), in terms of the number of chars required to occupy the same storage area.
\n is an Escape Character. It represents newline, i.e., an instruction to advance the output print position to the start of the next line.

Back to Contents

C++ Literal Constants

Boolean Literals

true, false

Character Literals

A character literal is a character enclosed in single quotes, e.g., 'a', 'b'. The single quotes are character literal delimiters, they are not part of the literal. To get a character literal containing a single quote, use '\''. Here the quote has been Escaped using the Escape Character backslash (\). To get a character literal containing a backslash, use '\\'. Note also the special escaped sequences '\n' (newline) and '\t' (tab).

String Literals

A string literal is a sequence of zero or more characters (including escape sequences) enclosed in double quotes, e.g., "This is a string literal\n". The double quotes are string literal delimiters, they are not themselves part of the literal. To get a double quote inside a string literal, it is necessary to escape it, e.g., "\"".

Integer Literals

Decimal: 256, -3
Hexadecimal: 0xF3E, 0Xffff3bc9
Octal: 0777, 056
Unsigned Decimal: 3U, 3u, 65535U
Long Decimal: 3L, 3l (use uppercase L, as lowercase letter l looks too much like digit 1).
Unsigned Long Decimal: 3UL, 3LU. Lowercase lu and ul are legal, but potentially confusing.

Floating-Point Literals

1.23, .23, 0.23, 1., 1.0, 1.23e10, 1.23E10, 1.23e-15 (all floating-point literals are type double by default).
1.23f, 1.23F, 1.23e10F, 1.23E10f (use the f or F suffixes to force the floating-point literal to be of type float).

Example Literals
/* * File: literals.cpp * * Purpose: Illustration of C++ literal constants * * Version: 1.0 * * Date: September 20, 2000 * * Author: Colin Flanagan * */ #include <iostream> using namespace std; int main() { bool truthvalue = true; char c = 'c', newline = '\n', tab = '\t'; int i = 123; unsigned ui = 4294967295U; // This is too big to represent as a 32-bit // signed value. int i2 = 4294967295U; // Compiler accepts this, performs the // initialisation, but the value in i2 is // interpreted as signed, hence -ve (as the // MSB of the unsigned literal is set). int hi = 0xffffffff; // This is the same value as ui, but represented // as a hex literal. Note that we are putting // this in a signed integer, so the result is // -ve (as the MSB of the literal is set). int hui = 0xffffffff; // Again, same value as ui. int oi = 0777; // 0777 is an octal literal. long l = 123L; // 123 is a long literal. unsigned long ul = 123UL; // 123 is now an unsigned long literal. float f = 1.2f; double d = -1.2e300; cout << " truthvalue = " << truthvalue << "\n c = " << c << "\n newline (effect appears between quotes) = \"" << newline << '"' << "\n tab (effect appears between quotes) = \"" << tab << '"' << "\n i = " << i << "\n ui = " << ui << "\n i2 = " << i2 << "\n hi = " << hi << "\n hui = " << hui << "\n oi = " << oi << "\n l = " << l << "\n ul = " << ul << "\n d = " << d << "\n f = " << f << endl; cout << " size of bool literal (in chars): " << sizeof(true) << "\n size of char literal \'c\': " << sizeof('c') << "\n size of int literal 123: " << sizeof(123) << "\n size of hex literal 0xffffffff: " << sizeof(0xffffffff) << "\n size of octal literal 0777: " << sizeof(0777) << "\n size of long literal 123L: " << sizeof(123L) << "\n size of unsigned long literal 123UL: " << sizeof(123UL) << "\n size of unsigned long literal 123ul: " << sizeof(123ul) << "\n size of unsigned long literal 123lu: " << sizeof(123lu) << "\n size of unsigned long literal 123LU: " << sizeof(123LU) << endl; return 0; }

Example Literals


/*
 * File:      literals.cpp                            
 *
 * Purpose:   Illustration of C++ literal constants
 *
 * Version:   1.0
 *
 * Date:      September 20, 2000
 *
 * Author:    Colin Flanagan
 *
 */
#include <iostream>
using namespace std;

int main()
{
    bool truthvalue = true;
    char c = 'c', newline = '\n', tab = '\t';
    int i = 123;
    unsigned ui = 4294967295U; // This is too big to represent as a 32-bit
                               // signed value.
    int i2 = 4294967295U;      // Compiler accepts this, performs the 
                               // initialisation, but the value in i2 is 
			       // interpreted as signed, hence -ve (as the
			       // MSB of the unsigned literal is set).
    int hi = 0xffffffff;       // This is the same value as ui, but represented
                               // as a hex literal. Note that we are putting 
			       // this in a signed integer, so the result is
			       // -ve (as the MSB of the literal is set).
    int hui = 0xffffffff;      // Again, same value as ui.
    int oi = 0777;             // 0777 is an octal literal.
    long l = 123L;             // 123 is a long literal.
    unsigned long ul = 123UL;  // 123 is now an unsigned long literal.
    float f = 1.2f;
    double d = -1.2e300;

    cout << " truthvalue = " << truthvalue 
         << "\n c = " << c
	 << "\n newline (effect appears between quotes) = \"" << newline << '"'
	 << "\n tab (effect appears between quotes) = \"" << tab << '"'
	 << "\n i = " << i
	 << "\n ui = " << ui
	 << "\n i2 = " << i2
	 << "\n hi = " << hi
	 << "\n hui = " << hui
	 << "\n oi = " << oi
	 << "\n l = " << l 
	 << "\n ul = " << ul 
	 << "\n d = " << d 
	 << "\n f = " << f << endl;


    cout << " size of bool literal (in chars): " << sizeof(true)
         << "\n size of char literal \'c\': " << sizeof('c')
         << "\n size of int literal 123: " << sizeof(123)
         << "\n size of hex literal 0xffffffff: " << sizeof(0xffffffff)
         << "\n size of octal literal 0777: " << sizeof(0777)
         << "\n size of long literal 123L: " << sizeof(123L)
         << "\n size of unsigned long literal 123UL: " << sizeof(123UL)
         << "\n size of unsigned long literal 123ul: " << sizeof(123ul)
         << "\n size of unsigned long literal 123lu: " << sizeof(123lu) 
         << "\n size of unsigned long literal 123LU: " << sizeof(123LU) << endl;

    return 0;
}

Back to Contents

C++ Identifiers

C++ uses Identifiers to name variables and other user-defined elements of a program.
A C++ Identifier is a sequence of letters, digits, and underscore characters (_).
An identifier may not start with a digit. Use a letter.
C++ imposes no limits on the length of an identifier, however, the linker may impose some (implementation-defined) limits. Extensions (e.g., allowing the character $ in an identifier) yield nonportable code.
A C++ keyword cannot be used as an identifier (i.e., no user-defined variable, class, typedef or structure name can be the same as a keyword).
C++ is case-sensitive. Hence Hello, HELLO and HeLLo are all distinct identifiers.
Although it is legal C++, don't start an identifier with an underscore. Such names are typically reserved by the compiler, linker or run-time environment, so can cause portability problems.
The following are legal C++ variable names: hello this_is_a_long_name VALUE Value
The following are not: 0123 a-fool $sys class pay.due

Back to Contents

Enumerations

A C++ Enumeration is a data-type. It differs from the built-in types in that it consists of a set of values specified by the programmer. Once defined, an enumeration is used very much like an integer type.

Enumerations are normally used when we need some constants with meaningful names in a program, but we don't care very much about their values. For example, we can write


enum months { Jan, Feb, Mar, April, May, June,
              July, Aug, Sept, Oct, Nov, Dec
	    } thismonth, lastmonth;

Given this declaration in a program, we can use:

The enumeration type months. We can declare some more variables of this type: months holiday;
The enumeration constants Jan ... Dec.
The variables thismonth and lastmonth. These variables can be assigned values of type months.

The first constant in an enumeration has integer value 0, the next 1, etc. You can change this if you want to force the elements of an enumeration to have specific values.


enum revolutions { AMERICAN = 1776, FRENCH = 1789,
		   RUSSIAN = 1917,  CHINESE = 1948 };

The constant AMERICAN of type revolutions has value 1776, etc.

Back to Contents

C++ Operators

C++ has a large set of operators. Operators are used in Expressions along with literals and variables, to generate values.

The C++ operators include:

Comparison and Logical Operators
Arithmetic Operators
Bitwise Operators
Assignment Operators

Back to Contents

Comparison and Logical Operators

Comparison Operators
Operator	Purpose	Example
expr₁ `==` expr₂	Test if expr₁ equal to expr₂	`a == 5`
expr₁ != expr₂	Test if expr₁ not equal to expr₂	`a != 5`
expr₁ `<` expr₂	Test if expr₁ less than expr₂	`a < 5`
expr₁ `<=` expr₂	Test if expr₁ less than or equal to expr₂	`a <= 5`
expr₁ `>` expr₂	Test if expr₁ greater than expr₂	`a > 5`
expr₁ `>=` expr₂	Test if expr₁ greater than or equal to expr₂	`a >= 5`

expr represents any C++ expression, which can include a variable, a literal or a combination of these.
The result of applying a comparison operator to two operands is a bool value, i.e., true or false.
Note the form of the equality comparison operator, "==". The operator "=" is the Assignment Operator.

Logical Operators
Operator	Purpose	Example
expr₁ `&&` expr₂	Perform Boolean (logical) AND of expr₁ and expr₂	`a >= 5 && a < 10`
expr₁ `\|\|` expr₂	Perform Boolean (logical) OR of expr₁ and expr₂	`a <= 5 \|\| a > 10`
`!` expr	Perform Boolean (logical) NOT on expr	`!(a <= 5 \|\| a > 10)`

&& and || are Short-Circuiting operators. If the result of evaluating the operand on their left is sufficient to determine the truth value of the entire expression, the operand on the right is not evaluated at all.

Back to Contents

Arithmetic Operators

Operator	Purpose	Example
expr₁ `` expr₂*	Multiply expr₁ by expr₂	`a * 10`
expr₁ `/` expr₂	Divide expr₁ by expr₂	`a / 10`
expr₁ `%` expr₂	Find the remainder when expr₁ is divided by expr₂	`30 % 7`
expr₁ `+` expr₂	Add expr₂ to expr₁	`a + 7`
expr₁ `-` expr₂	Subtract expr₂ from expr₁	`a - 7`
`-` expr	Negate expr	`-a`
`++` var	Add 1 to var (preincrement)	`++a`
var `++`	Add 1 to var (postincrement)	`a++`
`--` var	Subtract 1 from var (predecrement)	`--a`
var `--`	Subtract 1 from var (postdecrement)	`a--`

var represents a C++ variable.
*, /, +, and -, may be applied to integral or floating-point operands (or a mixture of both).
% may only be applied to integral operands.
The increment and decrement operators come in two forms, "pre" and "post". The idea is that the "pre" forms apply the operation before the result becomes available for use in any subsequent expression, whereas the "post" forms make the value of the variable available first, then apply the increment or decrement operation. Most of the time the distinction is not important. However, if you write code like the following, the form of operator chosen does make a significant difference.
int i1, i2, i3, i4; i1 = i2 = 10; i3 = ++i1; // Both i1 and i3 are now 11. i4 = i2++; // i2 is 11, but i4 is 10.

Back to Contents

Bitwise Operators

Operator	Purpose	Example
expr₁ `&` expr₂	Bitwise AND of expr₁ and expr₂	`a & 0xff`
expr₁ `\|` expr₂	Bitwise OR of expr₁ and expr₂	`a \| 0555`
expr₁ `^` expr₂	Bitwise Exclusive-OR of expr₁ and expr₂	`a ^ 1`
`~` expr	Negate bits of expr	`~a`
expr₁ `<<` expr₂	Left shift expr₁ by expr₂ bit positions	`a << 1`
expr₁ `>>` expr₂	Right shift expr₁ by expr₂ bit positions	`a >> 2`

Back to Contents

Assignment Operators

Operator	Purpose	Example
var `=` expr	Put result of evaluating expr into var	`a = 20`
var `=` expr*	Multiply var by expr and put result back in var	`a *= 20`
var `/=` expr	Divide var by expr and put result back in var	`a /= 20`
var `%=` expr	Generate var `%` expr and put result back in var	`a %= 20`
var `+=` expr	Add expr to var and put result back in var	`a += 20`
var `-=` expr	Subtract expr from var and put result back in var	`a -= 20`
var `&=` expr	Bitwise AND expr with var and put result back in var	`a &= 20`
var `\|=` expr	Bitwise OR expr with var and put result back in var	`a \|= 20`
var `^=` expr	Bitwise Exclusive-OR expr with var and put result back in var	`a ^= 20`
var `<<=` expr	Left shift contents of var by expr bits and put result back in var	`a <<= 2`
var `>>=` expr	Right shift contents of var by expr bits and put result back in var	`a >>= 2`

Back to Contents

The if ... else Statement

This is the basic decision statement in C++. It comes in two flavours, with and without an else block.

if (<Boolean Expression>)
    <if-part>
else
    <else-part>

and


if (<Boolean Expression>)
    <if-part>

Examples:


/*
 * File:      ifelse.cpp                            
 *
 * Purpose:   Illustrates the use of C++ if and if-else.
 *
 * Version:   1.0
 *
 * Date:      September 20, 2000
 *
 * Author:    Colin Flanagan
 *
 */
#include <iostream>
using namespace std;

int main()
{
    char ch;

    cout << "Please enter a character "; cin >> ch;

    if ( ch >= 'A' && ch <= 'Z' )  
        cout << "Uppercase";
    else if ( ch >= 'a' && ch <= 'z' ) {
        cout << "Lowercase, converting to uppercase";
	ch += 'A' - 'a';  // ch = (ch - 'a') + 'A';
    }
    else if ( ch >= '0' && ch <= '9' )
        cout << "Digit";
    else
        cout << "Not alphanumeric";

    if ( ch == '.' || ch == ',' || 
         ch == '?' || ch == '!' )
        cout << ", punctuation";

    cout << ": '" << ch << '\'' << endl;
    return 0;
}

The above program shows an example of a Nested if ... else structure, a style very common in C++ for complex multiway branches.

One of the if statements governs a block of code


    else if ( ch >= 'a' && ch <= 'z' ) {
        cout << "Lowercase, converting to uppercase";
	ch += 'A' - 'a';  // ch = (ch - 'a') + 'A';
    }

The final if statement in the program has no else part.

Back to Contents

The ? : Operator

This special operator allows simple if ... else decisions to be made in a very compact style.


max = (a > b) ? a : b;

Here max gets assigned the value of the expression following the ? if the Boolean preceding it is true, and gets assigned the value of the expression following the : if the Boolean is false.

It is equivalent to the if ... else code:


if ( a > b )
    max = a;
else
    max = b;

Back to Contents

The switch Statement

The switch statement is an alternative approach to handling multiway branches.


if ( ch == '+' )       acc += value;
else if ( ch == '-' )  acc -= value;
else if ( ch == '*' )  acc *= value;
else if ( ch == '/' )  acc /= value;
else
    cout << "Error" << end;

can be coded, using a switch statement, as:


switch ( ch ) {
    case '+' :  acc += value;  break;
    case '-' :  acc -= value;  break;
    case '*' :  acc *= value;  break;
    case '/' :  acc /= value;  break;
    default  :  
        cout << "Error" << end;
	break;
}

The case labels (e.g., case '+') must be integral constants (i.e., character or integer constant, or constant expression), or members of an enumeration. No variables, non-constant expressions or floating-point values are allowed.
Each case label must be unique within the switch statement. Duplicate labels are not allowed.
The only comparison that may be performed in a case block is equality. If you need a more complex comparison, use a nested if ... else structure.
The switch statement matches its argument (the expression in parentheses immediately following the switch keyword) against each of the case labels in turn, looking for a match. The case block following the first matching case label is executed.
If no case label matches, and if the switch statement contains the default keyword, then the block of code associated with the default keyword is executed. The default keyword may come anywhere in the switch statement, but it is considered good style to put it last.
A default block is not obligatory in a switch statement. If the default block is omitted, the switch will only be executed if a match is found between its argument and one of the case labels.
Once the switch statement starts executing code, it will execute all the following statements in the switch block, unless it encounters a break statement.
This can lead to non-intuitive behaviour by switch statements. If you forget to terminate the sequence of statements following a case label with a break statement, then the code associated with the next case label will be executed also.
Sometimes this is useful. Say you have a block of code which should be executed when any one of a number of conditions is true. You can achieve this effect with code like the following:
switch ( colour ) { case Red : case Green : case Blue : colourType = PRIMARY; break; default : colourType = COMPOSITE; break; }
Clearly, if the default block comes last in the switch statement, it doesn't need a break to terminate it. It is considered good style to include the break, however.

Back to Contents

The while loop

This is the simplest type of looping construct found in C++. It consists of a while keyword, followed by a Boolean Expression enclosed in parentheses, followed by a Loop Body, which is either a single statement or a block of statements. Before the loop body can be executed, the Boolean expression must be evaluated. If the Boolean is true, the loop body is executed, and the while loops back to evaluate the Boolean again. If the Boolean is false, the loop exits, and execution of the program continues with the following statement.


int i = 0;
while ( i < 10 ) {
    cout << i << ' ';
    i++;
}
cout << "Loop done" << endl;

Output of this is:


0 1 2 3 4 5 6 7 8 9 Loop done

Back to Contents

The do ... while loop

The do ... while loop is similar to the while loop, but the Boolean test occurs after the loop body. This means that the loop body of a do ... while loop is always executed at least once.


int i = 10;
do {
    cout << i << ' ';
    i++;
} while ( i < 10 );
cout << "Loop done" << endl;

Output of this is:


10 Loop done

The equivalent while loop would not execute its loop body at all if i were initially 10.

Back to Contents

The for loop

The for loop is the most important type of loop construct in C++. It is similar to a while loop, but it also allows for the initialisation and incrementing of loop variables to occur in the for loop header.


for (int i = 0; i < 10; i++) cout << i << ' ';
cout << "Loop done" << endl;

This has the same effect as the while loop shown earlier. If fact, any for loop may always be rewritten as an equivalent while loop.


int i;
float fact10;

for (i = 2, fact10 = 1.0f; i <= 10; i++)
    fact10 *= i;

i = 2;
fact10 = 1.0f;
while (i <= 10) {
    fact10 *= i;
    i++;
}

The for loop is very flexible in C++.

Notice in the above that two initialisation statements have been included (shown in green), separted by a Comma Operator. By using the comma operator in the initialisation, test or increment sections, we can maintain several loop variables very easily.
The loop variables in C++ don't have to be integers, they can be any type.
The loop variable modification doesn't have to be a simple addition or subtraction, any sort of operator is valid. This allows for extremely terse for loops, e.g.,
for (i = 2, fact10 = 1.0f; i <= 10; fact10 *= i, i++) ;
Here the for loop has an empty body, all the work of the loop is being done in the head.
The general form of a for loop is:
for ( Initialisations ; Termination Test ; Loop Variable Modifications ) Loop Body
It is possible to omit any, or all, of these sections when a for loop is used. This is sometimes useful. The following for loop, for exaxmple, has no Loop Variable Modifications section.
for (i = 2, fact10 = 1.0f; i <= 10; ) fact10 *= i++;
Such uses of the for loop often appear in idiomatic C++ code. It is important to be able to read and understand such code, however, it is better to use the while and do loops when these will improve the clarity of the code. Consider:
char ch; for ( ; cin.get(ch); cout << ch) if ( ch >= 'a' && ch <= 'z' ) ch += 'A' - 'a';
This is something of an abuse of the intent of the for loop. There is no initialisation section and the loop variable modifications section is not being used to modify any loop variables (this underlines the fact that in C++ any sort of code can go into the various sections which make up the header of a for loop). It is probably clearer to use a while loop in this case.
while ( cin.get(ch) ) { if ( ch >= 'a' && ch <= 'z' ) ch += 'A' - 'a'; cout << ch; }

A break statement in the body of a for loop will cause execution of the loop to halt immediately, regardless of whether the termination condition is true or not. Consider the following code which finds the largest value whose factorial can be represented in an int on a given machine.


int n, factN, oldFact;
for (n = 2, factN = 1; n < 1000; n += 1) {
    oldFact = factN;  factN *= n;
    if ( factN / oldFact != n ) break;
}
cout << "Factorial " << n - 1 << " = " 
     << oldFact << " is the largest" << endl;

Loop variables which are Declared as well as Initialised in the head of a for loop have a scope which extends to the end of the corresponding loop body.


// Table of values of f(x) = 2x^2 + 3x + 4, x = -1.0 ... -0.5

cout << "   x  |   f(x)\n";

for (float x = -1.0f; x <= -0.5f; x += 0.05f) { // x in scope here
    float f = (2.0f * x + 3.0f) * x + 4.0f;     // f in scope here

    // Output x as a number of the form xx.xx, right justified
    // and with a leading minus sign, in a 5 char
    // field.
    cout << right << fixed << setprecision(2) << setw(5) 
	 << x << " | ";

    // Output f as a number of the form xx.xxxx, right
    // justified, in a 7 char field.
    cout << right << fixed << setprecision(4) << setw(7) 
	 << f << '\n';

} // Neither x nor f available beyond this point

N.B., details of the format controls used here (right, fixed, setprecision & setw) may be found in Johnsonbaugh & Kalin, pp. 31-33.
Note for Visual C++ programmers: Visual C++ v6.0 does not implement the scoping rule for for-loop declared variables in the ANSI/ISO fashion. Instead, a variable declared in the head of a for-loop stays in scope until the end of the block where the for is declared, (an older behaviour, used in C++ before the ANSI/ISO standard was finalised). This means certain C++ programs which are correct according to the ANSI/ISO standard will not compile under Visual C++ v6.0. Here is an example.
#include <iostream> using namespace std; int main() { for (int i = 0; i < 10; i++) cout << i << ' '; for (int i = 20; i >= 1; i--) cout << i << ' '; return 0; }
This is an ANSI/ISO standard C++ program. The variable i declared in the first loop goes out of scope at the end of that loop, so it is valid to declare a different local variable with the same name for the second loop.
However, in Visual C++ v6.0, the first declaration of i is assumed to remain in scope until the end of the block which encloses it. Hence, it remains an active variable until the end of main and the second declaration of i generates an error.

Back to Contents

Functions in C++

Functions in C++ are one way to divide code up into manageable units. We have already seen one C++ function, main, which must be part of every C++ program. All other C++ functions have a similar syntax to main.


<Return Type> <Function Name> ( <Parameter List> ) {
     <Statement>
        .
        .
        .
     <Statement>
}


/*
 * File:      function.cpp                            
 *
 * Purpose:   Illustrates the use of C++ functions.
 *
 * Version:   1.0
 *
 * Date:      October 5, 2000
 *
 * Author:    Colin Flanagan
 *
 */
#include <iostream>
#include <iomanip>
using namespace std;

/* ----------------------------------------------------------
 *
 * f:         Calculate f(x) = 2x^2 + 3x + 4
 *
 * Input(s):  x, a float
 *
 * Output(s): none
 *
 * Returns:   f(x), a float
 *
 */

float f(float x) {
    return (2.0f * x + 3.0f) * x + 4.0f;
}

/* ----------------------------------------------------------
 *
 * main
 *
 */

int main()
{
    for (float val = -1.0f; val <= -0.5f; val += 0.05f) 
	cout << right << fixed << setprecision(2) << setw(5) 
	     << val << " | "
	     << right << fixed << setprecision(4) << setw(7) 
	     << f(val) << '\n';
    return 0;
}

This program contains two functions, f and main. The definition of f comes before that of main so that the compiler has "seen" f already when it compiles main.
This is needed because the compiler has to know what sort of code it is to generate when it sees the call to f within main.
In this program, f returns a float and takes a single Formal Parameter, x.
The Call to f is made within main. It is the expression f(val) in the output statement. Note that this call supplies an Actual Parameter, val. The value of this actual parameter is copied into the formal parameter x and used when f is executing. This style of parameter passing is called Call By Value, and is the default in C++.
Note that the number and types of the formal and actual parameters must agree. If they do not, a compile-time error is generated.
Because f's declaration states that it returns a float, it must contain a return statement with an expression of this type as its argument.
In general, a C++ function must include a return type in its declaration, stating the type of result the function returns. What happens, however, if we want a "procedure-like" function, i.e., one which does not return any values? In this case we specify the return type of the function as "void". This tells C++ that this particular "function" does not return a result.
void prettyPrint(float value, int fieldWidth, int precision) { cout << right << fixed << setprecision(precision) << setw(fieldWidth) << value; }
Note that this function does not need a return statement as it does not return a value to its caller. Any call to it will require three actual parameters.

Back to Contents

Function Prototypes

A Function Prototype is a Declaration of a function without its corresponding Definition. It looks like the header of a function without the body.

Function Prototypes are used in C++ to allow the definitions of functions to be placed in multiple source files. As long as a C++ compiler has access to a function prototype, it can generate the appropriate code for a function call. The actual code needed to implement the function may be compiled separately and later linked to the code of its caller to generate an executable file.

Example: Consider the function f above. It is not necessary to have access to the definition of f in order to compile the code for main, all the compiler needs to do this is know:

The number and types of the formal parameters of f, and;
The type returned by a call to f,

in order to generate code for a call to f within main. Here is a version of the file function.cpp which contains a function prototype for f, but does not contain its definition.


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

float f(float x);   // Function prototype for f.

int main()
{
    for (float val = -1.0f; val <= -0.5f; val += 0.05f) 
	cout << right << fixed << setprecision(2) << setw(5) 
	     << val << " | "
	     << right << fixed << setprecision(4) << setw(7) 
	     << f(val) << '\n';
    return 0;
}

A separate source file contains the definition of f. Note that the function prototype is terminated by a semicolon in place of a function body.

This technique of Separate Compilation allows large projects to be broken up into a number of smaller units. These smaller units compile quickly and are linked together to generate an executable file.

It may be necessary for a function prototype to be visible in multiple source files. Rather than repeat the function prototype in the various source files, with the associated possibility of incorrect definition, it is common practice in C++ to group sets of related function prototypes into a Header File, and use an #include directive to incorporate the header file into a source file where these function prototypes are needed. Since there is now only one function prototype for a function (held in the header file), errors are much less likely to occur than if the function prototype is re-written in each source file where it is needed.

The appropriate header file is commonly also #included in the source file where a function is defined. Strictly speaking, this is not necessary, the function prototype does not include any information which is required in order to compile the function definition. However, the practice is very useful because it serves as a consistency check, a guarantee that the various uses of a function and its implementation are agreed about what its interface should look like.

Here is the earlier example divided up into a header file f.h, and two source files, f.cpp and main.cpp. file.


#ifndef F_HEADER
#define F_HEADER 1
/*
 * File:      f.h
 *
 * Header file containing function prototype for function
 * f(x).  Definition iof f(x) in file f.cpp.
 *
 */

float f(float x);
#endif


/*
 * File:      f.cpp
 *
 */
#include "f.h"         // Include header for function f(x).

/* --------------------------------------------------------
 *
 * f:         Calculate f(x) = 2x^2 + 3x + 4
 *
 * Input(s):  x, a float
 *
 * Output(s): none
 *
 * Returns:   f(x), a float
 *
 */

float f(float x) {
    return (2.0f * x + 3.0f) * x + 4.0f;
}


/*
 * File:      main.cpp
 *
 */
#include <iostream>
#include <iomanip>
#include "f.h"         // Include header for function f(x).
using namespace std;

int main()
{
    for (float val = -1.0f; val <= -0.5f; val += 0.05f)
	cout << right << fixed << setprecision(2) << setw(5)
	     << val << " | "
	     << right << fixed << setprecision(4) << setw(7)
	     << f(val) << '\n';
    return 0;
}

Note the use of the quotes in the #include "f.h" directive in the two source files. This tells C++ to look for f.h in the Current Working Directory. The angle brackets on the other #include directives tell C++ to look for these header files (iostream & iomanip) in the C++ System Include Directory.
Note the use of the #ifndef, #define and #endif directives in the header file. These are designed to prevent multiple definitions of the function prototype for f occurring in a source file.
This can easily happen in a large project where the same header file may get #included more than once in a source file through multiple inclusion routes (unintentional, but very common with large software systems).
The mechanisim works as follows: #ifndef is a Conditional Inclusion preprocessor directive. If the argument to an #ifndef is defined (i.e., has any sort of value), then everything following the #ifndef until an #endif preprocessor directive is encountered is simply ignored (treated like a comment) by the preprocessor. Hence, if the symbol F_HEADER has a value when the #ifndef is encountered, the function prototype will be ignored by the compiler. Now, the first time the header file is #included in a particular source file, F_HEADER is undefined, so the #ifndef accepts everything in the header file and passes it on to the compiler, making the function prototype available for use.
Note, however, that one of the things in the header file is a #define preprocessor directive, which defines the symbol F_HEADER to have the value 1 (in fact, any value will do). Hence, if the same header file is supsequently #included in the same source file, F_HEADER will be defined and the function prototype will be ignored.
This use of #ifndef, #endif and #define is very common in header files, used to ensure that C++'s Single Definition Rule (which says that any entity in a C++ program may only be defined once) is not breached.

A final point about function prototypes. The formal parameter names in a function prototype are dummies. They are not needed. All that you need in a function prototype is the data type of each formal parameter, (e.g., "float f(float);" is fine). However, including formal parameter names in function prototypes is perfectly legal and may help to make the prototype more readable, so you are encouraged to do it.

Back to Contents

C++ Arrays

C++ allows single and multi-dimensional arrays of data elements. Declarations are made by including the size of the array associated with a variable in square brackets after its name:


char a[7], buff[256];
int vals[35];
float v[3];
double matrix[3][3];

Here we have declared a to be a 7-element array of chars. buff is also an array of chars, but has 256 elements. vals is an array of ints with 35 elements, and v is an array of floats with 35 elements. All these arrays are 1-dimensional. Array matrix, on the other hand, is 2-dimensional, comprising 9 doubles.

Accessing the elements of an array makes use of the Array Subscript operator ([ ]). Here is an example program which sorts an array of 5 values read from the standard input.


/*
 * File:      sort.cpp                            
 *
 * Purpose:   Sorts an array of 5 integers read
 *            from the standard input.
 *            A simple bubble sort is used.
 *
 * Version:   1.0
 *
 * Date:      October 6, 2000
 *
 * Author:    Colin Flanagan
 *
 */
#include <iostream>
using namespace std;

int main()
{
    const int MAX = 5;
    int elements[MAX], i;

    cout << "Enter " << MAX << " integer values to sort --> ";
    for (i = 0; i < MAX; i++)  cin >> elements[i];

    bool swappedElements = true;
    while ( swappedElements ) {
        swappedElements = false;
	int j;
	for (i = 0, j = 1; j < MAX; i++, j++)
	    if ( elements[i] > elements[j] ) {
		int temp = elements[i];
		elements[i] = elements[j];
		elements[j] = temp;
		swappedElements = true;
            }		
        for (i = 0; i < MAX; i++)  cout << elements[i] << ' ';
        cout << endl; 
    }
    cout << "Sorted elements: ";
    for (i = 0; i < MAX; i++)  cout << elements[i] << ' ';
    cout << endl; 
    
    return 0;
}

The most unusual feature of C++ arrays is that they are 0-based, rather than 1-based. That is to say, the first member of the array elements is elements[0], the second is elements[1]. The last member of this array, of size five, is elements[4].
Forgeting this is a common source of C++ errors, called Off By One errors.
The above program also makes use of a constant, MAX. Constants will be discussed later in the course.

Multi-dimensional arrays are "arrays of arrays". For example, matrix[3][3] is an array of size 3, where each of its elements is also an array of size 3. Access to multi-dimensional arrays just requires multiple [ ] operators. Here is code which calculates and outputs the inverse of a 2 x 2 matrix. It is a good example of the use of multi-dimensional arrays.


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

int main() {
    double m[2][2], invM[2][2];

    for (int i = 0; i < 2; i++)     // Read in matrix m.
        for (int j = 0; j < 2; j++)
	    cin >> m[i][j];

    // Calculate "ad - bc", the scale factor for the
    // inverse. This must be non-zero if the matrix
    // has an inverse.
    double adbc = m[0][0] * m[1][1] - m[0][1] * m[1][0];

    if ( adbc == 0.0 )
        cout << "matrix has no inverse" << endl;
    else {
        // Inverse calculation using the well-known
	// formula.
        invM[0][0] =  m[1][1] / adbc;
        invM[1][1] =  m[0][0] / adbc;
        invM[0][1] = -m[0][1] / adbc;
        invM[1][0] = -m[1][0] / adbc;

        // Code to display the inverse.
        cout << fixed << setprecision(5);	
	for (int i = 0; i < 2; i++) {
	    for (int j = 0; j < 2; j++) {
	        cout << setw(9) << invM[i][j];
		if ( j == 0 ) cout << ", ";
	    }
	    cout << '\n';
	}
    }
    return 0;
}

Arrays may be passed to functions. A function which accepts a 1-dimensional array as an argument does not need to specify the array size in its formal argument list.


#include <iostream>
using namespace std;

const int VECTOR_SIZE = 3;

float innerprod(float v1[], float v2[]);
void readVector(float v[]);

//------------------------------------------------------------------
//
// Function:	    main
//

int main()
{
    float v1[3], v2[3];

    cout << "Enter vector 1 (" << VECTOR_SIZE << " elements) --> ";
    readVector(v1);
    
    cout << "Enter vector 2 (" << VECTOR_SIZE << " elements) --> ";
    readVector(v2);

    cout << "The inner product of v1 and v2 = " << innerprod(v1, v2) 
         << endl;
    return 0;
}

//------------------------------------------------------------------
//
// Function:	    innerprod
//
// Inputs:	    Two vectors of floats, both of size VECTOR_SIZE.
// Outputs:	    None.
// Returns:	    A float.
// Purpose:	    Calculates the inner product of the argument
//                  vectors.
// Side Effects:    None.
//

float innerprod(float v1[], float v2[]) 
{
    float acc = 0.0f;
    for (int i = 0; i < VECTOR_SIZE; i++) acc += v1[i] * v2[i];
    return acc;
}

//------------------------------------------------------------------
//
// Function:	    readVector
//
// Input:	    A vector of floats, of size VECTOR_SIZE.
// Output:	    The same vector, with its contents modified to
//		    values read from the standard input.
// Returns:	    Nothing.
// Purpose:	    Reads elements into vector supplied as actual
//		    parameter.
// Side Effects:    Modifies actual parameter to call.
//

void readVector(float v[])
{
    for (int i = 0; i < VECTOR_SIZE; i++) cin >> v[i];
}

Note the "empty bracket" notation (e.g., float c[]) used to specify that a 1-dimensional array is being passed to a function. This tells C++ that the argument is an array, but does not explicitly mention its size. Sometimes this is useful. It is always legal to specify the size of an array explicitly in a formal argument list.
One important point illustrated by the above code is that arrays are not passed by value into a function, but Passed By Reference. This means that any modification to a formal array parameter of a function will also modify the actual array parameter used in the call to that function. This behaviour is used to advantage in the above code, where the readVector function relies on it to ensure that v1 and v2 get the values read from cin placed into them.
Note that this behaviour is in marked contrast to the behaviour of scalars used as formal parameters. A scalar formal parameter can be modified in a function, and this will not change the value of the corresponding actual parameter used in a call to that function.
The reason for this difference in treatment of array parameters and scalar parameters is one of efficiency. C++ always makes a local copy of any scalar parameters to a function, and it is the local copy that the function works with. For arrays, on the other hand, C++ passes the address of the first element to the function, (as it is potentially expensive to copy the whole array element by element). Thus, when working with an array parameter, a function is modifying the original array, hence pass by reference.

Arrays in C++ may be Explicitly Initialised when they are declared. If a 1-dimensional array is explicitly initialised it is not necessary to give its size, as C++ can work this out by counting the elements.


int primes[] = { 2, 3, 5, 7, 11, 13, 17, 19, 23 };

Here primes is a 1-dimensional array of size 9.

Explicit initialisation applies to multi-dimensional arrays as well. However, in this case you have to specify the sizes of all the dimensions except the major one.


double matrix[][3] = { { 10.0, 20.0, 30.0 },
                       { 40.0, 50.0, 60.0 } };

Here matrix is a 2-dimensional array containing 2 1-d arrays each of size 3.

String literals in C++ are a type of array (array of char). A string literal consists of the characters of the string, terminated by a Null Character, automatically inserted by the C++ compiler to indicate "end of string". Hence, the character literal "Hi" has three elements, 'H', 'i' and '\0' (the C++ notation for the null character). The null character always has an integer value of zero.

Arrays of char may be explicitly initialised by using string literals.


char hello[] = "Hello";

This creates a 6-element array of char. Hello[0] is 'H', Hello[1] is 'e', and Hello[5] is '\0'.

The fact that a null character is guaranteed to appear at the end of a properly formed string literal is used extensively in C++ manipulation of arrays of char.


void to_uppercase(char s[])
{
    for (int i = 0; i < 1000 && s[i] != '\0'; i++)  
        if ( s[i] >= 'a' && s[i] <= 'z' ) s[i] += 'A' - 'a';
}

Back to Contents

C++ Structures

A Structure in C++ is a Composite Data Type, i.e., a way to group together a number of data elements and treat them as a unit. Example: a Date could be made up of integers representing the day, month and year:


struct Date {
    int day;
    int month;
    int year;
};

Now Dates can be declared in C++ programs just as if they were built-in types.

Access to the members of a structure is performed using the Dot Operator (".").


#include <iostream>
using namespace std;

struct Date {
    int day;
    int month;
    int year;
};

char monthNames[][4] = { "Jan", "Feb", "Mar", "Apr", 
                         "May", "Jun", "Jul", "Aug", 
			 "Sep", "Oct", "Nov", "Dec" };

void displayDate(Date d);

int main()
{
    Date today, last_year;

    today.day = 10;
    today.month = 10;
    today.year = 2000;

    Date tomorrow = today;
    tomorrow.day++;

    last_year = today;  last_year.year--;

    cout << "Today is "; displayDate(today);
    cout << "\nTomorrow will be "; displayDate(tomorrow);
    cout << "\nLast year was "; displayDate(last_year);
    cout << endl;
    return 0;
}

void displayDate(Date date) 
{
    cout << monthNames[date.month-1] << ' ' 
         << date.day << ", " << date.year;
}

The Date structure is usually defined at File Scope so that it is visible across several functions. Here, for example, it is visible to both main and displayDate.
Once the Date structure is defined, variables of type Date may be declared. The type Date can be used just like any of the built-in types in a declaration.
Access to the elements of a Date variable is via the dot operator. Hence today.day accesses the day field of the Date variable today, etc.
Structures may be assigned. The code last_year = today; sets all the fields of last_year equal to the fields of today.
Structures may also be passed as parameters to functions. They are passed by value, which means that a local copy of the structure is made within the called function.
A point about the 2-d array array monthNames. The size of the second dimension is given as 4 to allow space for the month names. Each month name is an array of four characters, the three visible ones plus a null ('\0') to terminate the string.

The fields within a structure do not have to be homogeneous. They may be of differing types.


struct student {
    int   id_number;
    float qca;
    char  firstname[40];
          lastname[40];
          middleinitial;
};

Back to Contents

Pointers in C++

In C++ a Pointer is a variable which holds the Memory Address of another variable as its contents.

Pointers have types, i.e., a given pointer variable is only allowed to point to (i.e., contain the address of) other variables of a certain type. Thus C++ has "pointers to int", "pointers to float", "pointers to char", etc., but a pointer to an int may only point to an int variable, never a char variable or a float variable.

Pointers are declared very much like any other variables, except that they have a special symbol, (the asterisk, "*") to denote that they are pointers and not standard variables.


char ch, *chptr;
int x, y, *pi;
float f, *pf;
double *pointerToDouble;

Here chptr is a pointer to a char, pi is a pointer to an int, pf is a pointer to a float, and pointerToDouble is a pointer to a double. Note how declarations of pointers may be mixed with declarations of ordinary variables (ch, x, y, & f).

Note that declaring a pointer does not initialise it. All the pointers above may be assumed initially to contain random values. Attempting to use an uninitialised pointer in a program will usually cause a run-time error (often the compiler will warn you if it thinks a pointer - or any variable - is being used before it is initialised).

To initialise a pointer to point to a valid variable requires the use of the Address-Of operator ("&"). Here is code which declares and initialises a pointer to an integer.


int value = 22, *ptr;

ptr = &value;          // "ptr" now contains the address of "value".

To get at the value of a variable via a pointer requires the use of the Dereference operator (the asterisk, "*").


int value = 22, *ptr;

ptr = &value;          // "ptr" now contains the address of "value".

cout << value << ' ';  // Print contents of "value" variable.

cout << *ptr << '\n';  // Print contents of "value", but access
                       // via pointer "ptr", using dereference.

(Note that C++ has several uses for the asterisk: as a way of declaring pointers; as a way of dereferencing them; and as a multiplication operator. Be careful you understand what context an asterisk is being used in.)

Pointers and Structures

Pointers to structures may be declared in a similar way to pointers to any of the built-in types. For example, given the Date structure from above, we may declare: Date today, *ptoday;, where today is a variable of type Date and ptoday is a pointer to a variable of type Date.

C++ has a special operator to allow the elements of a structure to be accessed via a pointer. We could use (*ptoday).day to access the day field of variable today via dereferencing through ptoday, or we may use ptoday->day to achieve the same result. The Arrow operator ("->") allows direct access to the fields of a structure through a pointer to that structure.


Date today, *ptoday;

ptoday = &today;       // "ptoday" now contains the address of "today".

ptoday->day = 10;      // Modify fields of "today" thru pointer, using
ptoday->month = 10;    // arrow operator.
ptoday->year = 2000;

cout << today.day      // today.day = 10 (modified thru pointer)
     << '/'
     << today.month    // today.month = 10
     << '/'
     << today.year;    // today.year = 2000

Pointers and Arrays

Pointers and arrays have a special relationship in C++.

The name of an array behaves like a pointer to its first element (element 0 of the array).
Dereferencing the name of an array returns the value of the first element of the array.
Adding an integer, value i, to a pointer to the base of an array gives the address of the i^th element of that array. Dereferencing this address gives the value of the i^th element. Hence, if x is an array of 20 ints, we may access element 4 (the fifth element of that array) using either the array subscript operator x[4], or the dereferencing operator *(x+4). The two approaches are completely equivalent in C++ (indeed, they are synonyms).


int i, primes[] = { 2, 3, 5, 7, 11, 13, 17, 19, 23, -1 };

for (i = 0; primes[i] > 0; i++) cout << primes[i] << ' ';

for (i = 0; *(primes+i) > 0; i++) cout << *(primes+i) << ' ';

for (int *pptr = primes; *pptr > 0; pptr++) cout << *pptr << ' ';

The Null Pointer

Sometimes it is convenient to specify that a pointer variable currently doesn't hold a valid address. Such a pointer is called a Null Pointer, and is specified in C++ by using the constant 0. Any pointer can be assigned this value, and any pointer containing this value is null, i.e., currently not pointing at anything.

Here is an example of the use of null pointers. A structure can be defined to contain a pointer to structures of the same type. This allows the structure to be used to build a linked-list.


struct node {
    int id;        // student id number
    char name[40]; // student name
    node *next;    // next node in list
};

The following is a function which traverses such a linked list looking for a particular student id and returns the name of that student if a match is found. If no match is found, a null pointer is returned.


char *search(node *listNode, int id)
{
    while ( listNode != 0 && listNode->id != id )
        listNode = listNode->next;

    return (listNode ? listNode->name : 0);
}

The end of the list is indicated by the null pointer. When a node has no successor in the list, its next field is null.
The test listNode != 0 ensures that listNode points to a valid node. This is a good use of the short-circuiting && operator.
The while loop terminates when either a match has been found or the end of the list reached. The return statement returns a pointer to the char array representing the student name if the end of the list has not been reached. Otherwise it returns a null pointer to char. Note how the test to see if the end of the list has been reached is represented: if listNode is non-null, it behaves as true, hence listNode->name is returned; if it is null, it behaves like false and a null pointer to char (i.e., 0) is returned.

Note for C programmers: C++ does not make use of the preprocessor macro NULL. Anywhere a C program would use NULL, the C++ style is to use 0.

Back to Contents

Command-Line Arguments to Programs

C++ allows the use of Command-Line Arguments to pass information to programs from the command line. To make use of command-line arguments in a program, we must declare the main function in a special way:


int main(int argc, char *argv[])

Here the first parameter, argc, will be filled in by the operating system with the number of command-line arguments passed to the program when it is run. The second parameter is an array of pointers to null-terminated arrays of char which are the string representations of the arguments themselves.

The two formal parameters may have any names you like, but it is traditional in C and C++ programming to call them argc and argv. (argument count and argument vector). They must have the types shown above, however.

Here is a program which echoes back the command-line parameters is receives:


/*
 * Program:	echoargs
 *
 * Purpose:	Illustrate the use of command-line arguments by echoing all
 *		such arguments back to the user.
 *
 */
 
#include <iostream>
using namespace std;

int main(int argc, char *argv[])
{
    cout << argc << " command-line parameters were passed to the program.\n";
    for (int i = 0; i < argc; i++)
        cout << "Argument[" << i << "] is :" << argv[i] << '\n';
    return 0;
}

If you run this program you will notice that argv[0] is the name of the program itself. C++ always returns the name of the currently executing program as its first command-line parameter. Subsequent parameters will appear in successive elements of argv:


F:\modules\c++\notes> echoargs hello world, my name is Colin
7 command-line parameters were passed to the program.
Argument[0] is :F:\modules\c++\notes\echoargs.exe
Argument[1] is :hello
Argument[2] is :world,
Argument[3] is :my
Argument[4] is :name
Argument[5] is :is
Argument[6] is :Colin

It is the operating system which is responsible for breaking up the command line into parameters. It normally splits the command line up by separating parameters where whitespace appears.

Back to Contents

Colin Flanagan / 19-October-2000