"Идиомы и стили С++" - читать интересную книгу автора (Makhmutov Albert)

Шаг 20 - Временные объекты. Неявные вызовы конструкторов и их подавление.

Не удается углубиться в какую-либо тему. Приходится касаться по верхам, потом переключаться на что-то другое. С другой стороны, может это и правильно, часто достаточно только знать, что есть ТАКОЕ решение, а изучить детально можно и позже, когда сделаешь окончательный выбор. Да и не очень это интересно - что за радость переписать двадцать страниц из учебника, или перевести статью какого-нибудь доктора CS? Объяснения которого в точности так же логичны, как рассказ Ивана Бездомного насчет "…Берлиоза зарезало трамваем, а тот заранее знал про масло, которое Аннушка пролила" - то есть логика и связь есть - но только для него самого.

Чтож, к делу.

А кто такие временные объекты? Локальные переменные с замечательными именами a, a1, a2, a_1, tmp1, tmp2? (Кстати ни за что не берите на работу болванов, которые так именуют переменные; пусть на FoxPro пишут. Думаю написать про это отдельный Шаг - причины для немедленного увольнения.) Вообще-то нет. Временные объекты - это объекты, которые не имеют имен в коде и неявно создаются компилятором. Поскольку неявные "подарки" компилятора иногда бывают очень некстати, лучше заранее знать, чего можно ожидать от него. А зачем он их создает? Первое - при выполнении преобразования типов, для вызова функций. Второе - для возвращения объекта из функции.

Придется немного поэкспериментировать. Поэтому скопируйте себе код небольшого класса:

#include ‹iostream.h›

class CInt {

private:

 int m_i;

 int m_instance;

 static int iCounter;

public:

 CInt (int);

 CInt (const CIntamp;);

 ~CInt ();

 CInt operator+ (const CIntamp;);

 CIntamp; operator+=(const CIntamp;);

 CIntamp; operator= (const CIntamp;); // operator int ();

};

int CInt::iCounter = 0;

CInt::CInt (int _i=0): m_i(_i) {

 m_instance = ++iCounter;

 cout‹‹"defa constr " ‹‹ m_instance ‹‹ " "‹‹ m_i‹‹ endl;

}

CInt::CInt (const CIntamp; _i): m_i(_i.m_i) {

 m_instance = ++iCounter;

 cout‹‹"copy constr " ‹‹ m_instance ‹‹ " "‹‹ m_i‹‹ endl;

}

CInt::~CInt () {

 iCounter--;

 cout ‹‹"~destructor " ‹‹ m_instance ‹‹ " "‹‹ m_i‹‹ endl;

}

CIntamp; CInt::operator=(const CIntamp; _i) {

 m_i = _i.m_i;

 cout ‹‹"assert oper " ‹‹ m_instance ‹‹ " "‹‹ m_i‹‹ endl;

 return *this;

}

CInt CInt::operator+(const CIntamp; _i) {

 cout‹‹"addi operat " ‹‹ m_instance ‹‹ " "‹‹ m_i‹‹ endl;

 return CInt (m_i + _i.m_i);

}

CIntamp; CInt::operator+= (const CIntamp; _i) {

 m_i += _i.m_i;

 cout‹‹"autoadd ope " ‹‹ m_instance ‹‹ " "‹‹ m_i‹‹ endl;

 return *this;

}

/*

CInt::operator int () {

 return m_i;

}

*/

int main (void) {

 cout ‹‹ "start" ‹‹ endl;

 // Позиция 1.

 CInt i_test = CInt (2) + CInt (4);

 cout ‹‹ "firststop" ‹‹ endl;

 {

  // Позиция 2.

 }

 cout ‹‹ "thirdstop" ‹‹ endl;

 return 0;

}

Пояснения: класс представляет целые числа. Определены конструктор по умолчанию и копирования, присваивание, пара арифметических операторов, оператор преобразования в int (закомментирован). В функции main отмечены 2 позиции для экспериментов.

Еще момент - вызвала затруднения форма конструктора со списком инициализации, типа этой:

