Classes in C++

Dr Ian Cornelius

Hello

Hello (1)

Learning Outcomes

Understand how to use classes in C++
Demonstrate the ability to use classes in C++

Headers and Source Files

Headers and Source Files (1)

C++ classes are split into two files:
- header file, with a .h file extension
- source file, with a .cpp file extension
Header file consists of the class definitions and function headers
Source file consists of the implementation of the functions
If the class implementation does not change, then the class will not need to be recompiled
- only classes that change will be recompiled

When it comes to using classes in C++, they are split into two files, and these are known as header and source files. Each type of file has their own file extension associated with it, in this case the header file has the .h extension, and the source file has a .cpp extension.

The header file would consist of the class definitions and the function headers. Whereas the source file would contain the implementation of the functions. This is particularly useful when it comes to compiling your source-code, as only files that have changes within them will need to be recompiled. This is especially useful when it comes to code or scripts where there are thousands upon thousands of lines and many files.

Header and Source Files (2)

Header Files i

These are files that end with the .h file extension
Contains the declaration of the following:
- variables
- function headers
These files are referenced to in the C++ implementation source file using #include
- i.e. #include "myfile.h"
The files for a header are plain-text and contain rules for defining syntax
Header files are useful for the following reasons:
1. Speeds up compilation
2. Keeps the code organised
3. Allows for the separation of the interface from the implementation

Let’s begin by looking at a header file closely. As I have mentioned previously, these are the files that end with the .h file extension, and contains declarations for the following:

variables: in the case of object-oriented programming, a class header file will consist of definitions for all the class level variables. These variables would be accessible across the implementation of the source code files.
function headers: all function headers will be declared in the header file to be accessible across multiple implementation source-code files.

The header files themselves are referenced to in the C++ source file by using the #include keyword. The files themselves are often plain-text and contain rules for defining the syntax of a script. They are most useful for speeding up compilation, keeping your code organised, and allow you to separate the interface of code from its implementation. Allowing you to easily follow one of the object-orientation principles known as polymorphism. If you cannot remember what object orientation is, and its four principles, you will want to revisit my lecture on this from the first year programming module.

Header and Source Files (3)

Header Files ii

Header files can cause complex errors
Generally when multiple header declarations from other files are included in the same file
- this will raise a compiler error
- it can be avoided by using header guards

#ifndef UNIQUE_NAME
#define UNIQUE_NAME
...
#endif

Preprocessing on compilation will check for header guards and their unique name
- if the header is repeatedly included in the same file, then the contents will be ignored

More often than not, header files can cause an array of problems and complex errors. This would generally happen when multiple header declarations from other files are included in a single file, This will often lead to compiler errors, and it can be mitigated by using something known as a header guard.

Header guards are a couple of lines located at the beginning of the file, and one at the very end, encompassing the code in that file. They are sometimes referred to as conditional compilation directives and ensure that errors do not arise when the same function or variable is defined more than once.

The unique name from the syntax provided on the screen is often the name of the file. For example, if our file was called myfile.h then our unique name would be MY_FILE_H.

Header and Source Files (4)

Source Files

These are files that end with the .cpp file extension
Known to be the implementation file
- contains the implementation of the functions declared in the header file
Source files help split the interface from the implementation

Header and Source Files (5)

Example: Header File

#ifndef EXAMPLE_FILE_H
#define EXAMPLE_FILE_H
#include <iostream>
#include <string>

class ExampleClass {
public:
  int intExample1;
  char get_char();
  string say_hello(int tmpInt);
private:
  char charExample1;
}

#endif //EXAMPLE_FILE_H

Example: Source File

#include "myfile.h"

std::string say_hello(int tmpExample) {
  return "Hello " + std::to_string(tmpExample);
}

char get_char() {
  return charExample1;
}

On the screen is an example of how a header file would look. For now, you can ignore the class definition, along with the public and private keywords as we shall be introducing these later on in this lecture. However, what you can see from this example is the structure of what a typical header file would look like. You can see that there is no source-code so to speak for any function declarations, i.e. get_char or any of the variables have been initialised with values. Instead, it’s the overall structure of our class, and will be concerned with the necessary details that are required for implementation in the source file.

On the right-hand-side of the screen, you will see an example of how the source-file would look for our header file. You can see from this example that we have provided the function body to our function headers. In order to do this, we first need to include the header file, which contains our function definitions.

You will notice in our header file that we included iostream and string to enable us to print to the terminal window, and use strings. This including has carried over into our source-file, and we are not required to include it again. Which means we can use std::to_string to convert our integer to a string for concatenation.

