Разъяснения потребности в C-стиле, дайте иное толкование, и броски константы

Помните, что приведение констант может воздействовать на что-то другое, кроме исходного идентификатора:

void doit(const std::string &cs)
{
    std::string &ms = const_cast<std::string &>(cs);
}

int main()
{
    std::string s;
    doit(s);
}

Итак, пока doit отбрасывает константу, в этом примере базовая строка не является константой, поэтому неопределенное поведение отсутствует.

Обновление

Хорошо, вот лучший пример того, когда использование const_cast не совсем бесполезно. Мы начинаем с базового класса с виртуальной функцией, которая принимает параметр const:

class base
{
public:
    virtual void doit(const std::string &str);
};

, и теперь вы хотите переопределить эту виртуальную функцию.

class child : public base
{
public:
    virtual void doit(const std::string &str)
    {
        std::string &mstr = const_cast<std::string &>(str);
    }
};

Из-за логики / структуры вашего кода вы знаете, что child :: doit будет вызываться только с неконстантными строками (а class base не находится под вашим контролем поэтому вы не можете его ни изменить, ни подпись child :: doit , потому что тогда он больше не будет переопределять base :: doit ).В этом случае можно безопасно отказаться от const.

Да, это рискованно. Возможно, когда вы это напишете, это правда, что выполнение никогда не достигнет child :: doit с неконстантной строкой, и код действителен. Но это может измениться либо при сохранении вашей программы, либо, возможно, когда вы перестроите и загрузите последнюю версию class base .

Нет, приведение типов в стиле C может действовать как reinterpret_cast s, const-cast s или static_cast s в зависимости от ситуации. Вот почему они не поощряются - вы видите приведение в стиле C в коде, и вам нужно посмотреть подробности, чтобы увидеть, что он будет делать. Например:

const char* source;
int* target = (int*)source;// - acts as const_cast and reinterpret_cast at once
//int* target = retinterpret_cast<int*>source;// - won't compile - can't remove const

const_cast используется для удаления const из типа. Он также может удалить энергозависимый . Если объект действительно const , то результат не может быть записан и все равно будет иметь четко определенное поведение. Если, однако, он будет преобразован в const (путем передачи в функцию const T , то const_cast вернет его обратно в не const в порядке. (Я нашел дополнительную информацию здесь )

reinterpret_cast не может удалить const или volatile из типа.

см. Также

Отливки в стиле C на самом деле являются кувалдой программирования - вы, по сути, говорите компилятору, что квадратный стержень вон там пройдёт через это круглое отверстие, несмотря ни на что. В этом смысле reinterpret_cast очень похож.

Основное преимущество, которое я вижу в использовании операторов приведения в стиле C ++, заключается в том, что они позволяют лучше выразить ваши намерения и позволяют компилятору по-прежнему выполнять некоторую проверку операции, которую вы просите выполнить, а не той операции, которую вы просите выполнить. размер подходит всем стиль C.

Что касается const_cast - вы часто попадаете в ситуацию, когда вы передаете объект через ссылку на константу просто потому, что API требует этого. Скажем, у вас есть функция X, которая задает строку в стиле C:

void X(const char *str) { ... }

Внутри этой функции вы передаете параметр функции C, которая ожидает char * , даже если она не меняет нить. Единственный способ учесть это - использовать const_cast str.

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