An abstract data type (ADT) is a type that consists of a collection of data and associated operations for manipulating the data. The ADT will only mention the list of operations that can be performed but not the implementation. The implementation itself is hidden, which is why it's called abstract.
Imagine we have a DVD player we usually use in our pleasure time. The player has a remote control, too. The remote control has various menu buttons such as ejecting the disc, playing or stopping the video, increasing or decreasing volume, and so forth. Similar to the ADT, we don't have any idea how the player increases the volume when we press the increasing button (similar to the operation in ADT). We just call the increasing operation and then the player does it for us; we do not need to know the implementation of that operation.
Regarding the process flow, we need to take into account the ADT's implement abstraction, information hiding, and encapsulation techniques. The explanation of these three techniques is as follows:
- Abstraction is hiding the implementation details of the operations that are available in the ADT
- Information hiding is hiding the data which is being affected by that implementation
- Encapsulation is grouping all similar data and functions into a group
Classes are containers for variables and the operations (methods) that will affect the variables. As we discussed earlier, as ADTs implement encapsulation techniques for grouping all similar data and functions into a group, the classes can also be applied to group them. A class has three access control sections for wrapping the data and methods, and they are:
- Public: Data and methods can be accessed by any user of the class
- Protected: Data and methods can only be accessed by class methods, derived classes, and friends
- Private: Data and methods can only be accessed by class methods and friends
Let's go back to the definition of abstraction and information hiding in the previous section. We can implement abstraction by using protected or private keywords to hide the methods from outside the class and implement the information hiding by using a protected or private keyword to hide the data from outside the class.
Now, let's build a simple class named Animal, as shown in the following code snippet:
class Animal
{
private:
string m_name;
public:
void GiveName(string name)
{
m_name = name;
}
string GetName()
{
return m_name;
}
};As we can see in the preceding code snippet, we cannot access the m_name variable directly since we assigned it as private. However, we have two public methods to access the variable from the inside class. The GiveName() methods will modify the m_name value, and the GetName() methods will return the m_name value. The following is the code to consume the Animal class:
// Simple_Class.cbp
#include <iostream>
using namespace std;
class Animal
{
private:
string m_name;
public:
void GiveName(string name)
{
m_name = name;
}
string GetName()
{
return m_name;
}
};
int main()
{
Animal dog = Animal();
dog.GiveName("dog");
cout << "Hi, I'm a " << dog.GetName() << endl;
return 0;
}In the preceding code, we created a variable named dog of the type Animal. Since then, the dog has the ability that Animal has, such as invoking the GiveName() and GetName() methods. The following is the window we should see if we build and run the code:
Now, we can say that Animal ADT has two functions, and they are GiveName(string name) and GetName().
After discussing simple class, you might see that there's a similarity between structs and classes. They both actually have similar behaviors. The differences are, however, that structs have the default public members, while classes have the default private members. I personally recommend using structs as data structures only (they don't have any methods in them) and using classes to build the ADTs.
As we can see in the preceding code, we assign the variable to the instance of the Animal class by using its constructor, which is shown as follows:
Animal dog = Animal();
However, we can initialize a class data member by using a class constructor. The constructor name is the same as the class name. Let's refactor our preceding Animal class so it has a constructor. The refactored code should be as follows:
// Constructor.cbp
#include <iostream>
using namespace std;
class Animal
{
private:
string m_name;
public:
Animal(string name) : m_name(name)
{
}
string GetName()
{
return m_name;
}
};
int main()
{
Animal dog = Animal("dog");
cout << "Hi, I'm a " << dog.GetName() << endl;
return 0;
}As we can see in the preceding code, when we define the dog variable, we also initialize the m_name private variable of the class. We don't need the GiveName() method anymore to assign the private variable. Indeed, we will get the same output again if we build and run the preceding code.
In the preceding code, we assign dog as the Animal data type. However, we can also derive a new class based on the base class. By deriving from the base class, the derived class will also have the behavior that the base class has. Let's refactor the Animal class again. We will add a virtual method named MakeSound(). The virtual method is a method that has no implementation yet, and only has the definition (also known as the interface). The derived class has to add the implementation to the virtual method using the override keyword, or else the compiler will complain. After we have a new Animal class, we will make a class named Dog that derives from the Animal class. The code should be as follows:
// Derived_Class.cbp
#include <iostream>
using namespace std;
class Animal
{
private:
string m_name;
public:
Animal(string name) : m_name(name)
{
}
// The interface that has to be implemented
// in derived class
virtual string MakeSound() = 0;
string GetName()
{
return m_name;
}
};
class Dog : public Animal
{
public:
// Forward the constructor arguments
Dog(string name) : Animal(name) {}
// here we implement the interface
string MakeSound() override
{
return "woof-woof!";
}
};
int main()
{
Dog dog = Dog("Bulldog");
cout << dog.GetName() << " is barking: ";
cout << dog.MakeSound() << endl;
return 0;
}Now, we have two classes, the Animal class (as the base class) and the Dog class (as the derived class). As shown in the preceding code, the Dog class has to implement the MakeSound() method since it has been defined as a virtual method in the Animal class. The instance of the Dog class can also invoke the GetName() method, even though it's not implemented inside the Dog class since the derived class derives all base class behavior. If we run the preceding code, we will see the following console window:
Again, we can say that the Dog ADT has two functions, and they are the GetName() and MakeSound() functions.
Another necessary requirement of ADT is that it has to be able to control all copy operations to avoid dynamic memory aliasing problems caused by shallow copying (some members of the copy may reference the same objects as the original). For this purpose, we can use assignment operator overloading. As the sample, we will refactor the Dog class so it now has the copy assignment operator. The code should be as follows:
// Assignment_Operator_Overload.cbp
#include <iostream>
using namespace std;
class Animal
{
protected:
string m_name;
public:
Animal(string name) : m_name(name)
{
}
// The interface that has to be implemented
// in derived class
virtual string MakeSound() = 0;
string GetName()
{
return m_name;
}
};
class Dog : public Animal
{
public:
// Forward the constructor arguments
Dog(string name) : Animal(name) {}
// Copy assignment operator overloading
void operator = (const Dog &D)
{
m_name = D.m_name;
}
// here we implement the interface
string MakeSound() override
{
return "woof-woof!";
}
};
int main()
{
Dog dog = Dog("Bulldog");
cout << dog.GetName() << " is barking: ";
cout << dog.MakeSound() << endl;
Dog dog2 = dog;
cout << dog2.GetName() << " is barking: ";
cout << dog2.MakeSound() << endl;
return 0;
}We have added a copy assignment operator which is overloading in the Dog class. However, since we tried to access the m_name variable in the base class from the derived class, we need to make m_nameprotected instead of private. In the main() method, when we copy dog to dog2 in Dog dog2 = dog;, we can ensure that it's not a shallow copy.
Now, let's play with the templates. The templates are the features that allow the functions and classes to operate with generic types. It makes a function or class work on many different data types without having to be rewritten for each one. Using the template, we can build various data types, which we will discuss later in this book.
Suppose we have another class that is derived from the Animal class, for instance, Cat. We are going to make a function that will invoke the GetName() and MakeSound() methods for both the Dog and Cat instances. Without creating two separated functions, we can use the template, which is shown as follows:
// Function_Templates.cbp
#include <iostream>
using namespace std;
class Animal
{
protected:
string m_name;
public:
Animal(string name) : m_name(name)
{
}
// The interface that has to be implemented
// in derived class
virtual string MakeSound() = 0;
string GetName()
{
return m_name;
}
};
class Dog : public Animal
{
public:
// Forward the constructor arguments
Dog(string name) : Animal(name) {}
// Copy assignment operator overloading
void operator = (const Dog &D)
{
m_name = D.m_name;
}
// here we implement the interface
string MakeSound() override
{
return "woof-woof!";
}
};
class Cat : public Animal
{
public:
// Forward the constructor arguments
Cat(string name) : Animal(name) {}
// Copy assignment operator overloading
void operator = (const Cat &D)
{
m_name = D.m_name;
}
// here we implement the interface
string MakeSound() override
{
return "meow-meow!";
}
};
template<typename T>
void GetNameAndMakeSound(T& theAnimal)
{
cout << theAnimal.GetName() << " goes ";
cout << theAnimal.MakeSound() << endl;
}
int main()
{
Dog dog = Dog("Bulldog");
GetNameAndMakeSound(dog);
Cat cat = Cat("Persian Cat");
GetNameAndMakeSound(cat);
return 0;
}From the preceding code, we can see that we can pass both the Dog and Cat data types to the GetNameAndMakeSound() function since we have defined the <typename T> template before the function definition. The typename is a keyword in C++, which is used to write a template. The keyword is used for specifying that a symbol in a template definition or declaration is a type (in the preceding example, the symbol is T). As a result, the function becomes generic and can accept various data types, and if we build and run the preceding code, we will be shown the following console window:
Please ensure that the data type we pass to the generic function has the ability to do all the operation invoking from the generic function. However, the compiler will compile if the data type we pass does not have the expected operation. In the preceding function template example, we need to pass a data type that is an instance of the Animal class, so we can pass either instance of the Animal class or an instance of a derived class of the Animal class.
Similar to the function template, the class template is used to build a generic class that can accept various data types. Let's refactor the preceding Function_Template.cbp code by adding a new class template. The code should be as follows:
// Class_Templates.cbp
#include <iostream>
using namespace std;
class Animal
{
protected:
string m_name;
public:
Animal(string name) : m_name(name)
{
}
// The interface that has to be implemented
// in derived class
virtual string MakeSound() = 0;
string GetName()
{
return m_name;
}
};
class Dog : public Animal
{
public:
// Forward the constructor arguments
Dog(string name) : Animal(name) {}
// Copy assignment operator overloading
void operator = (const Dog &D)
{
m_name = D.m_name;
}
// here we implement the interface
string MakeSound() override
{
return "woof-woof!";
}
};
class Cat : public Animal
{
public:
// Forward the constructor arguments
Cat(string name) : Animal(name) {}
// Copy assignment operator overloading
void operator = (const Cat &D)
{
m_name = D.m_name;
}
// here we implement the interface
string MakeSound() override
{
return "meow-meow!";
}
};
template<typename T>
void GetNameAndMakeSound(T& theAnimal)
{
cout << theAnimal.GetName() << " goes ";
cout << theAnimal.MakeSound() << endl;
}
template <typename T>
class AnimalTemplate
{
private:
T m_animal;
public:
AnimalTemplate(T animal) : m_animal(animal) {}
void GetNameAndMakeSound()
{
cout << m_animal.GetName() << " goes ";
cout << m_animal.MakeSound() << endl;
}
};
int main()
{
Dog dog = Dog("Bulldog");
AnimalTemplate<Dog> dogTemplate(dog);
dogTemplate.GetNameAndMakeSound();
Cat cat = Cat("Persian Cat");
AnimalTemplate<Cat> catTemplate(cat);
catTemplate.GetNameAndMakeSound();
return 0;
}As we can see in the preceding code, we have a new class named AnimalTemplate. It's a template class and it can be used by any data type. However, we have to define the data type in the angle bracket, as we can see in the preceding code, when we use the instances dogTemplate and catTemplate. If we build and run the code, we will get the same output as we did for the Function_Template.cbp code.
C++ programming has another powerful feature regarding the use of template classes, which is the Standard Template Library. It's a set of class templates to provide all functions that are commonly used in manipulating various data structures. There are four components that build the STL, and they are algorithms, containers, iterators, and functions. Now, let's look at these components further.
Algorithms are used on ranges of elements, such as sorting and searching. The sorting algorithm is used to arrange the elements, both in ascending and descending order. The searching algorithm is used to look for a specific value from the ranges of elements.
Containers are used to store objects and data. The common container that is widely used is vector. The vector is similar to an array, except it has the ability to resize itself automatically when an element is inserted or deleted.
Iterators are used to work upon a sequence of values. Each container has its own iterator. For instance, there are begin(), end(), rbegin(), and rend() functions in the vector container.
Functions are used to overload the existing function. The instance of this component is called a functor, or function object. The functor is defined as a pointer of a function where we can parameterize the existing function.
We are not building any code in this section since we just need to know that the STL is a powerful library in C++ and that it exists, fortunately. We are going to discuss the STL deeper in the following chapters while we construct data structures.