Classes

Classes (1)

Recap: Classes

Recap:
Classes provide a structure for the objects
They are used for defining:
- a set of properties, represented by variables
- the behaviour, which is represented by functions

classDiagram
  Dog <|-- GermanShepherd : extends
  Dog <|-- GoldenRetriever : extends

You were introduced to classes in the first year programming module. To refresh your memory, let’s revisit the introductory slides on what a class is. Classes can be used to provide a structure for developing objects. They can be used for defining a set of properties in the form of variables, and the behaviour of an object in the forms of a function.

Objects that have been created from these classes are referred to as an instance, or instances, depending upon the number of times an object has been created from the class. The process of creating an object is known as “instantiation”. An object will have a property, which, as you know, is a value that is associated with a real-world entity, such as a name or an age. For example, we may have a class dog and from this we can have multiple objects created for each type of breed, such as German Shepherd and Golden Retriever.

Classes (2)

Creating classes in C++ is different to Python
Source code is split between two files:
- header (.h)
- source (.cpp)
The header contains information about the variables and functions
The source contains the actual implementation of the functions
Classes will be defined using the class keyword followed by a name
The body of a class is defined inside a set of curly brackets ({}) and terminated by a semicolon (;)

class Student {
  ...
};

When it comes to creating classes in C++, it is completely different in comparison to Python. As we have touched upon earlier, the source-code is split between two files: a header and source file. The header file will contain information about the variables and functions, whilst the source will contain the implementation for the functions.

Just like Python, when it comes to creating a class in C++, it makes use of the class keyword. This is then followed by a set of curly brackets, and a semicolon at the end. Inside the curly brackets will be the body of our class, which we shall be discussing over the next few slides.

Classes (3)

Access Specifiers

Access specifiers control how members of a class are accessed
There are three access specifiers in C++:
- public: members are accessible outside the class
- private: members cannot be accessed (or viewed) outside the class
- protected: members cannot be accessed outside the class; but can be accessed with inheritance

class Lecturer {
  public:
    std::string name;
  private:
    int age;
  protected:
    std::string dateOfBirth;
};

One of the key differences with classes in C++ is the use of access modifiers. You will already be accustomed to the public and private access modifiers, as we can use these in Python. Remember, to create a private variable or function in Python, we just prepend two underscores to the name. In C++, it is a little different, we declare both the public and private specifiers. However, there is also an additional specifier, and this is protected.

Let’s have a look at each one of these, and see what they mean in C++:

public: these are functions or variables that can be accessed outside the class
private: these are functions or variables that cannot be accessed outside the class
protected: these are functions or variables that cannot be accessed outside the class, but they can be accessed with inheritance.

On the screen is an example of how you will declare the access specifiers when constructing your class.

Classes (4)

Creating an Object i

Recap:
- Objects are instances that are created from a class
- Objects created from classes will be referred as instance(s)
  - the process of creating an object from a class is instantiation
- Objects will have a property
  - a set of values that are associated with a real-world entity
- For example:
  - Class: Dog
  - Objects: German Shepherd, Golden Retriever

classDiagram
  Dog <|-- GermanShepherd : extends
  Dog <|-- GoldenRetriever : extends

Classes (5)

Creating an Object ii

An object can be created from the class by calling upon the class name
- followed by the name of the variable, i.e. Lectuer lecturer1;

#include <iostream>
class Lecturer {
  public:
    std::string name;
  private:
    int age;
};
int main() {
  Lecturer lecturer1;
  Lecturer lecturer2;
  lecturer1.name = "Ian Cornelius";
  lecturer2.name = "Terry Richards";
  std::cout << "lecturer1.name -> " << lecturer1.name << std::endl;
  std::cout << "lecturer2.name -> " << lecturer2.name << std::endl;
  return 0;
}

lecturer1.name -> Ian Cornelius
lecturer2.name -> Terry Richards

As you are aware, an object is an instance of a class. On the screen, you can see we have created our class called Lecturer and from this class we have created two objects, one object for myself, Ian Cornelius and another object for Terry Richards. These are referred to as instances of a class, and a process is known as instantiation.

Each object will have a set of properties that are assigned to them. Think of these as the variables that you have declared inside your class. Looking back at our Lecturer class, we can see that the properties in this case are the name and age of a lecturer.

Classes (6)

Class Constructors

Recap:
- Constructors are a special type of function and is called automatically when an object is created
- They have the same name as the class and do not return a type

