В чем разница между static_cast и Implicit_cast?

Ответ 1

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

Вы можете сбрасывать с помощью static_cast. Не так с implicit_cast. static_cast в основном позволяет вам делать какое-либо неявное преобразование и, кроме того, обратное любому неявному преобразованию (вплоть до некоторых ограничений. вы не можете опускать, если есть виртуальный базовый класс). Но implicit_cast будет принимать неявные преобразования. no down-cast, no void*->T*, no U->T, если T имеет только явные конструкторы для U.

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

int a = 3.4;

Но неявное преобразование происходит от double до int. Такие вещи, как "неявный приведение", не существуют, поскольку приведение всегда является явным запросом на преобразование. Конструкция имени для boost::implicit_cast - прекрасная комбинация "приведение с использованием неявных преобразований". Теперь вся реализация boost::implicit_cast такова (объясняется здесь):

template<typename T> struct identity { typedef T type; };
template<typename Dst> Dst implicit_cast(typename identity<Dst>::type t)
{ return t; }

Идея состоит в том, чтобы использовать невыводимый контекст для параметра t. Это позволит избежать ловушек, таких как:

call_const_version(implicit_cast(this)); // oops, wrong!

Было бы желательно записать это следующим образом

call_const_version(implicit_cast<MyClass const*>(this)); // right!

Компилятор не может определить тип, который должен указать параметр шаблона Dst, поскольку он должен сначала знать, что такое identity<Dst>, так как он является частью параметра, используемого для дедукции. Но это, в свою очередь, зависит от параметра Dst (identity может быть явно специализированным для некоторых типов). Теперь мы получили круговую зависимость, для которой стандарт просто говорит, что такой параметр является не выводимым контекстом, и должен быть предоставлен явный шаблон-аргумент.

Ответ 2

Предпочитаете implcit_cast, если этого достаточно в вашей ситуации. implicit_cast менее мощный и безопаснее, чем static_cast.

Например, downcasting от базового указателя на производный указатель возможен с static_cast, но не с implicit_cast. С помощью обоих бросок возможен другой способ. Затем, когда вы бросаете из базы в производный класс, используйте implicit_cast, потому что он сохраняет вас в безопасности, если вы путаете оба класса.

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

Ответ 3

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

например.

int i = 100;
long l = i;

и

int i = 100;
long l = implicit_cast<long>(i);

- это точно такой же код

однако вы можете предоставить свои собственные неявные приведения для ваших собственных типов, перегружая implicit_cast, как показано ниже.

template <typename T>
inline T implicit_cast (typename mpl::identity<T>::type x) 
{
    return x;
}

Смотрите boost/implicit_cast.hpp для более

Надеюсь, что это поможет

ИЗМЕНИТЬ

На этой странице также говорится о implicit_cast Новый С++

Кроме того, основной функцией static_cast является выполнение не изменяющегося или семантического преобразования из одного типа в другой. Тип изменяется, но значения остаются идентичными, например.

void *voidPtr = . . .
int* intPtr = static_cast<int*>(voidPtr);

Я хочу посмотреть на этот указатель void, как если бы он был указателем int, указатель не изменился, а под обложками voidPtr имеет точно такое же значение, как intPtr. implicit_cast, тип изменяется, но значения после преобразования могут также отличаться.

Ответ 4

Неявные преобразования, явные преобразования и static_cast - это разные вещи. однако, если вы можете конвертировать неявно, вы можете явно конвертировать, и если вы можете явно конвертировать, вы можете статически ставить. Однако в другом направлении это неверно. Существует совершенно разумная взаимосвязь между неявным отбрасыванием и статические отливки. Первый является подмножеством последнего.

Подробнее см. раздел 5.2.9.3 стандарта С++.

В противном случае выражение e может быть явно преобразован в тип T, используя static_cast формы static_- cast (e), если декларация T t (e); хорошо сформирована, для некоторых изобретенных временная переменная t (8.5).

С++ поощряет использование static_casts, потому что делает преобразование "видимым" в программе. Использование самих бросков указывает на какое-то программируемое правило, которое стоит того, чтобы лучше использовать static_cast.