CClass::CClass (int _a, int _b, int _c) : m_a(_a), m_bc(_b, _c) {}

Тут нет ничего такого, просто конструкторы членов-переменных и базовых классов вызываются явно со своими параметрами, это выгоднее чем создавать пустые, а потом в теле конструктора выполнять ПРИСВАИВАНИЕ при помощи оператора operator=().

Попробуем в позицию 1 поставить:

CInt i_test = 1 + 2;

Вызовется только один конструктор - по умолчанию. Это одно и то же:

CInt i_test = 3; ‹=====› CInt i_test(3);

Попробуем так

CInt i_test;

i_test = CInt(1) + CInt(2);

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

А если записать в одну строку?

CInt i_test = CInt(1) + CInt(2);

Подумаем немного. Сначала левый операнд, потом правый, потом результат, потом создается объект а при помощи конструктора копирования. Всего четыре. Три по умолчанию, один копирования. Лепота.

ДА НИЧЕГО ТАКОГО! Компилятору плевать на нашу логику. Он берет результат, и превращает его в i_test. Оптимизирует. Три вызова дефолт конструктора, и ни одного временного объекта.

Я встречал этот вопрос на BrainBench и на ProveIt.

А еще давайте сравним два варианта кода:

CInt i_test = CInt(1) + CInt(2) + CInt (4) + CInt(8);

и

CInt i_test = CInt (1);

i_test+=CInt(2);

i_test+=CInt(4);

i_test+=CInt(8);

Видите? В первом варианте конструктор вызывается 7 раз, а во втором 4.

С явными вызовами конструкторов все понятно. А неявные?

CInt i_test = CInt(1) + 2;

Компилятор пытается найти подходящий оператор operator+, но его нет для примитивного int. Тогда он считает, что конструктор CInt(int) - вполне подходящий способ преобразования, и на место двойки ставит CInt(2).

Теперь раскройте оператор operator int. Хочется ожидать разумного поведения компилятора; но увы - в нашем примере этого ожидать не стоит. Есть два способа вычислить последнее выражение - и компилятор не знает что выбрать, и подыхает, как Буриданов осел между двумя кучами сена. Чтобы помочь компилятору, нужно один вариант блокировать. Как?

Не определять оператор преобразования, а определять вместо них функции, типа operator int() ‹-› asInt()

В определении конструктора использовать модификатор explicit для подавления неявных вызовов.

Использовать proxy-object - промежуточный объект наподобие курсора из Шага 16, все назначение которого - быть другим объектом когда нужно, и не быть им, когда не нужно. Словами больно заумно, проще нарисовать код.

// Класс прокси-объекта

class CProxyInt {

 friend class CInt;

private:

 int m_i;

public:

 CProxyInt (int _i): m_i(_i) {}

 int getInt () const { return m_i; }

};

// Предыдущий класс инт.

class CInt {

 friend class CProxyInt;

private:

 int m_i;

 int m_instance;

 static int iCounter;

public:

 // Конструктор по умолчанию изменен

 CInt (CProxyInt);

 CInt (const CIntamp;);

 ~CInt();

 CInt operator+(const CIntamp;);

 CIntamp; operator+=(const CIntamp;);

 CIntamp; operator= (const CIntamp;);

// operator int ();

};

int CInt::iCounter = 0;

// Реализация конструктора, вместо инта стоит прокси

CInt::CInt (CProxyInt _i=0): m_i(_i.m_i) {

 m_instance = ++iCounter;

 cout‹‹"defa constr " ‹‹ m_instance ‹‹ " "‹‹ m_i ‹‹ endl;

}

CInt a(5); // Это компилируется нормально

CInt a = 5; // А это нет. И все неявные вызовы тоже.

Видите, мы используем технику proxy уже второй раз, но совершенно в другом контексте. Общее то, что proxy применяется в том случае, если мы хотим определить свои законы преобразования типов и классов.

В этом смысле smart-указатель несомненно тоже рroxy, (уменьш. ласк. проксятник, проксятничек).