Константные методы классов. Константные объекты. Ключевое слово mutable

Опубликовано 02.04.2018 | Автор: admin

Иногда программисты описывают методы класса обозначая методам константность. Константы вообще полезно применять. Чтобы понимать, зачем нужны константные методы класса, прежде всего нужно понимать зачем вообще нужны константы:

Применение константности к обычной переменной даёт возможность защитить значение переменной от изменений.

Применение константности к методу класса даёт возможность защитить состояние некоторых данных класса от влияния метода на них.

Чтобы понять второе, надо посмотреть код:

//Листинг #1.1        Константные методы класса       clang
#include <iostream>

using namespace std;


class MyClass{
    int x;
public:
    void print() const{                 //константный метод класса
        cout << "x == " << x << '\n';
    }

    void set_x(int value){
        x = value;
    }
};


int main ()
{
  MyClass obj;
  obj.set_x(100);       //Записываем значение в x вовнутрь класса
  obj.print();          //выводим записанное в x класса значение на экран
}

//Листинг #1.1 Константные методы класса clang

#include <iostream>

using namespace std;

class MyClass{

int x;

public:

void print() const{ //константный метод класса

cout << "x == " << x << '\n';

}

void set_x(int value){

x = value;

}

};

int main ()

{

MyClass obj;

obj.set_x(100); //Записываем значение в x вовнутрь класса

obj.print(); //выводим записанное в x класса значение на экран

}

Есть методы записывающие (их ещё называют сеттерами) и методы читающие (геттеры). Если метод не должен влиять на состояние объекта, то такой метод имеет смысл делать константным.

Пусть мы ошиблись при написании кода, перепутали функцию и попробовали изменить x, принадлежащее классу, внутри функции читающей:

//Листинг #1.2        Константные методы класса       clang
#include <iostream>

using namespace std;


class MyClass{
    int x;
public:
    void print() const{                     //потому что const
        cout << "x == " << x << '\n';
         x = 100;         //Ошибка компиляции
    }
};


int main ()
{
  MyClass obj;
  obj.print();
}

//Листинг #1.2 Константные методы класса clang

#include <iostream>

using namespace std;

class MyClass{

int x;

public:

void print() const{ //потому что const

cout << "x == " << x << '\n';

x = 100; //Ошибка компиляции

}

};

int main ()

{

MyClass obj;

obj.print();

}

Конечно, сейчас эта ошибка выглядит нелепо и сама ситуация притянута за уши. Но сможете ли всегда знать, чисто читающая ли функция? Сама суть, надеюсь, ясна.

В целом, можно обозначать или саму переменную как константу, тогда изменять её не сможет ни один метод класса, или обозначать константный метод, чтобы разделять могущие изменять переменную класса методы и немогущие.

В некоторых случаях внутри класса требуется переменная, которая ни при каких обстоятельствах не должна становиться константной. Практически полезного примера я привести не могу. О мьютексах и хешах писать не смею. Поэтому приведён будет очень простой пример подсчёта числа вызова некоторой функции класса.

Для обозначения переменной класса быть всегда неконстантной используется ключевое слово С++ mutable

//Листинг 2     использование mutable           clang
     //Листинг #1        Константные методы класса       clang
#include <iostream>

using namespace std;


class MyClass{
    int x;
    mutable int count;      //переменная count имеет тип int и защищена от навешивания константности константными методами
public:
    void print() const{
        cout << count << ": ";
        cout << "x == " << x << '\n';
        count++;
    }

    void set_x(int value){
        x = value;
    }

    void set_count(int value){
        count = value;
    }

    void numbers_print_call() const{
        cout << "print was call ";      //Функция print вызывалась
        cout << count << '\n';          //count

        count++;
    }
};




int main ()
{
  MyClass obj;

  obj.set_x(20);
  obj.set_count(0);

  obj.print();      //вызываем один из методов класса несколько раз
  obj.print();
  obj.print();
  obj.print();


   obj.numbers_print_call();    //выводим число вызовов
}

//Листинг 2 использование mutable clang

//Листинг #1 Константные методы класса clang

#include <iostream>

using namespace std;

