Які ідіоми C ++ застаріли в C ++ 11?

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

Які старі способи кодування, безумовно, поступаються стилям C ++ 11, і що ми можемо зробити замість цього?

Відповідаючи на це, ви можете пропустити очевидні речі, такі як "використовувати автоматичні змінні".

1. Заключний клас : C ++ 11 забезпечує finalспецифікатор для запобігання похідності класу
2. C ++ 11 лямбда значно знижують потребу в названих класах функціональних об'єктів (функторів).
3. Move Constructor : магічні способи, коли std::auto_ptrроботи більше не потрібні завдяки першокласній підтримці посилань на rvalue.
4. Безпечний бул : Про це йшлося раніше. Явні оператори C ++ 11 заперечують цю дуже поширену ідіому C ++ 03.
5. Зменшення до придатності : Багато контейнерів C ++ 11 STL забезпечують функцію shrink_to_fit()члена, що повинно усунути необхідність заміни на тимчасову.
6. Тимчасовий базовий клас : Деякі старі бібліотеки C ++ використовують цю досить складну ідіому. З семантикою руху це більше не потрібно.
7. Введіть безпечний перелік Перерахування дуже безпечні для C ++ 11.
8. Заборона розподілу купи : = deleteСинтаксис є набагато більш прямим способом сказати, що певна функціональність явно заперечується. Це застосовно для запобігання розподілу купи (тобто =deleteдля учасника operator new), запобігання копій, присвоєння тощо.
9. Шаблонні typedef : Шаблони псевдонімів на C ++ 11 зменшують потребу в простих шаблонах typedef. Однак генераторам складного типу все ще потрібні метафункції.
10. Деякі числові обчислення часу компіляції, такі як Фібоначчі, можна легко замінити, використовуючи узагальнені постійні вирази
11. result_of: Використання шаблону класу result_ofслід замінити на decltype. Я думаю, result_ofвикористовує, decltypeколи є.
12. Ініціалізатори членів класу зберігають введення тексту для ініціалізації за замовчуванням нестатичних членів зі значеннями за замовчуванням.
13. У новому C ++ 11 код NULLслід переосмислити як nullptr, але дивіться розмови STL, щоб дізнатися, чому вони вирішили проти цього.
14. Фанатики шаблонів виразів раді, що вони мають синтаксис функції зворотного типу в C ++ 11. Немає більше 30-ти рядкових типів повернення!

Я думаю, я зупинюсь на цьому!

В один момент часу було стверджено, що варто повертатись за constзначенням, а не просто за значенням:

const A foo();
^^^^^

Це було в основному нешкідливим для C ++ 98/03, і, можливо, навіть зловив декілька помилок, які виглядали так:

foo() = a;

Але повернення через constпротипоказане в C ++ 11, оскільки воно гальмує семантику переміщення:

A a = foo();  // foo will copy into a instead of move into it

Тож просто розслабтесь та кодуйте:

A foo();  // return by non-const value

Як тільки ви зможете відмовитися 0і NULLна користь nullptr, зробіть це!

У негенеричному коді використання 0чи NULLне така велика справа. Але як тільки ви починаєте обходити нульові константи покажчика в загальному коді, ситуація швидко змінюється. Коли ви переходите 0до значення, template<class T> func(T) Tвиводиться як не, intа не як нульова константа вказівника. І це не може бути перетворене назад у нульову постійну вказівник після цього. Це каскади перетворюється на тріску проблем, яких просто не існує, якщо всесвіт використовується тільки nullptr.

C ++ 11 не застаріло 0і NULLє нульовими константами вказівника. Але ви повинні кодувати так, ніби це було.

Безпечна ідіома булів → explicit operator bool().

Приватні конструктори копій (прискорення: без копіювання) → X(const X&) = delete

Моделювання остаточного класу з приватним деструктором та віртуальним успадкуванням →class X final

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

Я зараз використовую ці дані, і неймовірно, як часто ви просто говорите, що ви хочете зробити, використовуючи count_if (), for_each () або інші алгоритми, замість того, щоб знову писати прокляті петлі.

Як тільки ви використовуєте компілятор C ++ 11 з повною стандартною бібліотекою C ++ 11, у вас більше немає хорошого приводу не використовувати стандартні алгоритми для побудови своїх . Лямбда просто вб'є.

Чому?

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

В основному, читання алгоритмів, виготовлених за допомогою стандартних алгоритмів, набагато простіше, оскільки слова приховують деталі реалізації циклів.

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

Вам потрібно буде впроваджувати власні версії swapрідше. У програмі C ++ 03 ефективне некидання swapчасто необхідно для уникнення затрат та перекидання копій, а оскільки std::swapвикористовує дві копії, swapчасто доводиться налаштовувати. У C ++ std::swapвикористовує move, і тому фокус зміщується на впровадженні ефективних конструкторів переміщення та некидальних переміщень та операторів присвоєння переміщення. Оскільки для них за замовчуванням часто просто добре, це буде набагато менше роботи, ніж у C ++ 03.

Як правило, важко передбачити, які ідіоми будуть використовуватися, оскільки вони створені через досвід. Ми можемо очікувати, що "Ефективний C ++ 11", можливо, наступного року, а "Стандарти кодування C ++ 11" лише через три роки, оскільки необхідного досвіду ще немає.

Я не знаю назви для цього, але код C ++ 03 часто використовував таку конструкцію як заміну для відсутнього призначення переміщення:

std::map<Big, Bigger> createBigMap(); // returns by value

void example ()
{
  std::map<Big, Bigger> map;

  // ... some code using map

  createBigMap().swap(map);  // cheap swap
}

Це дозволило уникнути будь-якого копіювання за рахунок копіювання elision у поєднанні з swapвищезазначеним.

Коли я помітив, що компілятор, що використовує стандарт C ++ 11, більше не має помилок у наступному коді:

std::vector<std::vector<int>> a;

за нібито містить оператора >>, я почав танцювати. У попередніх версіях треба було б зробити

std::vector<std::vector<int> > a;

Що ще гірше, якщо вам коли-небудь довелося це налагоджувати, ви знаєте, наскільки жахливими є повідомлення про помилки, які виходять із цього.

Я, однак, не знаю, чи це було для вас "очевидно".

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