Блог

Приведения типов в стиле C (все 4) выглядят точно так же, как некоторые шаблоны функций. например

 template<typename TO, typename FROM>
TO dynamic_cast (FROM p);
  

будет использоваться как,

 dynamic_cast<Derived*>(p); // p is Base*
  

Почему не разрешается перегружать их стандартом языка для пользовательского использования? (например, мы можем перегрузить ключевые слова like new/delete или other operators )

Почему не разрешается перегружать их стандартом языка для пользовательского использования?

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

Единственный встречный пример, о котором я знаю, — это невозможность dynamic_cast перехода между экземплярами интеллектуального указателя:

 shared_ptr<Derived> pd = dynamic_cast<shared_ptr<Derived> >(pb);
  

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

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

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

Я думаю, причина та же, что и для ключевого слова you can’t overload language.

На самом деле, вы должны рассматривать их как ключевое слово языка, а не как шаблонную функцию, даже если они выглядят одинаково. ОТО, я не мог представить, каких катастроф можно было бы натворить, изменив значение этого конкретного аспекта C .

Редактировать
Я был почти уверен, что у кого-нибудь возник бы вопрос: «тогда почему вы можете перегружать new / delete ?». Я думаю, что настройка выделения / освобождения памяти — это то, что вам нужно в определенных сценариях, и преимущества, позволяющие вам перегружать их, перевешивают риски. Я не вижу никакого преимущества в подрыве системы типов C , поэтому я не могу придумать сценарий, в котором это было бы полезно. А ты?

Преобразование указателей с помощью dynamic_cast , reinterpret_cast и static_cast имеют четко определенные значения, и, вероятно, лучше не допускать перегрузки.
Было бы затруднительно разрешить пользователям изменять значение const_cast .

Остается только приведение типов объектов.

 struct A
{
  A() {};
  template <typename FROM>
  A(FROMamp;)  {
    std::cout << "Casting to A \o/" << std::endl;
  }

  template <typename TO>
  operator TO()  {
    std::cout << "Casting from A \o/" << std::endl;
    return TO();
  }
};
  

затем

   int i; A a;
  A toA = static_cast<A>(i);  //  Casting to A o/
  int fromA = static_cast<int>(a); // Casting from A o/
  

Надеюсь, у вас есть варианты использования получше, чем у меня 🙂

Вы не можете перегружать эти операторы. Возможно, это потому, что вы не можете изменить значение такой фундаментальной вещи, как говорят другие ответы. (Например, изменение значения для целых чисел или * оформления для генерации указателя на тип).

Сказав это, ничто не мешает вам определить ваши собственные обобщения приведенных функций, которые принимают аргумент и возвращают вещи, очень связанные с ним. На самом деле, я бы высказал противоположную точку зрения, вы никогда не должны использовать операции приведения языка ( static/dynamic/reinterpret_cast ), если вы не делаете довольно низкоуровневые вещи.

Что вы, вероятно, хотели бы сделать, так это определить свою собственную функцию приведения, которая большую часть времени ведет себя подобно функциям, предоставляемым языком, но время от времени они делают что-то более специфичное для ваших конкретных целей. Вы должны хорошенько подумать, что на самом деле делает эта функция, и правильно назвать ее. Какую стоимость времени выполнения вы можете себе позволить, какое поведение при «сбое» (выбросить выполнение?, вернуть нулевое значение?) и т.д.

Стандарт и многие библиотеки полны таких функций. Иногда они добавляют измененное поведение поверх приведения языка, в других случаях они делают больше. Некоторые примеры:

https://en.cppreference.com/w/cpp/memory/shared_ptr/pointer_cast

• std::static_pointer_cast ,
• std::dynamic_pointer_cast ,
• std::const_pointer_cast ,

• std::reinterpret_pointer_cast

• std::any_cast

• std::chrono::time_point_cast

(смотрите также https://www.boost.org/doc/libs/1_39_0/libs/smart_ptr/pointer_cast.html )

https://www.boost.org/doc/libs/1_42_0/libs/conversion/lexical_cast.htm

• boost::lexical_cast

https://www.boost.org/doc/libs/1_63_0/libs/conversion/cast.htm

• polymorphic_cast ,
• polymorphic_downcast ,
• polymorphic_pointer_cast
• polymorphic_pointer_downcast

https://www.boost.org/doc/libs/1_72_0/libs/numeric/conversion/doc/html/boost_numericconversion/improved_numeric_cast__.html

• boost::numeric_cast

https://www.boost.org/doc/libs/1_47_0/doc/html/boost_units/Quantities.html#boost_units .Количества.количество_конструкции_и_конверсии

• boost::units::quanity_cast .

Иногда они вообще не вызываются cast 🙂

https://en.cppreference.com/w/cpp/utility/variant/get_if

• std::get_if

Другой пример, для кода шаблона я написал эту функцию приведения, которая вызывается только в том случае, если преобразование может быть выполнено неявно:

     template<class To, class From, std::enable_if_t<std::is_convertible<From, To>{}, int> =0>
    To implicit_cast(Fromamp;amp; f){
        return static_cast<To>(f);
    }
  

https://godbolt.org/z/ym8MnJ