How to ... in c++ (in examples)

Assembled by Ross Bannister, University of Reading

Reserved Words

asm, auto, bool, break, case, char, class, const, continue, default, delete, do, double,
else, enum, extern, false, float, for, friend, goto, if, inline, int, interrupt,
long, main, naked, new, operator, private, protected, public, register, return,
short, signed, sizeof, static, struct, switch, template, this, true, typedef,
union, unsigned, virtual, void, volatile, while.

Main Body of Code

include statements
Global variable declarations
Type definitions
Enumerator definitions (named integer constants)
Structure definitions
Union definitions

Function declarations (not definitions)

// Single line comments
/* Multiple
   line
   comments */

int main()
{ statements; ...return integer; }

Function definitions

(integer=0 is normal ending of main)

Data types

Primitive data types

char       (1 byte integer for characters)
int        (2-byte signed integer)
float      (4-byte real)
double     (8-byte real)

Logical types can be represented as integers (0=false, other value=true) (or use the special bool type).
Variables can be initialized in the declaration.

Type modifiers

const        (definition of constants)
long         (double length integer)
unsigned     (unsigned integer)
static       (in functions, maintains value between calls)

Casting (type conversion)

int (floatvariable)

Forcing types

9.99f     (forcing to type float)
999L      (forcing to long (4-byte) integer)

Derived data types

Type definitions

typedef variable_type NAME;

variable_type contains a primitive type with type modifiers.
NAME becomes a pseudonym for variable_type for variable declaration:
```
NAME variable_name;
```

Enumerators

enum name
{ integer_identifier1 [= value1],
  integer_identifier2 [= value2],
  ... };

In the program, a variable (declared as type enum_variable_name) can be set to one of the identifiers. If values are omitted then they take on incremental integers, starting with 0. Further declarations can be made later using name as the type.

Structures

Structures are user defined composite types, defined by:
```
struct struct_name
{ member_declarations; };
```
Member_declarations are variable declarations (primitive, arrays, derived, pointers, etc.).
Other variables of this type can be declared:
```
struct struct_name variable_name;
```
It is possible to have arrays of derived data types.
Members of the structure are referenced by:
```
variable_name.member_name
```

Union

union name { member_declarations; };

As struct, but all members share the same memory.

Operators

Arithmetic operators

+, -, *, /     (ordinary arithmetic operators)
%              (remainder)
++, —         (increment, decrement)

Logical operators

&& (and), || (or), ^ (xor), ! (not)

Relational operators

==, !=, <, >, <=, >=

Compound assignment operators

expression1 operator = expression2;

is equivalent to:

expression1 = expression1 operator expression2;

Control structures

If ... else

if (expression) {statement1;} else {statement2;}

The else branch is optional. This is equivalent to:

expression1 ? statement1 : statement2

Switch

switch (integer_expression)
{ case integer1:
    statements1;
    break;
  case integer2:
    statements2;
    break;
  default:
    statements3;
}

While

while (logical_expression)
{ statements; }

do ... while

do
{ statements; }
while (logical_expression);

For

for (statement1; expression; statement2)
{ statements; }

is equivalent to:

statement1;
while (expression)
{ statements;
  statement2; }

Common loop usage:

for (i=1; i<=100; i++)
{ statements; }

If statement1 or statement2 is missing, nothing is executed in their place.
If expression is missing it is true by default.
Statement1 can include a declaration of the loop variable (it continues to exist after the loop has finished).

Exiting and skipping loops

break    (exit the loop)
continue (skip to next cycle (statement2 is still evaluated in for loop))

The above can be used in while, do ... while, and for loops.

Arrays

Declaration

type array_name [size];
type array_name [sizex][sizey];
type array_name [size] = {value0, value1, ... };
type array_name [sizex][sizey] = {{value00, value01, ... }, {value10, value11, ... }, { ... } };

Array elements start at 0 and end at size-1.
size, sizex, sizey, etc. can be omitted when declaration and initialization are combined (values are implied).
Arrays are implicitly pointers to the start of the array.
This way of allocating arrays, uses space from the stack, instead of the method described later under the heading “Pointer”, which uses space from the heap. The heap is much larger than the stack.

Using and accessing

array_name [index]
array_name [indexx][indexy]

Pointers

Pointer declaration and null setting

Declaration (with optional setting to the null pointer, two equivalent ways):

type* pointer_name = NULL;
type *pointer_name = NULL;

Pointers are always 4 bytes long.

Pointer creation and deletion

For single variables:

pointer_name = new type;
...
delete pointer_name;

For dynamically allocated (1D) arrays:

pointer_name = new type[size];
...
delete[] pointer_name;

In the case of arrays the pointer points to the first element in the array.
Deleting the array (as above) releasing the space of the whole array.
This way of allocating arrays, uses space from the heap, instead of the method described under the heading “Arrays”, which uses space from the stack. The heap is much larger than the stack.

For dynamically allocated 2D arrays - suggested functions (to create and destroy array doubles):

