convariant return types

[pproger]

добрый день. кто нить разбирался с сабжем? (конвариантный возвращаемый тип).

во всех примерах приводят примерно одинаковый код

class Base {
public:
    virtual Base* clone() const
    {
        return new Base(*this);
    }
};

class Derived : public Base {
public:
    virtual Base* clone() const
    {
        return new Derived(*this);
    }
};

и хотим вызывать это так

Derived* d = new Derived;
Derived* d2 = d->clone();

но компиль не дает нам этого сделать, требуя явного преобразования Base * в Derived *. для этого можно поменять возвращаемое значение у замещенной вирт функции

class Base {
public:
    virtual Base* clone() const
    {
        return new Base(*this);
    }
};

class Derived : public Base {
public:
    virtual Derived * clone() const
    {
        return new Derived(*this);
    }
};

и такой код сработает.

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

в общем, разъясните мне идиоту.
кой какая инфа есть тут
http://www.lwithers.me.uk/articles/covariant.html
но так же ничего не объяснено, зачем тут виртуал

[BOBAH13]

Я честно говоря прочитал и не смог понять что вас именно волнует так?

virtual Base* clone() const
    {
        return new Derived(*this);
    }

тут по моему и так ясно, вы возвращаете другой тип, по этому и требует приведение типов. А то, что если есть адрес Base*, но вы знаете что это Derived* на самом деле, то конечно можно сделать такое (Derived*)(Base*)->DerivedField;

Возможно я не понял, но вроде все логично.

[pproger]

2BOBAH13
да, возвращается ДРУГОЙ тип и требует приведения типа, если мы хотим это использовать вот так

Derived* d = new Derived;
Derived* d2 = d->clone();

но авторы статьи не хотят кастовать типы! и предлагают написать так

class Base {
public:
    virtual Base* clone() const
    {
        return new Base(*this);
    }
};

class Derived : public Base {
public:
    virtual Derived * clone() const
    {
        return new Derived(*this);
    }
};

да, будет работать идеально. мой же вопрос, ЗАЧЕМ clone виртуальна? если для достижения эффекта описанного в статье нужно вызвать объект НЕ ЧЕРЕЗ базовый класс, а напрямую? т.е чем этот код отличается от этого?

class Base {
public:
    Base* clone() const
    {
        return new Base(*this);
    }
};

class Derived : public Base {
public:
    Derived * clone() const
    {
        return new Derived(*this);
    }
};

    Derived* d = new Derived;
    Derived* d2 = d->clone();

зачем там виртаул?) тип все равно нельзя использовать полиморфно. еслиб можно было написать так

Base* d = new Derived; // создали derived
Derived* d2 = d->clone(); // тип возвращаемого значения clone берется из Base!!! и опять нужно приведение типа!

ЕСЛИ БЫ это работало (т.е если б тип возвращаемого значения вирт функции брался у derived-a), согласен на 100500%, это удобно. но это не работает

[BOBAH13]

Я не уверен, но на то что, у Base и Derived есть один и тот же метод clone, может virtual говорит о том, что Base::clone() не будет доступен т.к. существует теперь Derived::clone(). Но на счет данной теории "зачем?" стоит наверное посмотреть спецификацию C++, а именно virtual, боюсь я не могу ответить на столь специфический вопрос.

[UltimaBeaR]

эм, какбэ в твоем коде (который без виртуал) ты создаешь экземпляр Base когда тебе нужно экземпляр Derived.. а это согласись немного не то что тебе надо

.. вобщем виртуал там для того чтоб ты мог из указателя на base (который на самом деле dreived) вызвать клон и получить derived, другого virtual не делает, если оно тебе ненадо то и не пиши его, меньше объект весить будет

[pproger]

2BOBAH13
нет, virtual тут говорит как и всегда, что clone замещается в derived. но типы возвращаемого значения всегда берется из Base, поэтому нет возможности использовать clone полиморфно.

я пока нашел один ответ. в base объявлена чисто виртуальная функция clone, остальные классы ее реализуют. и виртуальность тут нужна, чтоб не забыть в новом подклассе переопределить clone.
но мне этот ответ не нравится

2UltimaBeaR
ты невнимательно читал. яж описал, что ЕСЛИ БЫ ЭТО РАБОТАЛО (то что ты написал), ЭТО БЫЛО БЫ ОХРЕНЕТИТЕЛЬНОЙ СУПЕРФИЧЕЙ

. вобщем виртуал там для того чтоб ты мог из указателя на base вызвать клон и получить derived

на, вызови

class Base {
public:
    virtual Base* clone() const
    {
        return new Base(*this);
    }
};

class Derived : public Base {
public:
    virtual Derived * clone() const
    {
        return new Derived(*this);
    }
};

int main()
{
    Base* d = new Derived;
    Derived* d2 = d->clone();
    return 0;
}

типы кастовать нельзя! с кастом и так понятно. и почему это НЕ работает, я тоже написал

[UltimaBeaR]

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

[pproger]

2UltimaBeaR

Вобще поидее если ты объявляешь виртуальную функцию с другим заголовком(возвращает другой тип) то эта уже другая виртуальная функция

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

[UltimaBeaR]

дейсвтительно перезаписывается, тогда могу предположить что при полиморфном юзании clone() надо будет в любом случае приводить тип, если же не использовать виртуал то полиморфно юзать вобще не выйдет

[pproger]

2UltimaBeaR
возможно. но если бы я хотел приводить тип, я бы не стал менять тип возвращаемого значения с Base* на Derived*, оставил бы Base*, приводил бы тип и этой темы вообще бы не было. а возможность не приводить тип при неполиморфном использовании не очень то и полезна