class Lecturer {
  public:
    Lecturer() {
      ...
    }
};

Class constructors are used when an object is created in C++, and they are useful for passing through arguments of an object and assigning them to their appropriate class variables. In The previous example, we were setting the name of lecturer by calling the variable directly on the instance of the class. However, if we were to try and access the age variable to set a value it would not be allowed, as it was private.

However, with a class constructor, when we initially create our object, we can pass through arguments for the name and age variables, and set them as necessary. In this case, we can interact with our private variable and set the age of our lecturer.

Classes (7)

Default Constructors

Constructors with no parameters are known as a default constructor
A class Lecturer has been created
- the default constructor sets the name and age of the lecturer
An object is created and the variable name is accessed
- the name of the lecturer is returned
- the age of the lecturer cannot be accessed as it is private

#include <iostream>
class Lecturer {
  public:
    std::string name;
    Lecturer() {
      name = "Ian Cornelius";
      age = 34;
    }
  private:
    int age;
};
int main() {
  Lecturer lecturer1;
  std::cout << "lecturer1.name -> " << lecturer1.name << std::endl;
  return 0;
}

lecturer1.name -> Ian Cornelius

When it comes to creating constructors in C++, we can use a method known as default constructors, and they will have no parameters associated with them. To create a default constructor, inside our class, and the public access specifier, we need to provide the name of our class again, followed by two round brackets and a set of curly brackets. Inside the set of curly brackets, we can then write code for the body of our constructor.

Typically, code inside the body of our constructor would be used to apply values to our variables, and/or execute some code when the object instance is created. In this case, inside our default constructor, we can set the name and age of our lecturer. Therefore, I have decided to hardcode some values for the name of our lecturer, as we are unable to use any parameters.

Therefore, when we create an object, the object will be created with these default values, and you can see that when we access the name variable it returns the name of our student. However, we still cannot access the age variable as it is still considered to be private. But! Because we have a default constructor inside our class definition, we can actually set the variable age to hold a value, and in this case I have provided 34.

Classes (8)

Parameterised Constructors

Constructors with parameters are known as a parameterised constructor
A class Lecturer has been created
- the parameterised constructor sets the name and age of the lecturer
The variable name is accessed
- the name of the lecturer is returned
- the age of the lecturer cannot be accessed as it is private

#include <iostream>
class Lecturer {
  public:
    std::string name;
    Lecturer(std::string _name, int _age) {
      name = _name;
      age = _age;
    }
  private:
    int age;
};
int main() {
  Lecturer lecturer1("Ian Cornelius", 34);
  Lecturer lecturer2("Terry Richards", -1);
  std::cout << "lecturer1.name -> " << lecturer1.name << std::endl;
  std::cout << "lecturer2.name -> " << lecturer2.name << std::endl;
  return 0;
}

lecturer1.name -> Ian Cornelius
lecturer2.name -> Terry Richards

Another method of building your classes is by using a parameterised constructor, and this will allow you to pass through arguments on the initial construction of the object. However, before we can begin initialising our object, we need to create our constructor in the class. To do this, the process is the same as a default constructor, but instead we are going to be adding some parameters to our constructor header, which means we need to add some things between our round brackets.

You will see from the example on the right-hand-side of the screen, that our constructor accepts two parameters. One for the name, and the other for our age. As we are writing code in C++, we must ensure that we supply the appropriate data types before the variable name. In this case, the _name and _age have both been prepended with string and int, respectively.

You will want to take notice of how I have named my parameter variables. I have prefixed them with an underscore, to denote that these are my parameter variable names. This is because the actual variable names of the class are very similar, with both of them being name and age respectively.

When it comes to creating our object, we are now required to pass through some arguments. You will see in our code example, that when I create the object named lectuer1, I have passed through two argumentS: Ian Cornelius and 34. This will then create an object and store those values in their respective variables for the class. You can also see from my example that I have managed to create a second object from the class, and this time I have populated the arguments with the values: Terry Richards and -1.

Because I have used parameters in the constructor of our class, it means that we can create objects with different values for our variables. This is a key difference compared to a default constructor, whereby I was hardcoding values into it, and therefore two objects with the same variables would have been created.

Just like our default constructor method, when we use our parameterized constructor, we are able to populate our age variable, although it has been specified as private. However, this still means that we are unable to access the variable when using our print function.

Classes (9)

Class Functions

Classes can also consist of functions, and they will belong to the object that is created
A class Lecturer has been created
- the parameterised constructor sets the name and age of the student
The function greeting() is accessed on the lecturer1 object

