Навіщо використовувати static_cast <int> (x) замість (int) x?

Я чув, що цю static_castфункцію слід віддавати перевагу стилю С або простому кастингу в стилі функції. Це правда? Чому?

Основна причина полягає в тому , що класичні зліпки C не роблять жодної різниці між тим, що ми називаємо static_cast<>(), reinterpret_cast<>(), const_cast<>()і dynamic_cast<>(). Ці чотири речі абсолютно різні.

A, static_cast<>()як правило, безпечний. Існує дійсна конверсія в мові або відповідний конструктор, що робить це можливим. Єдиний раз, коли це трохи ризиковано - це коли ти перейшов до спадкового класу; ви повинні переконатися, що об’єкт насправді є нащадком, який ви стверджуєте, що він є, за допомогою зовнішньої мови (як прапор об’єкта). A dynamic_cast<>()безпечний, доки перевіряється результат (покажчик) або враховується можливий виняток (посилання).

А reinterpret_cast<>()(або а const_cast<>()) з іншого боку - це завжди небезпечно. Ви скажете компілятору: "повірте мені: я знаю, це не схоже на foo(це виглядає так, ніби він не змінюється), але це так".

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

Припустимо наступне:

class CDerivedClass : public CMyBase {...};
class CMyOtherStuff {...} ;

CMyBase  *pSomething; // filled somewhere

Тепер ці два складені однаково:

CDerivedClass *pMyObject;
pMyObject = static_cast<CDerivedClass*>(pSomething); // Safe; as long as we checked

pMyObject = (CDerivedClass*)(pSomething); // Same as static_cast<>
                                     // Safe; as long as we checked
                                     // but harder to read

Однак подивимось цей майже однаковий код:

CMyOtherStuff *pOther;
pOther = static_cast<CMyOtherStuff*>(pSomething); // Compiler error: Can't convert

pOther = (CMyOtherStuff*)(pSomething);            // No compiler error.
                                                  // Same as reinterpret_cast<>
                                                  // and it's wrong!!!

Як бачите, не існує простого способу розрізнити дві ситуації, не знаючи багато про всі заняття.

Друга проблема полягає в тому, що ролі в стилі С занадто важко знайти. У складних виразах можна дуже важко побачити ролі в стилі С. Практично неможливо написати автоматизований інструмент, який повинен знаходити касти у стилі C (наприклад, інструмент пошуку) без повного виду компілятора C ++. З іншого боку, легко знайти "static_cast <" або "reinterpret_cast <".

pOther = reinterpret_cast<CMyOtherStuff*>(pSomething);
      // No compiler error.
      // but the presence of a reinterpret_cast<> is 
      // like a Siren with Red Flashing Lights in your code.
      // The mere typing of it should cause you to feel VERY uncomfortable.

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

Одна прагматична порада: ви можете легко шукати ключове слово static_cast у своєму вихідному коді, якщо плануєте налагодити проект.

Коротше кажучи :

1. static_cast<>() дає змогу перевіряти час компіляції, C-Style cast не робить.
2. static_cast<>()їх можна легко помітити в будь-якому місці всередині вихідного коду C ++; на відміну, C_Style ролі важче помітити.
3. Наміри передаються набагато краще, використовуючи ролі C ++.

Більше пояснення :

Статичний формат виконує перетворення між сумісними типами . Він схожий на ролі в стилі С, але є більш обмежуючим. Наприклад, команда в стилі C дозволить цілому вказівнику вказувати на знак.

char c = 10;       // 1 byte
int *p = (int*)&c; // 4 bytes

Оскільки це призводить до того, що 4-байтний вказівник вказує на 1 байт виділеної пам'яті, запис у цей покажчик або спричинить помилку під час виконання, або замінить деяку суміжну пам'ять.

*p = 5; // run-time error: stack corruption

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

int *q = static_cast<int*>(&c); // compile-time error

