A Summary of Chapter 2

• The switch statement
• Arrays
• Strings
• Functions
• Pointers
• Structures
• File access

The switch statement

• This is used to choose a different course of action for your program depending on the value of a variable. The syntax is as follows:

  switch (variable)
  { case firstvalue : dothis;
                      dothat;
                      somethingelse;
                      break;
    case secondvalue : anotheraction;
                       andanother;
                       break;
       etc.
  }
  

  variable is the variable to be tested and firstvalue, secondvalue etc. are constants (not variables, but values) representing the possible values that the variable can take.

• Each set of actions should end in the statement break; to make the program skip over the remaining possibilities of the switch statement to the instruction after the end.

• You can insert a default : clause just before the ending } of the switch statement. This will be activated if none of the other values triggers any actions. It basically means "failing all else, do me", and, being the last item in the switch statement, does not require a break; after it.

Arrays

• An array lets you tie several simple variables (ints, floats etc.) into a single name. All the variables must be of the same type. You can't have an array that holds both int values and long values, for instance.

• Declare an array as follows:

  int myname[30];
  

• In this case, the array would be called myname and it would contain 30 integers, referred to as myname[0], myname[1] etc. up to myname[29] (not myname[30], note, as we start counting from 0).

• Each of these elements can be used just as you would a normal int value:

  myname[2] = 34;
  myname[15] = 4 * myname[7] - 10;
  cout << myname[20];
  

• Arrays are often used with loops to step through all (or some) of the values:

  // Display all the values from myname[0] to myname[9]
  for (int x = 0; x < 10; x++)
    cout << myname[x] << " ";
  

• You can declare arrays with 2, 3 or more dimensions similarly:

  double airpressures[40][25];
  
  ...
  
  airpressures[3][index] = 45.11;
  
  ...
  
  for (int x = 0; x < 40; x++)
    airepressures[x][0] *= 3;
  
  ...
  
  for (int a = 0; a < 40; a++)
    for (int b = 0; b < 25; b++)
      airpressures[a][b] = 0;
  

  The same applies to three-dimensional arrays etc. except they have three index numbers.

Strings

• A string is a sentence, word, sequence of characters strung together like waggons in a goods-train.

• There are two ways of implementing strings in C++, the old way (a hangover from C) and the new way. The old way simply treats them as an array of characters, except you can enter and display strings all in one go, rather than a single character at a time.

  char name[20];
  
  cout << "Enter the name : ";
  cin >> name;
  
  cout << "The name is " << name << endl;
  

  You will notice that there is no messing around with array indices in that. The last character of the string is an invisible character of value 0.

• The new (improved) way of implementing strings is to use a data type called String which is built into a header file string.h (or cstring.h, depending on which version of C++ you are using), which you must #include at the start of the program.
• Basically, strings are still implemented as arrays of characters with a 0 character at the end to mark where the string ends, except this time you don't have to declare them as arrays, simply as strings:

  string name, address, girlfriend;
  

• You can set a string all in one go, but also refer to individual letters of it:

  girlfriend = "Diane";
  cout << girlfriend[0];  // Displays D
  

  Remember, the first character of the string is still in slot 0, not 1.

• The string type provides various operations that you can use such as length(), compare() and substr() that let you find the length of the strings, compare strings etc. There are lots of these.

• You can use cin to read a string into a program just as you can with a numerical variable, but be warned! It will only read up to a space and ignore anything from there on. If you want to read in a string which contains spaces (or other weird characters such as TAB), then use the getline function.

  cout << "Enter your full name : ";
  cin.getline(name,20);
  

  In this case, the second parameter (the number after the name of the string variable whose value is to be read in) is the maximum number of characters that you want getline() to accept. If you try to enter more than this number of characters, getline() simply ignores the rest.

Functions

• A function is a group of instructions bundled together into one unit and referred to by a name. A function is defined as follows:

  return_type function_name (parameter_list)
  {
      // The statements making up the function go here
  }
  

  The return type is a simple variable type (int or double etc. but not something complicated such as array). This means that the function can be called (referred to by name) in place of a variable, just as if it were a variable itself. If you want to refer to the function without it handing back a value (i.e. just as sequence of instructions), then use the special word void for the return type.

• The parameter_list referred to above is an (optional) list of variables, complete with their types that can be "passed in" to the function and used within it. You can pass in different variables or constant values every time you call the function. If a function has no parameters, then you still have to include the brackets, but you put nothing between them. You can pass arrays as parameters.

• If a function has a proper return type (i.e. not void), then it should contain a return instruction followed by the value that the function produces (an expression, or variable or such like). When the function reaches this instruction, it throws out the value specified, stops running and returns control to the main program or the function that called it.

