Чи слід повертати об'єкти const?

У Effective C++пункті 03 використовуйте const, коли це можливо.

class Bigint
{
  int _data[MAXLEN];
  //...
public:
  int& operator[](const int index) { return _data[index]; }
  const int operator[](const int index) const { return _data[index]; }
  //...
};

const int operator[]робить різницю від int& operator[].

А як щодо:

int foo() { }

і

const int foo() { }

Здається, вони однакові.

Моє запитання: чому ми використовуємо const int operator[](const int index) constзамість int operator[](const int index) const?

CV-кваліфікатори верхнього рівня для типів повернення некласного типу ігноруються. Це означає, що навіть якщо ви пишете:

int const foo();

Повертається тип int. Якщо тип повернення є посиланням, звичайно, constце вже не верхній рівень, а різниця між:

int& operator[]( int index );

і

int const& operator[]( int index ) const;

є значущим. (Зауважте також, що в оголошеннях функцій, як і вище, будь-які cv-кваліфікатори верхнього рівня також ігноруються.)

Різниця також актуальна для повернутих значень класу типу: якщо ви повернетесь T const, то абонент не може викликати функції, що не є const, щодо повернутого значення, наприклад:

class Test
{
public:
    void f();
    void g() const;
};

Test ff();
Test const gg();

ff().f();             //  legal
ff().g();             //  legal
gg().f();             //  **illegal**
gg().g();             //  legal

Ви повинні чітко розмежовувати використання const, що застосовується до повернутих значень, параметрів та самої функції.

Повернути значення

• Якщо функція повертається за значенням , const не має значення, оскільки копія об'єкта. Однак це матиме значення в C ++ 11 із залученою семантикою переміщення.
• Це також ніколи не має значення для базових типів, оскільки вони завжди копіюються.

Поміркуйте const std::string SomeMethod() const. Це не дозволить використовувати (std::string&&)функцію, оскільки вона очікує неконстантного значення. Іншими словами, повернутий рядок завжди буде скопійовано.

• Якщо функція повертається за посиланням , constзахищає повернутий об'єкт від модифікації.

Параметри

• Якщо ви передаєте параметр за значенням , const запобігає зміні заданого значення функцією у функції . Вихідні дані з параметра все одно не можна змінити, оскільки у вас є лише копія.
• Зверніть увагу, що оскільки копія завжди створюється, const має значення лише для тіла функції , отже, це перевіряється лише у визначенні функції, а не в декларації (інтерфейсі).
• Якщо ви передаєте параметр за посиланням , застосовується те саме правило, що і у повернутих значеннях

Сама функція

• Якщо функція є constв кінці, вона може запускати лише інші constфункції, і не може змінювати або дозволяти модифікацію даних класу. Таким чином, якщо воно повертається за посиланням, повернене посилання має бути const. Тільки функції const можна викликати на об'єкті або посилання на об'єкт, який є самим const. Також змінні поля можна змінювати.
• Поведінка, створена компілятором, змінює thisпосилання на T const*. Функція може завждиconst_cast this , але, звичайно, цього робити не слід, і це вважається небезпечним.
• Звичайно, розумно використовувати цей специфікатор лише для методів класу; глобальні функції з const в кінці викличуть помилку компіляції.

Висновок

Якщо ваш метод не змінює і ніколи не змінить змінні класу, позначте його як const і переконайтесь, що він відповідає усім необхідним критеріям. Це дозволить писати більш чистий код, тим самим зберігаючи його правильним . Однак покласти constскрізь, не замислюючись, звичайно, не шлях.

Існує мало користі в додаванні constкваліфікації до неопорної / НЕ покажчик rvalues, і немає сенсу в додаванні його вбудованих модулів.

У разі певного користувача типів , A constкваліфікація буде перешкоджати викликають абонентам від виклику до не- constфункції - члена на повернутому об'єкті. Наприклад, дано

const std::string foo();
      std::string bar();

тоді

foo().resize(42);

було б заборонено, поки

bar().resize(4711);

буде дозволено.

Для вбудованих подібних int це взагалі не має сенсу, оскільки такі значення r не можуть бути змінені.