Детальніше про:
Яка різниця між static_cast <> та литтям у стилі C
та
Регулярним складанням проти static_cast проти динамичного_cast

Питання є більш простим, ніж просто використання камер в стилі static_cast або C, оскільки різні випадки трапляються при використанні кастингу в стилі C. Оператори лиття C ++ мають на меті зробити ці операції більш чіткими.

На поверхні static_cast та C стилі відображаються однаково, наприклад, при передачі одного значення іншому:

int i;
double d = (double)i;                  //C-style cast
double d2 = static_cast<double>( i );  //C++ cast

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

class A {};
class B : public A {};

A* a = new B;
B* b = (B*)a;                                  //(1) what is this supposed to do?

char* c = (char*)new int( 5 );                 //(2) that weird?
char* c1 = static_cast<char*>( new int( 5 ) ); //(3) compile time error

У цьому прикладі (1), можливо, гаразд, тому що об'єкт, на який вказує A, є дійсно екземпляром B. Але що робити, якщо ви не знаєте в той момент коду, що насправді вказує? (2) може бути абсолютно законним (ви хочете подивитися лише на один байт цілого числа), але це також може бути помилкою, в цьому випадку помилка була б непоганою, як (3). Оператори кастингу C ++ призначені для викриття цих проблем у коді, надаючи помилки під час компіляції або час виконання під час виконання.

Отже, для суворого "кастингу значення" можна використовувати static_cast. Якщо ви хочете виконувати поліморфне лиття покажчиків під час виконання, використовуйте динамічну передачу. Якщо ви дійсно хочете забути про типи, ви можете використовувати reintrepret_cast. А щоб просто викинути const у вікно, є const_cast.

Вони просто роблять код більш явним, щоб він виглядав так, що ви знаєте, що робили.

static_castозначає, що ви не можете випадково const_castабо reinterpret_cast, що добре.

1. Дозволяє легко знаходити касти у вашому коді за допомогою grep або подібних інструментів.
2. Зрозуміло, що саме ви робите роль, і залучаєте допомогу компілятора в його застосуванні. Якщо ви хочете лише відкинути const-ness, тоді ви можете використовувати const_cast, що не дозволить вам робити інші типи перетворень.
3. Касти самі по собі некрасиві - ви як програміст перекручуєте, як компілятор звичайно ставиться до вашого коду. Ви говорите компілятору: "Я знаю краще за вас". У цьому випадку має сенс, що виконання акторської ролі має бути помірно болючою справою, і вони повинні дотримуватися у вашому коді, оскільки вони є ймовірним джерелом проблем.

Див. Ефективне введення C ++

Йдеться про те, яку безпеку типу ви хочете нав'язати.

Коли ви пишете (bar) foo(що еквівалентноreinterpret_cast<bar> foo тому, що ви не надали оператора перетворення типів), ви кажете компілятору ігнорувати безпеку типу та просто виконайте так, як йому сказано.

Коли ви пишете, static_cast<bar> fooви просите компілятора хоча б перевірити, чи є сенс перетворення типу, а для цілісних типів - вставити якийсь код перетворення.

EDIT 2014-02-26

Я написав цю відповідь більше 5 років тому, і я зрозумів її неправильно. (Див. Коментарі.) Але це все ще отримує відгуки!

У ролях коду легко пропустити касти в стилі. У ролях стилів C ++ - це не лише краща практика; вони пропонують набагато більшу ступінь гнучкості.

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

static_cast пропонує хорошу конверсію для числових типів, наприклад, від перерахунків до int чи int до плаваючих чи будь-яких типів даних, яким ви впевнені. Він не виконує жодних перевірок часу виконання.

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

Є кілька інших, але це головні, з якими ви зіткнетесь.

static_cast, крім маніпулювання покажчиками на класи, також може використовуватися для виконання перетворень, чітко визначених у класах, а також для здійснення стандартних перетворень між основними типами:

double d = 3.14159265;
int    i = static_cast<int>(d);