• Here is an example of a function, complete with a return type and a parameter list containing three parameters:

  // This function gives 'x' to the power of 'y'
  long power (int x, int y)
  { long temp = 1;
    int i;
    for (i = 0; i < y; i++)  // Multiply temp by 'x', 'y' times
     temp *= x;
    return temp;
  }
  
  ...
  
  cout << "The value of 17 squared is ";
  answer = power(17,2);
  cout << answer;
  

  In this example, the function was called power and returned a long value. It had two parameters, both int values, which were referred to as x and y inside the function. The function calculated the value of x to the power of y in a variable called temp which it returned at the end.

  The function was called by quoting its name and passing it two parameters, in this case, the numbers 17 and 2. The parameter x became 17 for the duration of this function call, and y became 2 for this function call, although they could be totally different if the function were called again with different values. The function was called as part of a variable assignment, just as if it were a variable or a number.

Pointers

• a pointer is a variable which contains as a value a reference to another variable. Think of a pointer as containing the "address" of the variable, the way an envelope has an address on it referring to a house.

• Pointers are used a great deal with structures (see below) to create complicated data structures.

• Pointers are declared as follows:

  double* first;
  int *x;
  

  Pointers have to point to a certain type of item. In this example, the first pointer can only point to a double value and the pointer x can only point to an integer. The asterisk can come at the end of the type or at the start of the variable name.

• A pointer is made to point to something (i.e. assigned, the way you would a variable) using the & operation:

  int hello = 4;
  
  x = &hello;
  

  This instruction means "make 'x' point to the variable 'hello'".

• You now have two ways of referring to the variable hello, either directly or as "the variable that x points to". Both the following instructions have the same effect:

  hello = -62;
  *x = -62;
  

  The instruction *x means "the variable that x refers to".

• You can easily make a variable point to something else, so:

  int goodbye = 107;
  x = &goodbye;
  *x = -62;
  cout << goodbye << endl;  // Now has the value -62.
  

  in this case, the same instruction *x = -62 changes the value of the variable goodbye, not hello.

Structures

• A structure is a way of grouping several different variables of the same or different types together and referring to them under a single name, a bit like an array that can hold different typed values.

• A structure is defined as follows:

  struct my_structure_name
  {
    int first; 
    double heresanothervariable;
    string yetanother;
    float anarrayaswell[56];
  };
  

  The structure type is called by the name you give it (after the word struct). The variables inside the structure (called member variables) are declared just like any other variables, but within curly brackets. Don't forget the semicolon after the closing curly bracket (I always do!)

• Now you can use your structure as any other variable type and declare variable from it:

  struct dog
  { string name;
    int year_of_birth;
    double height;
  };
  
  dog pet, guarddog, stray; // Variables of type dog
  

• Refer to the structure using a dot between the name of the variable and the name of the member variable:

  pet.name = "Dylan";
  guarddog.year_of_birth = 1990;
  

• You can declare arrays of structures, just as you can declare arrays of anything else:

  dog dalmatians[101];
  
  dalmatians[0].name = "Pongo";
  dalmatians[0].height = 75.5;
  // 99 of the dogs were born in the same year
  for (int i = 2; i < 101; i++)
    dalmatians[i].year_of_birth = 1996;
  

• You can also pass structures to arrays as parameters. They are referred to in the array using the name in the parameter list:

  void do_something (dog d)
  { cout << d.name << endl;  // Refer to dog as 'd' here
  }
  

File access

• Files contain data on the floppy disk, or hard disk or CD-ROM or whatever sort of disc you have.

• You can open a file for input or output, or even for both at the same time (but let's keep things simple here). Here's how you declare a file for input:

  #include <fstream.h>
  
  const char* fname = "mydata";
  ifstream f(fname);
  

  Notice that the file access commands are included in a header file which you must include. The name "mydata" is the file name on the disc (which can include full path names, extensions - the full works), and the instruction ifstream opens the file as an "input stream". And here is a file being opened for output (an "output stream"):

  const char* file2 = "c:\\MI5\\secrets.txt";
  ofstream filevar(file2);
  

  Note that path names must be specified using a double \\ character rather than a single one, as this is how you include a \ character in a string (A single one is used by the compiler to recognise control codes such as \n for a new line.

• Now that you have declared your file, you can use it just like cout for output streams, or cin for input streams:

  // This writes out to the file 'f' on the disc
  f << "The variable has the value " << x << endl;
  
  // This reads a variable from the file 'filevar' on the disc
  filevar >> temp_var;
  

• The operator >> suffers from the same limitation that cin suffered from, namely it only reads as far as spaces or tab characters. If you want to read an entire line from a file, spaces, tabs and all, use the file equivalent of getline:

  // Read a line from file 'filevar' to
  // string variable 'anothervariable'
  filevar.getline(anothervariable);
  

• When you have finished with reading and writing to and from files, don't forget to close them:

  filevar.close();
  f.close();
  

Go back	Top of the page	Main Menu	Go on