class MyClass{

int x;

mutable int count; //переменная count имеет тип int и защищена от навешивания константности константными методами

public:

void print() const{

cout << count << ": ";

cout << "x == " << x << '\n';

count++;

}

void set_x(int value){

x = value;

}

void set_count(int value){

count = value;

}

void numbers_print_call() const{

cout << "print was call "; //Функция print вызывалась

cout << count << '\n'; //count

count++;

}

};

int main ()

{

MyClass obj;

obj.set_x(20);

obj.set_count(0);

obj.print(); //вызываем один из методов класса несколько раз

obj.print();

obj.numbers_print_call(); //выводим число вызовов

}

В очень-очень старых компиляторах может не быть ключевого слова mutable, оно появилось где-то с 1992-го года. Пример #2 демонстрирует возможность исключить навешивания константности на переменную класса методом класса.

Но вернёмся к константным методам. От них может быть очень значимая польза.

У константного объекта могут быть вызваны только константные методы.

Константный объект — это неизменяемый экземпляр класса.

//Листинг #3.1        Константные объекты класса       clang
#include <iostream>
#include <string.h>

using namespace std;


class MyClass{
    char Caption[256];
public:
    MyClass(const char* name){
        strcpy(Caption, name);
    }
};


int main ()
{
  const MyClass obj1("Nikolay");        //Константный объект obj1
  const MyClass obj2("Wasia");          //Константный объект obj2
}

//Листинг #3.1 Константные объекты класса clang

#include <iostream>

#include <string.h>

using namespace std;

class MyClass{

char Caption[256];

public:

MyClass(const char* name){

strcpy(Caption, name);

}

};

int main ()

{

const MyClass obj1("Nikolay"); //Константный объект obj1

const MyClass obj2("Wasia"); //Константный объект obj2

}

Здесь используется конструктор класса. Вы должны понять, что константные объекты создаются также, как создаются константные переменные. Поскольку константные переменные требуют обязательной инициализации, я задействовал конструктор класса.

Смысл здесь такой, что если объект константный, то никакие его внутренние данные изменению не подлежат. Если данное класса заявлено mutable, то используя методы класса можно влиять на такое данное:

//Листинг #3.2        Константные объекты класса       clang
#include <iostream>
#include <string.h>

using namespace std;


class MyClass{
     char Caption[256];
public:
    MyClass(const char* name){
        strcpy(Caption, name);
    }

    /*ФУНКЦИЯ ВЫВОДА ЗНАЧЕНИЯ ОДНОГО ИЗ ДАННЫХ КЛАССА*/
    void print() const{             //Метод сделали константным
        cout << Caption << '\n';

    }
};


int main ()
{
  const MyClass obj1("Nikolay");        //Константный объект obj1

   obj1.print();     //У константного объекта вызывается константный метод. Всё работает

}

//Листинг #3.2 Константные объекты класса clang

#include <iostream>

#include <string.h>

using namespace std;

class MyClass{

char Caption[256];

public:

MyClass(const char* name){

strcpy(Caption, name);

}

/*ФУНКЦИЯ ВЫВОДА ЗНАЧЕНИЯ ОДНОГО ИЗ ДАННЫХ КЛАССА*/

void print() const{ //Метод сделали константным

cout << Caption << '\n';

}

};

int main ()

{

const MyClass obj1("Nikolay"); //Константный объект obj1

obj1.print(); //У константного объекта вызывается константный метод. Всё работает

}

Немного отвлечёмся от константных методов. Когда вы используете константные объекты, должны понимать, что в отличие от обычных переменных, в основном, менять их внутреннее состояние нельзя, но изменения некоторым данным объекту может быть позволено или использованием ключевого слова mutable или использованием ключевого слова static.

//Листинг #4.1         clang
#include <iostream>

using namespace std;

class MyClass{
     char x;             //Обычное данное
     mutable char y;     //мутабельное данное
     static char z;      //статическое данное
public:
    MyClass():x('x'),y('y'){}       //конструктор по умолчанию

    void print(){
        x--;        //Изменяем
        y--;
        z--;
        cout << "x == " << x << '\n';   //выводим на экран
        cout << "y == " << y << '\n';
        cout << "z == " << z << '\n';
    }
};

char MyClass::z = 'z';       //Записали значение в статическую переменную 'z'


int main ()
{
    MyClass obj;
    obj.print();
}

//Листинг #4.1 clang

#include <iostream>

using namespace std;

