oop — Ковариантность и контравариантность в указателе функции C ++?

Учти это

class Base { };

class Derived : public Base { };

Base *f1(Derived *) { return {}; }
Derived *f2(Derived *) { return {}; }   // covariant
Base *f3(Base *) { return {}; } // contravariant
Derived *f4(Base *) { return {}; } // covariant & contravariant

using Callback = Base *(*)(Derived *);

Callback pfunc1 = f1;   // works of course

// These won't work...
Callback pfunc2 = f2;
Callback pfunc3 = f3;
Callback pfunc4 = f4;// So I have to make a wrapper for each
Base *f2_wrap(Derived *d)
{
return f2(d);
}

Base *f3_wrap(Derived *d)
{
return f3(d);
}

Base *f4_wrap(Derived *d)
{
return f4(d);
}

// Now it works
Callback pfunc2 = f2_wrap;
Callback pfunc3 = f3_wrap;
Callback pfunc4 = f4_wrap;

Так почему я не могу установить указатель на функцию, которая имеет Derived объект в качестве возвращаемого значения или функция, которая имеет Base объект в качестве аргумента (который работает в делегате c #)?

Я знаю, что могу обойтись с помощью функции-обертки, но почему она не является частью языковой функции?

1

Решение

Необработанные указатели функций совместимы только по присваиванию, когда типы точно совпадают

Тем не менее, вы можете использовать std::function:

#include <functional>

struct Base{};
struct Derived: Base{};

auto f1( Derived* ) -> Base*        { return 0; }
auto f2( Derived* ) -> Derived*     { return 0; }   // covariant
auto f3( Base* )    -> Base*        { return 0; }   // contravariant
auto f4( Base* )    -> Derived*     { return 0; }   // covariant & contravariant

auto main()
-> int
{
using Callback = std::function<auto( Derived* ) -> Base*>;

Callback pfunc1 = f1;   // works
Callback pfunc2 = f2;   // works
Callback pfunc3 = f3;   // works
Callback pfunc4 = f4;   // works
}

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

#include <functional>

struct Base{};
struct Derived: Base{};

struct F{ virtual auto f( Derived* ) -> Base* = 0; };

#define R override { return 0; }
struct F1: F { auto f( Derived* ) -> Base*      R };
struct F2: F { auto f( Derived* ) -> Derived*   R };   // covariant, OK
struct F3: F { auto f( Base* )    -> Base*      R };   // !contravariant
struct F4: F { auto f( Base* )    -> Derived*   R };   // !covariant & contravariant

Результат компиляции с MinGW g ++ 7.3.0:

> g ++ -c 2.cpp
2.cpp: 11: 21: ошибка: «Base * F3 :: f (Base *)» помечена как «override», но не переопределяет
struct F3: F {auto f (Base *) -> Base * R}; //! контравариантный
^
2.cpp: 12: 21: ошибка: «Derived * F4 :: f (Base *)» помечена как «override», но не переопределяет
struct F4: F {auto f (Base *) -> Производная * R}; //! ковариантный  контравариантный

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

2

Другие решения

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

C # имеет виртуальную машину и не допускает множественного наследования, поэтому C # имеет гораздо больше контроля в такой ситуации, вы не можете сравнивать C # и C ++.

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

class Base { };

class Derived : public Base { };

Base *f1(Derived *) { return {}; }
Derived *f2(Derived *) { return {}; }   // covariant
Base *f3(Base *) { return {}; } // contravariant
Derived *f4(Base *) { return {}; } // covariant & contravariant

using Callback = Base *(*)(Derived *);

Callback pfunc1 = f1;   // works of course

// These won't work (now it will work)...
Callback pfunc2 = (Callback)(f2); //explict cast
Callback pfunc3 = (Callback)f3;
Callback pfunc4 = (Callback)f4;
0

По вопросам рекламы ammmcru@yandex.ru
Adblock
detector