void Array_2d_double_create ( double ***Array,
                              int    ylen,
                              int    xlen )
{ int j;
  *Array = new double *[ylen];
  for (j=0; j<ylen; j++)
  { (*Array)[j] = new double[xlen];
  }
}
...
void Array_2d_double_destroy ( double ***Array,
                               int    ylen)
{ int j;
  for (j=0; j<ylen; j++)
  { delete (*Array)[j];
  }
  delete (*Array);
}

To access:
Array[j][i]

Accessing information

To access a pointer’s target:

*pointer_name

If the pointer is to a structure:

(*pointer_name).variable_name

To return a pointer to a variable (useful for call-by-address in function calls):

&variable_name

Allocation check:

(pointer_name)

This will return true if it is an allocated pointer.

Characters and Strings

String declaration and setting

Declaration (with optional initialization)

char string_name [] = {char1, char2, ..., \0};
char string_name [] = "literal string";

Strings are arrays of characters.
Characters, e.g. char1, go inside single quotes.
Characters inside single quotes evaluate to their ASCII code.
In the first example declaration above, the last character must be \0 (see below). This is implied in the second example declaration.
Literal strings go inside double quotes. Literal string arguments can be given in double quotes. This sets up an array and passes the pointer to the start of the array.
In the above the array length is implied.
After declaration, strings cannot be set directly using literal strings (use strcpy of standard library string.h).
```
strcpy (string_name, "literal string");
```

Special characters

\" double quotes
\’ single quote
\\ backslash
\n newline
\0 null (padding)

String utilities

#include <string.h>

// Read a string from a file
fgets (string-pointer, max-length, file-pointer);

// Formatted write to a string
sprintf (output-string, "format specifier", inputs, ...);

// Size of a string
sizeof (string);


#include <string.h>
// Extract a sub-string from position n
strncpy (output-substring, original-string + n, length-of-substring);

// Copy one string to another
strcpy (output-string, input-string);

// Find the place in a string where a substring is located (returns pointer);
sub = strstr (string, substring);

// Find the place in a string where a single character is located (returns pointer);
sub = strchr (string, char);

// (note the position in the string can be found as pos = sub-string,
//  where pos is an integer, and where 0 corresponds to the first position)

// Compare two strings
pos = strcmp (string1, string2);
// Returns 0 when the two strings are equal

// Compare two strings (to at most n characters)
pos = strncmp (string1, string2, n);

Input and Output

Keyboard and screen (cout and cin)

#include <iostream.h>
...
cout << exp1 << exp2 ...;
cin >> var1 >> var2 ...;

Keyboard and screen (formatted)

Output to screen:

#include <stdio.h>
...
printf (format_string, exp1, exp2, ...);

Input from keyboard:

scanf (format_string, &exp1, &exp2 , ...);

The variable arguments for scanf are addresses (&). The & is implicit for pointers or arrays.
See below for the format_string description.

Format string description

Example used with printf:

printf ("\nThe result for %i is %f", int_var, double_var);

The %i and %f are examples of format specifiers.
Format specifiers have a general form, %[flag] [width][.precision]type.
Only the type part has been used in the above example.
Useful flags are:
- - left justify
- + always display sign (for numerical data)
- (space) display a space if there is no sign (for numerical data)
- 0 pad with leading zeros
The width specifies how many characters to use in total for this output element
The precision specifies how many digits are displayed after the decimal point (for numerical data)
Useful types are:
- c character
- s string
- d or i signed integer(e.g. %02d or %02i will return 01, 02, etc.)
- u unsigned integer (e.g. %02u will return 01, 02, etc.)
- f floating point
- e or E exponential format
- g or G computer chooses f / e
- x hex (lower case letters a-f)
- X hex (upper case letters A-F)
- p pointer

A further example:

printf ("%  8u  %7s  %  8i  %  11.6f\n", int_var1, string_var, int_var2, float_var);

This will:

use 8 digits to display an unsigned integer, padded with leading spaces (followed by 2 spaces),
use 7 characters to display a string (followed by 2 spaces),
use 8 digits to display an integer, padded with leading spaces (followed by 2 spaces),
use 11 digits, 6 decimal places to display a float, padded with leading spaces.

File IO (formatted)

Open a file:

#include <stdio.h>
...
FILE* file_var = NULL;
...
file_var = fopen (file_name_string, mode_string);

file_var is a pointer to a FILE type.
mode_string is specified below.\begin_inset Separator latexpar\end_inset
- "r" reading (file exists)
- "w" writing (file may or may not exist)
- "r+" reading and writing (file exists)
- "w+" reading and writing (file may or may not exist)
file_var remains NULL (logically false) if opening is unsuccessful.

Output to file:

fprintf (file-var, format_string, exp1, exp2, ...);

Input from file:

fscanf (file-var, format_string, &exp1, &exp2 , ...);

Read a whole line as a string:

fgets(string, length-of-string-declaration, file-var);