class MyClass{

char x; //Обычное данное

mutable char y; //мутабельное данное

static char z; //статическое данное

public:

MyClass():x('x'),y('y'){} //конструктор по умолчанию

void print(){

x--; //Изменяем

y--;

z--;

cout << "x == " << x << '\n'; //выводим на экран

cout << "y == " << y << '\n';

cout << "z == " << z << '\n';

}

};

char MyClass::z = 'z'; //Записали значение в статическую переменную 'z'

int main ()

{

MyClass obj;

obj.print();

}

В листинге #4.1 было отказано от константости вообще. Чтобы вам было проще проанализировать следующее:

    //Листинг #4.2         clang
#include <iostream>

using namespace std;

class MyClass{
     char x;             //Обычное данное
     mutable char y;     //мутабельное данное
     static char z;      //статическое данное
public:
    MyClass():x('x'),y('y'){}       //конструктор поумолчанию

    void print() const{
 //       x--;          //Поскольку не static и не mutable, а объект константный, так делать нельзя, обычные переменные изменениям не подлежат
        y--;
        z--;
        cout << "x == " << x << '\n';   //выводим на экран
        cout << "y == " << y << '\n';
        cout << "z == " << z << '\n';
    }
};

char MyClass::z = 'z';       //Записали значение в статическую переменную 'z'


int main ()
{
    const MyClass obj;
    obj.print();        //Хоть объект и константный, частично он будет изменён
}

//Листинг #4.2 clang

#include <iostream>

using namespace std;

class MyClass{

char x; //Обычное данное

mutable char y; //мутабельное данное

static char z; //статическое данное

public:

MyClass():x('x'),y('y'){} //конструктор поумолчанию

void print() const{

// x--; //Поскольку не static и не mutable, а объект константный, так делать нельзя, обычные переменные изменениям не подлежат

y--;

z--;

cout << "x == " << x << '\n'; //выводим на экран

cout << "y == " << y << '\n';

cout << "z == " << z << '\n';

}

};

char MyClass::z = 'z'; //Записали значение в статическую переменную 'z'

int main ()

{

const MyClass obj;

obj.print(); //Хоть объект и константный, частично он будет изменён

}

После прочтения этой статьи, в идеале, вы должны понимать как в коде задавать константные методы класса, различать константные методы класса и константные объекты класса, понимать, что иногда можно отказаться от константности данного (переменой из) класса, делая объект класса ограниченно константным.

Иногда не нужно навешивать константность данному класса методом класса. Само данное класса может быть объявлено константным изначально. Смотрим два кода: один для старых компиляторов, второй для современных.

//Листинг #5.1         clang
#include <iostream.h>
#include <conio.h>

class MyClass{
	  const int x;
public:
	 MyClass():x(100){}

	 void print() const{
		  cout << x << '\n';
	 }
};


int main ()
{
	 clrscr();
	 const MyClass obj;
	 obj.print();        //Хоть объект и константный, частично он будет изменён
	 cin.get();
	 return 0;
}

//Листинг #5.1 clang

#include <iostream.h>

#include <conio.h>

class MyClass{

const int x;

public:

MyClass():x(100){}

void print() const{

cout << x << '\n';

}

};

int main ()

{

clrscr();

const MyClass obj;

obj.print(); //Хоть объект и константный, частично он будет изменён

cin.get();

return 0;

}

//Листинг #5.2         clang
#include <iostream>

using namespace std;

class MyClass{
     const int x = 100;
public:
    void print() const{
        cout << x << '\n';
    }
};


int main ()
{
    const MyClass obj;
    obj.print();        //Хоть объект и константный, частично он будет изменён
}

//Листинг #5.2 clang

#include <iostream>

using namespace std;

class MyClass{

const int x = 100;

public:

void print() const{

cout << x << '\n';

}

};

int main ()

{

const MyClass obj;

obj.print(); //Хоть объект и константный, частично он будет изменён

}

Если эта статья оказалась полезной, вы смогли понять различия и что что делает, то это здорово.

Рубрика: Базовые знания, level "classer", Функции-члены классов

Константные методы классов. Константные объекты. Ключевое слово mutable

Добавить комментарий Отменить ответ

Поиск

Последние темы

Случайная книга в электронном формате

Последние комментарии

Мета