Значения, возвращаемые операцией

Функция operator++() программы C0UNTPP1 имеет небольшой дефект. Вы можете его выявить, если используете в функции main() строку, похожую на эту:

C1 = ++С2;

Компилятор будет протестовать. Почему? Просто потому, что мы определи­ли тип void для возвращаемого значения функции operator++(). А в нашем выра­жении присваивания будет запрошена переменная типа Counter. То-есть компи­лятор запросит значение переменной с2, после того как она будет обработана операцией ++, и присвоит ее значение переменной cl. Но, при данном нами оп­ределении в C0UNTPP1, мы не можем использовать ++ для увеличения объекта Counter в выражении присваивания: с таким операндом может быть использо­вана только операция ++. Конечно, обыкновенная операция ++, примененная к данным таких типов, как int, не столкнется с этими проблемами.

 Для того чтобы иметь возможность использовать написанный нами operator++() в выражениях присваивания, нам необходимо правильно определить тип его воз­вращаемого значения. Это сделано в следующей нашей программе C0UNTPP2.

// countpp2.cpp

// операция ++. возвращающий значение

#include <iostream>

using namespace std;

///////////////////////////////////////////////////////////

class Counter

{

private:

unsigned int count;

public:

Counter (): count (0) { }

unsigned int get_count ()

{ return count; }

Counter operator++ ()

{

++count;

Counter temp;

temp.count = count;

return temp;

}

};

///////////////////////////////////////////////////////////

int main ()

{

Counter cl, c2; // определяем переменные

cout << "\ncl = " << cl.get_count (); // выводим на экран

cout << "\nc2 = " << c2.get_count ();

++cl; // увеличиваем cl

c2 = ++cl; // cl=2, c2=2

cout << "\ncl = " << cl.get_count (); // снова показываем значения

cout << "\nc2 = " << c2.get_count () << endl;

return 0;

}

Здесь функция operator++() создает новый объект класса Counter, назван­ный temp, для использования его в качестве возвращаемого значения. Она сна­чала увеличивает переменную count в своем объекте, а затем создает объект temp и присваивает ему значение count, то же значение, что и в собственном объекте. В конце функция возвращает объект temp. Получаем ожидаемый эф­фект. Выражение типа

++cl

теперь возвращает значение, которое можно использовать в других выражениях, таких, как:

с2 = ++cl:

как показано в функции main(), где значение, возвращаемое cl++, присваивает­ся с2. Результат работы этой программы будет следующим:

cl = О с2 - О cl - 2

с2 = 2

 

Временные безымянные объекты

В примере C0UNTPP2 мы создали временный объект temp типа Counter, чьей един­ственной целью было хранение возвращаемого значения для операции ++. Реа­лизация этого объекта потребовала трех строк программы:

Counter temp;  // временный объект Counter

temp.count = count: // присваиваем ему значение count
return temp: // возвращаем объект

Существует много путей возвращения временного объекта из функции или перегруженной операции. Давайте рассмотрим еще один из способов в програм­ме C0UNTPP3:

// countpp3.cpp

// операция ++ с использованием недекларированной переменной

# include < iostream >

using namespace std;

///////////////////////////////////////////////////////////

class Counter

{

private:

unsigned int count;

public:

    Counter (): count (0) { }

Counter (int с): count (с) { }

unsigned int get_count ()

{ return count; }

Counter operator++ ()

{

++count;

return Counter (count);

}

};

///////////////////////////////////////////////////////////

int main ()

{

Counter cl, c2; // определяем переменные

cout << "\ncl = " << cl.get_count (); // выводим на зкран

cout << "\nc2 = " << c2.get_count ();

++cl; // увеличиваем cl

c2 = ++cl; // cl-2. c2=2

cout << "\ncl = " << cl.get_count ();// снова показываем значения

cout << "\n с 2 = " << c2.get_count () << endl;

return 0;

}

В строке этой программы return Counter (count):

происходят все те же действия, которые в программе C0UNTPP2 занимали три строки. Здесь создается объект типа Counter. Он не имеет имени, так как оно ни­где не будет использоваться. Этот объект инициализируется значением, полу­ченным в виде параметра count.

Но постойте: требуется ли здесь конструктор с одним аргументом? Да, тре­буется. Поэтому мы вставили этот конструктор в список методов класса в про­грамме C0UNTPP3.

Counter (int с): count (с) { }

Объект, инициализированный значением count, может быть возвращен функ­цией. Результат работы этой программы тот же, что и программы C0UNTPP2.

В обеих программах использовано создание копии исходного объекта (объ­екта, для которого вызывается функция), эта копия затем и возвращается функ­цией.

 

Постфиксные операции

До сих пор мы применяли операцию увеличения, используя только префиксную запись:

++cl

А как можно использовать постфиксную запись, где переменная увеличива­ется после того, как ее значение было использовано в выражении?

cl++

Чтобы иметь возможность работать с двумя версиями операции, мы опреде­лим два варианта перегрузки операции ++. Это показано в программе POSTFIX.

// postfix.срр

// префиксная и постфиксная операции ++ для нашего класса

#include <iostream>

using namespace std;

///////////////////////////////////////////////////////////

class Counter

{

private:

unsigned int count;

public:

    Counter (): count (0) { }

Counter (int с): count (с)

{}

unsigned int get_count ()

{ return count; }

Counter operator++ ()

{

return Counter (++count);

}

Counter operator++ (int) {

return Counter (count++);

}

};

///////////////////////////////////////////////////////////

int main ()

{

Counter cl, c2; // определяем переменные

cout << "\ncl = " << cl.get_count (); // выводим на экран

cout << "\nc2 = " << c2.get_count ();

++cl; // увеличиваем cl

c2 = ++cl; // cl=2, c2=2

cout << "\ncl = " << cl.get_count (); // снова показываем значения

cout << "\nc2 = " << c2.get_count ();

c2 = cl++;

cout << "\ncl = " << cl.get_count (); //и снова

cout << "\nc2 = " << c2.get_count () << endl;

return 0;

}

Теперь у нас есть два типа объявления функции operator++. С одной из них, для префиксной операции, мы уже были знакомы ранее:

Counter operator++ ():

Для реализации постфиксной записи операции ++ используем новую функцию:

Counter operator++ (int):

Различие между этими функциями только в том, что в скобках стоит int. Здесь int не играет роли аргумента и не означает целое число. Это просто сигнал для компилятора, чтобы использовалась постфиксная версия операции. Разработ­чики С++ нашли полезным повторное использование существующих операций и ключевых слов; в данном случае int предназначена также и для обозначения постфиксной операции. (А сможем ли мы использовать лучший синтаксис?) Результат работы программы будет таким:

cl = О с2 - О cl = 2 с2 - 2 cl = 3 с2 = 2

Первые четыре строки мы уже видели в программах C0UNTPP2 и C0UNTPP3. А в последних двух строках мы видим результаты, полученные после обработки выражения

с2 = cl++:

Здесь cl увеличивается до 3, но переменной с2 значение переменной cl было присвоено до ее увеличения. Поэтому переменная с2 имеет значение 2.

Конечно же, мы можем использовать различные варианты записи операции и для operator—.