C++. Сборник рецептов

15.4. Обеспечение невозможности модификации своих объектов в функции-члене

Требуется вызывать функции -члены для константного объекта, но ваш компилятор жалуется на то, что он не может преобразовать тип используемого вами объекта из константного в неконстантный.

Поместите ключевое слово

const

Пример 15.4. Объявление функции-члена константной

#include 

#include 

class RecordSet {

public:

 bool getFieldVal(int i, std::string& s) const;

 // ...

};

bool RecordSet::getFieldVal(int i, std::string& s) const {

 // Здесь нельзя модифицировать никакие неизменяемые

 // данные-члены (см. обсуждение)

}

void displayRecords(const RecordSet& rs) {

 // Здесь вы можете вызывать только константные функции-члены

 // для rs

}

Добавление концевого

const

RecordSet::getFieldVal

getFieldCount_

RecordSet

bool RecordSet::getFieldVal(int i, std::string& s) const {

 ++getFieldCount_; // Ошибка: константная функция-член не может

          // модифицировать переменную-член

          // ...

}

Это может также помочь обнаружить более тонкие ошибки, подобно тому, что делает

const

bool RecordSet::getFieldVal(int i, std::string& s) const {

 fieldArray_[i] = s; // Ой, я не это имел в виду

 // ...

}

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

В классе

RecordSet

void RecordSet::gotoNextPecord() const {

 if (curIndex_ >= 0 && curIndex_ < numRecords_-1)

  ++curIndex_;

}

void RecordSet::gotoPrevRecord() const {

 if (curIndex_ > 0)

  --curIndex_;

}

Очевидно, что это не сработает, если эти функции-члены являются константными. Обе обновляют данное-член. Однако без этого пользователи класса

RecordSet

const RecordSet

mutable

Для того чтобы

curIndex_

mutable int curIndex_;

Это позволит вам модифицировать

curIndex_

Применение ключевого слова

const

15.5. Написание оператора, не являющегося функцией-членом

Необходимо написать бинарный оператор, и вы не можете или не хотите сделать его функцией-членом класса.

Используйте ключевое слово

operator

String

Пример 15.5. Конкатенация с использованием оператора не члена

#include 

#include 

class String { // Предположим, что объявление класса String содержит,

        // по крайней мере, все, что указанно ниже

public:

 String();

 String(const char* p);

 String(const String& orig);

 ~String() {delete buf_;}

 String& append(const String& s);

 size_t length() const;

 const char* data() const;

 String& operator=(const String& orig);

 // ...

};

String operator+(const String& lhs, const String& rhs) {

 String tmp(lhs); // Сконструировать временный объект с помощью

          // конструктора копирования

 tmp.append(rhs); // Использовать функцию-член для выполнения реальной

          // работы

 return(tmp); // Возвратить временный объект

}

int main() {

 String s1("banana ");

 String s2("rancher");

 String s3, s4, s5, s6;

 s3 = s1 + s2;      // Работает хорошо, но с сюрпризами

 s4 = s1 + "rama";    // Автоматически конструируется "rama", используя

             // конструктор String(const char*)

 s5 = "ham " + s2;    // Круто, то же самое можно делать даже

 s6 = s1 + "rama " + s2; // с другим операндом

 std::cout << "s3 = " << s3.data() << '\n';

 std::cout << "s4 = " << s4.data() << '\n';

 std::cout << "s5 = " << s5.data() << '\n';

 std::cout << "s6 = " << s6.data() << '\n';

}

Независимый оператор объявляется и определяется подобно оператору функции-члена. В примере 15.5 я мог бы реализовать

operator+

String operator+(const String& rhs);

В большинстве случаев это будет работать одинаково, независимо от того, определяется ли

operator+

operator+

String

Вторая причина техническая. При использовании оператора-члена вы не сможете выполнить следующую операцию (из приведенного выше примера).

s5 = "ham " + s2;

Это не сработает, потому что символьная строка не имеет

operator+

String

operator+

String

String

const char*

String

s5 = String("ham ") + s2;

Компилятор позволяет вам немного сэкономить ваши действия и не вводить несколько символов за счет поиска и вызова соответствующего конструктора.

Перегрузка операторов сдвига потоков влево и вправо (

<<

>>

operator<<

ostream& operator<<(ostream& str, const MyClass& obj);

Конечно, вы можете создать подкласс одного из классов потока стандартной библиотеки и добавить все необходимые вам операторы сдвига влево, но будет ли такое решение действительно удачным? При таком решении только тот программный код, который использует ваш новый класс потока, сможет записывать в него объекты вашего специального класса. Если вы используете независимый оператор, любой программный код в том же самом пространстве имен сможет без проблем записать ваш объект в

ostream

istream

15.6. Инициализация последовательности значениями, разделяемыми запятыми

Требуется инициализировать последовательность набором значений, разделяемых запятыми, подобно тому как это делается для встроенных массивов.

При инициализации стандартных последовательностей (таких как

vector

list

Пример 15.6. Вспомогательные классы для инициализации стандартных последовательностей с применением синтаксиса с запятыми

#include 

#include 

#include 

#include 

using namespace std;

template

struct comma helper {

 typedef typename Seq_T::value_type value_type;

 explicit comma_helper(Seq_T& x) : m(x) {}

 comma_helper& operator=(const value_type& x) {

  m.clear();

  return operator+=(x);

 }

 comma_helper& operator+=(const value_type& x) {

  m.push_back(x);

  return *this;

 }

 Seq_T& m;

};

template

comma_helper initialize(Seq_T& x) {

 return comma_helper(x);

}

template

comma_helper& operator,(comma_helper& h, Scalar_T x) {

 h += x;

 return h;

}

int main() {

 vector v;

 int a = 2;

 int b = 5;

 initialize(v) = 0, 1, 1, a, 3, b, 8, 13;

 cout << v[3] << endl; // выдает 2

 system("pause");

 return EXIT_SUCCESS;

}

Часто стандартные последовательности инициализируются путем вызова несколько раз функции-члена

push_back

initialize

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

В решении используется вспомогательная функция

initialize

comma_helper

operator,

operator=

operator+=

Такое решение требует, чтобы я определил отдельную вспомогательную функцию из-за особенностей восприятия компилятором оператора

v = 1, 1, 2, ...;

v = 1

initialize

comma_helper

Оператор запятой (comma operator), называемый также оператором последовательности (sequencing operator), по умолчанию рассматривает выражения слева направо, и в результате получается значение и тип самого правого значения. Однако при перегрузке

operator

Пример 15.7. Применение перегруженного оператора запятой, когда порядок вычисления аргументов не определен

int prompt_user() {

 cout << "give me an integer ... ";

 cin >> n;

 return n;

}

void f() {

 vector v;

 // Следующий оператор может инициализировать v в неправильной

 // последовательности

 intialize(v) = prompt_user(), prompt_user();

}

В правильном варианте функции

f

prompt_user