C++ - Tutorial 007. Classes

C++, class

The availability of data that is publicly available in the structure has its advantages, providing complete freedom of action. However, we may want to hide the variables that are used in the data type to make the type behavior more predictable and easier to modify, and also that its usage is more like using a fundamental data type. To do this, you must define the interaction of the data type interface with access to inaccessible variables in the class.

In C ++, these types of data are called classes. A class has such a set of components as variables and methods for accessing the class's functionality.

The following sections can be defined in the class interface:

• public - Methods and variables are available for interaction from outside the class;
• protected - Methods and variables are available for use within the class, as well as in classes inherited from this class;
• private - Methods and variables are available for use only within a class

However, private variables can be accessed externally using public methods.

In structures , you can also define private, protected, and public sections. The difference between structures and classes in this case is that by default all members of structures (variables, methods) are public, whereas in the class members are in the private section.

Let's see how the Vector class can look like, which was declared as a structure in the previous article .

class Vector 
{
public:
    Vector(int s) 
        : elem {new double[s]}, 
          sz{s} 
    { }

    double& operator[](int i) { return elem[i]; }
    int size() { return sz; }

private:
    double∗ elem; // Pointer to elements
    int sz; // Number of elements
};

Define a variable of class Vector .

Vector v(6); // Vector of six elements

Graphically, Vector can be represented thus:

In principle, Vector is an object that describes the work with a pointer to an array of elements and their magnitude. Different Vector objects can have different number of elements and their value, but the size of the Vector object will always be the same, since it stores only the pointer and the integer size of the array size.

Since the array of elements is now in the private section. That access to its elements will be made through the overloaded operator of square brackets [] , and to the size of the array via the size() method.

double read_and_sum(int s)
{
    Vector v(s);  // Create a vector of elements
    for (int i=0; i!=v.size(); ++i)
        cin>>v[i];  // We read the elements from the input and write them into the vector

    double sum = 0;
    for (int i=0; i!=v.size(); ++i)
        sum+=v[i];  // Summarize the elements
    return sum;
}

In the Vector class, there is a function with the same name as Vector(int) . This function is a Vector constructor that performs the necessary initialization actions for the object while it is being created. A class can have multiple constructors.

Vector(int s) 
    : elem {new double[s]}, 
      sz{s} 
{ }

In the constructor, the elements are initialized using the initializer list , which is an element of the C++11 standard.

It does not show the error handling mechanism and work with the destructor, but more on this later.