#include <iostream>
class Lecturer {
  public:
    std::string name;
    Lecturer(std::string _name, int _age) {
      name = _name;
      age = _age;
    }
    std::string greeting() {
      return "Hello " + name + ", and welcome to 5062CEM!";
    }
  private:
    int age;
};
int main() {
  Lecturer lecturer1("Ian Cornelius", 34);
  std::cout << "lecturer1.greeting() -> " << lecturer1.greeting() << std::endl;
  return 0;
}

lecturer1.greeting() -> Hello Ian Cornelius, and welcome to 5062CEM!

You should already be familiar with the concept that classes can have functions, and these functions will belong to the object that was created. For this example, we shall build upon our Lecturer class and provide a function that can return a greeting to the person.

You will see in our code example on the right-hand-side of the screen, that I have provided a function called greeting. The return type of this function is string and it should therefore give you a clue on what will be returned from the function.

In this instance, the function is returning a string that greets the person and welcomes them to the module. You will see from the string that the name variable is being concatenated (or joined) to our string. Unlike Python, we can just refer to the name of our variable and not use a keyword such as self in order to access it.

When we create our Lecturer object, we pass through the name of lecturer and the age, in this case, Ian Cornelius and 34, respectively. We can then call our function on the created object, lecturer1, by appending a . followed by the name of our function and a set of round brackets.

When this function is called, it will return the greeting, “Hello Ian Cornelius, and welcome to 5062CEM!”, as you can see in the blue box on the screen.

Classes (10)

Accessing and Modifying Private Members i

The variable age in this class is private
There is no method of accessing this variable outside the class
- therefore, a method of accessing and modifying this variable is required
It can be achieved by creating a function inside the class

class Lecturer {
  public:
    std::string name;
    Lecturer(std::string _name, int _age) {
      name = _name;
      age = _age;
    }
  private:
    int age;
};

As it stands, each of the examples we have discussed so far has been unable to access the age variable, and this is because the variable has been created under the private access specifier. There is strictly no method of accessing this variable outside the class. Therefore, you are required to provide a method in order to access and modify this variable, once it has been set using a constructor.

To do this, we can create a set of functions in our class, which would allow us to access and modify the variable, but also extract the necessary information. This is often referred to as a getter and setter method, and you were introduced to this in the first year programming module.

Classes (11)

Accessing and Modifying Private Members ii

A class Lecturer has been created
- the parameterised constructor sets the name and age of the student
The function get_age() is accessed on the lecturer1 object
- access the private variable to return the age of the student
The function change_age() is accessed on the lecturer object
- changes the private variable to a new age

#include <iostream>
class Lecturer {
  public:
    std::string name;
    Lecturer(std::string _name, int _age) {
      name = _name;
      age = _age;
    }
    int get_age() {
      return age;
    }
    void change_age(int _age) {
      age = _age;
    }
  private:
    int age;
};
int main() {
  Lecturer lecturer1("Ian Cornelius", 34);
  std::cout << "lecturer1.get_age() -> " << lecturer1.get_age() << std::endl;
  lecturer1.change_age(-9);
  std::cout << "lecturer1.get_age() -> " << lecturer1.get_age() << std::endl;
  return 0;
}

lecturer1.get_age() -> 34
lecturer1.get_age() -> -9

You were introduced to the method of getters and setters in the previous slide to retrieve and change the values of private variables. On this slide, we shall have a look at an example of how this can be achieved.

You will see from the code on the right-hand-side that two functions have been implemented. One called, get_age and the other change_age, which as the name suggests have been designed to get the age of a lecturer and also change the age.

The get_age function has an int return type, as it is concerned with getting the value of the age variable which is stored as an integer. The function is concerned with returning the value that is stored in this variable.

The change_age function accepts a single argument, known as _age. Inside the function, the age variable is reassigned with the new value that has been passed through from our argument. This process allows us to circumvent the private nature of the age variable, and reassign the values for it outside our class.

When it comes to creating the instance of the class, we can follow the same process as before. We call the class name, Lecturer, followed by the name of a variable and a set of round brackets. Inside the set of round brackets, we then provide the argument for our object. In this case, I am creating a version of myself, and as such I provide my name and age.

Now for the interesting part, and retrieving the age of our object. To do this, we can call the gwt_age function on the object we have just created, which was called lecturer1. As you can see from the output on the screen, when we call this function it returns the age 34.