(Я пам'ятаю , Ефективне використання C ++ обговорює зробити тип повернення operator=()в constзасланні, хоча, і це що - то розглянути.)

Редагувати:

Здається, Скотт справді дав таку пораду . Якщо так, то з причин, наведених вище, я вважаю це сумнівним навіть для C ++ 98 та C ++ 03 . Що стосується С ++ 11, я вважаю це абсолютно неправильним , як, здається, виявив сам Скотт. В помилці для ефективного C ++, 3-е видання. , він пише (або цитує інших, хто скаржився):

З тексту випливає, що всі повернення за значеннями повинні бути const, але випадків, коли повернення за значенням non-const є гарним дизайном, важко знайти, наприклад, типи повернення std :: vector, де абоненти будуть використовувати swap з порожнім вектором "захопити" вміст поверненого значення без їх копіювання.

А пізніше:

Оголошення за значенням функції, що повертає значення const, запобіжить їх прив’язку до посилань rvalue у C ++ 0x. Оскільки посилання на rvalue розроблені, щоб допомогти підвищити ефективність коду на C ++, важливо враховувати взаємодію повернутих значень const та ініціалізацію посилань на rvalue при зазначенні підписів функцій.

Ви можете пропустити сенс поради Мейєрса. Суттєва різниця полягає вconst модифікаторі методу.

Цей метод не є const (примітка відсутня constв кінці), що означає, що йому дозволено змінювати стан класу.

int& operator[](const int index)

Це метод const (повідомлення constв кінці)

const int operator[](const int index) const

Що стосується типів параметра та поверненого значення, існує незначна різниця між intі const int, але це не стосується суті поради. Те , що ви повинні звернути увагу на те , що неконстантний від перевантаження вивела наступний, int&яка означає , що ви можете призначити до нього, наприклад num[i]=0, і повернення від перевантаження Const немодіфіціруемих значення (незалежно від того , якщо повертається типу не є intабо const int).

На мою особисту думку, якщо об'єкт передається за значенням , constмодифікатор є зайвим. Цей синтаксис коротший і досягає того ж

int& operator[](int index);
int operator[](int index) const;

Основною причиною повернення значень як const є те, що ви не можете сказати щось подібне foo() = 5;. Це на самому ділі не проблема з примітивними типами, так як ви не можете призначити rvalues примітивних типів, але це проблема з користувачем типів (як (a + b) = c;, з перевантаженим operator+).

Я завжди знаходив виправдання для цього досить хитрого. Ви не можете зупинити когось, хто має намір писати незграбний код, і цей конкретний тип примусу, на мій погляд, не має реальної вигоди.

З C ++ 11 насправді є багато шкоди, яку завдає ця ідіома: повернення значень як const перешкоджає оптимізації переміщення, і тому слід уникати, коли це можливо. В основному, я б зараз вважав це анти-шаблоном.

Ось дотична стаття, що стосується C ++ 11.

Коли ця книга була написана, порада мало користі, але послужила запобіганню користувачеві писати, наприклад, foo() = 42; і очікуючи, що це змінить щось стійке.

У випадку з operator[], це може дещо заплутати, якщо ви також не надаєте constперевантаження, яке повертає не- constпосилання, хоча, можливо, ви можете запобігти цій плутанині, повернувши constпосилання або об'єкт-проксі замість значення.

У наші дні це погана порада, оскільки вона заважає вам прив’язати результат до (не const) посилання на rvalue.

(Як вказувалося в коментарях, питання спірне при поверненні примітивного типу типу int, оскільки мова заважає вам привласнювати rvalueтип такого типу; я говорю про більш загальний випадок, який включає повернення визначених користувачем типів. )

Для примітивних типів (на зразок int), стабільність результату не має значення. Для класів це може змінити поведінку. Наприклад, ви не зможете викликати метод non-const у результаті вашої функції:

class Bigint {
    const C foo() const { ... }
     ...
}

Bigint b;
b.foo().bar();

Вищезазначене заборонено, якщо bar()є функцією-членом const C. Загалом, вибирайте, що має сенс.

Подивіться на це:

const int operator[](const int index) const

в constкінці заяви. Він описує, що цей метод можна викликати на константах.

З іншого боку, коли ви пишете лише

int& operator[](const int index)

його можна викликати лише у неконстантних екземплярах, а також забезпечити:

big_int[0] = 10;

синтаксис.

Одне з ваших перевантажень - повернення посилання на елемент у масиві, який ви потім зможете змінити.

int& operator[](const int index) { return _data[index]; }

Інше перевантаження повертає значення для використання.

const int operator[](const int index) const { return _data[index]; }

Оскільки ви викликаєте кожну з цих перевантажень однаково, і ніколи не зміните значення, коли воно використовується.

int foo = myBigInt[1]; // Doesn't change values inside the object.
myBigInt[1] = 2; // Assigns a new value at index `

У прикладі оператора індексації масиву ( operator[]) це має значення.

С

int& operator[](const int index) { /* ... */ }

Ви можете використовувати індексацію, щоб безпосередньо змінити запис у масиві, наприклад, використовуючи його так:

mybigint[3] = 5;

Другий, const int operator[](const int)оператор використовується для отримання лише значення.

Однак, як повернене значення з функцій, для простих типів, таких як, наприклад, intце не має значення. Важливо, якщо ви повертаєте більш складні типи, скажіть a std::vector, і не хочете, щоб виклик функції модифікував вектор.

Тип constповернення тут не так важливий. Оскільки ІНТ не тимчасові конструкції змінювані, немає спостережуваних відмінностей у використанні intпроти const int. Ви бачили б різницю, якби використовували більш складний об’єкт, який можна було б змінити.

Є кілька хороших відповідей, що стосуються технічності двох версій. Для примітивного значення це не має значення.

Однак я завжди вважав, constщо є для програміста, а не для компілятора. Коли ви пишете const, ви прямо говорите "це не повинно змінюватися". Погодьмося, constзазвичай це можна обійти в будь-якому випадку, так?

Коли ви повертаєте a const , ви говорите програмісту, який використовує цю функцію, що значення не повинно змінюватися. І якщо він його змінює, він, мабуть, робить щось не так, бо йому / їй не потрібно було б це робити.

РЕДАГУВАТИ: Я також вважаю "використовувати, constколи це можливо" - погана порада. Ви повинні використовувати його там, де це має сенс.