Индивидуальные и групповые автопоилки: для животных. Схемы и конструкции...
Археология об основании Рима: Новые раскопки проясняют и такой острый дискуссионный вопрос, как дата самого возникновения Рима...
Топ:
Комплексной системы оценки состояния охраны труда на производственном объекте (КСОТ-П): Цели и задачи Комплексной системы оценки состояния охраны труда и определению факторов рисков по охране труда...
Методика измерений сопротивления растеканию тока анодного заземления: Анодный заземлитель (анод) – проводник, погруженный в электролитическую среду (грунт, раствор электролита) и подключенный к положительному...
Выпускная квалификационная работа: Основная часть ВКР, как правило, состоит из двух-трех глав, каждая из которых, в свою очередь...
Интересное:
Финансовый рынок и его значение в управлении денежными потоками на современном этапе: любому предприятию для расширения производства и увеличения прибыли нужны...
Инженерная защита территорий, зданий и сооружений от опасных геологических процессов: Изучение оползневых явлений, оценка устойчивости склонов и проектирование противооползневых сооружений — актуальнейшие задачи, стоящие перед отечественными...
Распространение рака на другие отдаленные от желудка органы: Характерных симптомов рака желудка не существует. Выраженные симптомы появляются, когда опухоль...
Дисциплины:
2020-05-08 | 203 |
5.00
из
|
Заказать работу |
Функция 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—.
Наброски и зарисовки растений, плодов, цветов: Освоить конструктивное построение структуры дерева через зарисовки отдельных деревьев, группы деревьев...
Опора деревянной одностоечной и способы укрепление угловых опор: Опоры ВЛ - конструкции, предназначенные для поддерживания проводов на необходимой высоте над землей, водой...
Двойное оплодотворение у цветковых растений: Оплодотворение - это процесс слияния мужской и женской половых клеток с образованием зиготы...
Механическое удерживание земляных масс: Механическое удерживание земляных масс на склоне обеспечивают контрфорсными сооружениями различных конструкций...
© cyberpedia.su 2017-2024 - Не является автором материалов. Исключительное право сохранено за автором текста.
Если вы не хотите, чтобы данный материал был у нас на сайте, перейдите по ссылке: Нарушение авторских прав. Мы поможем в написании вашей работы!