Right now, we have been able to access the age of our lecturer. But how would we go about changing it? Well in this case, we can use the function we created earlier, called change_age. This function, as you should recall, accepts an integer argument, which will then be passed through and change the value of our private variable age. In this example, I have passed through the value -9. To confirm whether this change has been made, we can use the get_age function once again. This time, we can see that the age of our lecturer has been returned, and it has changed. Instead of 34 being returned to us, we get the value -9.

Classes (12)

Class Inheritance i

Recap:
Inheritance allows you to define a class that will inherit all the functions and properties from another class
There are two important terminologies to know:
- parent class which is the class from which another class is being inherited from
- child class which is the class that is inherited from the parent class
Inheriting a class in C++ can be achieved with the colon (:) character

class childClass : accessSpecifier parentClass {
...
}

The concept of inheritance was taught in the first year programming module, and it carries over into C++. However, as you may have seen, the process of inheriting a class is slightly different in C++ compared to Python. Before we look at the difference, we shall first recap what is meant by inheritance.

Inheritance allows you to define a class and inherit all the functions and properties from another class. Just to reaffirm these terminologies, a parent class is the main class from which another class can be inherited from and this is sometimes referred to as the base class. On the other hand, the child class is a class that is inherited from the parent class and this may sometimes be referred to as the derived class.

When it comes to inheriting a class, the syntax is different to Python, and C++ uses the colon character. On the screen, is the structure as to how you would inherit a class. Firstly, we begin with creating our class using the class keyword, followed by the name for the child class. The colon is then used, and the name of the parent class we are inheriting from is provided. This will be prefixed with an access specifier, which you should call could be one of the following: public, private and protected.

Classes (13)

Creating a Parent and Child Class

Any class you create in C++ can be a parent class
- the syntax is the same as creating any other class
A child class is created by include the parent class after the colon when creating the child class
- the child class will inherit all properties and functions of the parent class

#include <iostream>
// Parent Class
class Person {
  public:
    std::string name;
    Person(std::string _name, int _age) {
      name = _name;
      age = _age;
    }
  protected:
    int age;
};
// Child Class
class Lecturer : public Person {
  public:
    using Person::Person;
    int get_age() {
      return age;
    }
    void change_age(int _age) {
      age = _age;
    }
};
int main() {
  Lecturer lecturer1("Ian Cornelius", 34);
  std::cout << "lecturer1.name -> " << lecturer1.name << std::endl;
  std::cout << "lecturer1.get_age() -> " << lecturer1.get_age() << std::endl;
  return 0;
}

lecturer1.name -> Ian Cornelius
lecturer1.get_age() -> 34

Any class you create in C++ can be considered to be a parent class, and as such, a child class can be derived from it. A parent class has the same syntax as any other class creation, but the child class itself is a little different. The child class is created by including the parent class after the colon character. This will then enable it to inherit all the properties and functions of the parent class.

For this example, I have made some changes to my classes from earlier. Instead of having the lecturer holding variables name and age, they have instead been moved to a class called Person. This class will now be my parent class whereby I can inherit the variables in any future child classes. Inside my class Person, I have provided a parameterized constructor which would enable us to pass through arguments such as name and age to set the values of the respective variables.

When it comes to creating our child class, called Lecturer we want to inherit these variables, so we can use them in our child class. Therefore, when I create my class Lecturer I use a colon, followed by the keyword public and the name of our parent class, which is Person, to inherit these variables.

Inside our new Lecturer class, I need to carry over our constructor, and this can be achieved by using the using keyword, followed by the parent’s class name, two colons, and the parent’s class name again. A little confusing, but it ensures that the constructor can be called upon our class Lecturer without having to re-create it. The class Lecturer also contains the functions we created earlier to get the age, or change the age of a lecturer.

When it comes to creating an object of our class Lecturer, the proces is the same as before. We call the class name, Lecturer, followed by the name of a variable and a set of round brackets. Inside the set of round brackets, we then provide the arguments for our object. In this case, I am creating a version of myself, and as such I provide my name and age. We can then access the properties such as the variable name and the function get_age() by calling these upon the object, leturer1.

As you can see from the output, the name of our lecturer was returned, and we can see that the variable name is not within the scope of our Lecturer class. This is because it has inherited the variables from the parent class which was named Person.

Goodbye

Goodbye (1)

Questions and Support

Questions? Post them on the Community Page on Aula
Additional Support? Visit the Module Support Page
Contact Details:
- Dr Ian Cornelius, ab6459@coventry.ac.uk