The use of fprintf and fscanf is just like printf and scanf (above), but with the extra file_var parameter.
See above for the format_string description.

Closing a file:

fclose (file-var);

Test for end of file:

feof (file-var)

Functions

Declaration

type function_name (arg_type1 arg_name1, arg_type2 arg_name2, ...);

The declaration appears in the header of each file that uses the function.
The function type and the argument types are primitive data types (with modifiers if necessary), typedefs, enumerators, structures or unions, etc.
The argument names may be omitted.
For no arguments, use empty parenthesis.
If the function has no type then declare as type void (the function is then called as a statement).

Definition

type function_name (arg_type1 arg_name1, arg_type2 arg_name2, ...)
{ local variable declarations; statements;
  return value;
}

The definition appears after the ’main’ function definition.
The function ends when a return statement is found (this can appear many times anywhere in the definition) or at the end.
No return is required if the function is of type void.
Global variables are used by inserting :: immediately before the variable name (needed only if local variable exists with the same name).
Parameters are call-by-value.
Call-by-address is achieved by passing pointers as parameters (see below). This allows any changes of formal parameters (inside the function) to affect the actual parameters (outside).
All arrays are implicitly pointers to the start of the array.
Arrays may be passed by using the bare array_name as the actual parameters and array_name[] in the list of formal parameters.
For arrays of more than 1-D, the dimensions should be specified.

Mathematical operators

#include <math.h>

// x to the power of y
pow(x,y);

// Absolute value of an integer, i
abs(i);

// Absolute value of a double, d
fabs(d);

// Copy sign (forms a number with magnitude m and sign s)
copysign (m, s);

// pi
const float  pi = 3.14159265359;

// Inverse trig functions
asin(ratio);
acos(ratio);
atan(ratio);
atan2(y,x)

// Test for not-a-number (nan)
isnan(x);

Inputting information via command line arguments

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int ProgramArguments ( int    arg_count,
                       char   **arg_list,
                       char   *character,
                       char   string[64],
                       int    *integer,
                       double *doublevar );

int main ( int   arg_count,
           char  **arg_list )
{ int    success;
  char   character;
  char   string[64];
  int    integer;
  double doublevar;

  success = ProgramArguments ( arg_count,
                               arg_list,
                               &character,
                               string,
                               &integer,
                               &doublevar );


}


int ProgramArguments ( int    arg_count,    // in  No of args
                       char   **arg_list,   // in  Program arguments
                       char   *character,   // out Example with a character
                       char   string[64],   // out Example with a string
                       int    *integer,     // out Example with an integer
                       double *doublevar )  // out Example with a double

{ int success, count;

  success      = 1;
  count        = 0;

  // Extract the first argument (a character)
  count += 1;
  if (arg_count > count)
  { *character = arg_list[count][0];
    printf ("Argument 1: you entered %c\n", *character);
  }
  else
  { printf ("Argument 1 (a character) expected\n");
    success = 0;
  }

  // Extract the second argument (a string)
  count += 1;
  if (arg_count > count)
  { strcpy(string, arg_list[count]);
    printf ("Argument 2: you entered %s\n", string);
  }
  else
  { printf ("Argument 2 (a string) expected\n");
    success = 0;
  }

  // Extract the third argument (an integer)
  count += 1;
  if (arg_count > count)
  { *integer = atoi(arg_list[count]);
    printf ("Argument 3: you entered %i\n", *integer);
  }
  else
  { printf ("Argument 3 (an integer) expected\n");
    success = 0;
  }

  // Extract the fourth argument (an double precision)
  count += 1;
  if (arg_count > count)
  { *doublevar = atof(arg_list[count]);
    printf ("Argument 4: you entered %f\n", *doublevar);
  }
  else
  { printf ("Argument 4 (a double) expected\n");
    success = 0;
  }

  return success;
}

Example use:
- ./a.out a “happy birthday” 18 18.0

Miscellaneous

Exit code

#include <stdlib.h>

exit(status);

Check potential problems with source code (linux command)

cppcheck source_code.cpp --enable=all

Numerical libraries

FFTw

// Include
#include <fftw3.h>

// Compilation and linking
// g++ code.cpp -o code.out -lfftw3 -lm

// Data types
fftw_complex  //(this is a double[2], element [0] is real part, element [1] is imaginary part)
fftw_plan     // (this specifies the input/output arrays and the transform type)

// Example FT and inverse
fftw_complex realspace[100], spectralspace[100], realspace1[100];
fftw_plan    plan;

plan = fftw_plan_dft_1d(100, realspace, spectralspace, FFTW_FORWARD, FFTW_ESTIMATE);
fftw_execute(plan);

plan = fftw_plan_dft_1d(100, spectralspace, realspace, FFTW_BACKWARD, FFTW_ESTIMATE);
fftw_execute(plan);

Gnu Scientific Library

// Include (the appropriate routine is found in /usr/local/include/gsl)
#include <gsl/...h>
// Compilation and linking
// g++ code.cpp -o code.out -lgsl -lgslcblas -lm