不明白为啥这个类被认为是抽象类

Posted 2023-02-23

【中文标题】不明白为啥这个类被认为是抽象类

【英文标题】：Don't understand why this class is considered as abstract class不明白为什么这个类被认为是抽象类

【发布时间】：2016-02-16 11:29:07

【问题描述】：

我有以下课程：

EuropeanOption.h

#pragma once

class OptionPricer;

class EuropeanOption

protected:

    double dividend;

    double strike;

    double vol;

    double maturity;

    double spot;

public:
    EuropeanOption(void);

    virtual ~EuropeanOption(void);

    virtual double price(double rate, const OptionPricer& optionPricer) const = 0;

    virtual short getSign() const =0;

    double getDividend() const;
    double getStrike() const;
    double getVol () const;
    double getMaturity() const;
    double getSpot() const;


    void setDividend(double dividend_);
    void setStrike(double strike_);
    void setVol(double vol_);
    void setMaturity(double maturity_);
    void setSpot(double spot_);
;

EuropeanOption.cpp

#include "OptionPricer.h"
#include "EuropeanOption.h"


EuropeanOption::EuropeanOption(void)




EuropeanOption::~EuropeanOption(void)




double EuropeanOption::getDividend() const

    return dividend;


double EuropeanOption::getMaturity() const

    return maturity;


double EuropeanOption::getStrike() const

    return strike;


double EuropeanOption::getSpot() const 

    return spot;


double EuropeanOption::getVol() const

    return vol;



void EuropeanOption::setDividend(double dividend_)

    dividend = dividend_;


void EuropeanOption::setMaturity(double maturity_)

    maturity = maturity_;


void EuropeanOption::setSpot(double spot_)

    spot = spot_;


void EuropeanOption::setVol(double vol_)

    vol = vol_;


void EuropeanOption::setStrike(double strike_)

    strike = strike_;

EuropeanCall.h

#pragma once

    #include "EuropeanOption.h"

    class EuropeanCall :
        public EuropeanOption
    

    public:
        EuropeanCall(void);
        EuropeanCall(double spot_, double strike_, double maturity_, double vol_, double dividend_ = 0);

        ~EuropeanCall(void);

        short getSign() const;
        double price(const OptionPricer& optionPricer, double rate) const;
    

;

EuropeanCall.cpp

#include "EuropeanCall.h"
#include "OptionPricer.h"
#include <cstdlib>


EuropeanCall::EuropeanCall(void)




EuropeanCall::EuropeanCall(double spot_, double strike_, double maturity_, double vol_, double dividend_)

    spot = spot_;
    strike = strike_;
    maturity = maturity_;
    vol = vol_;
    dividend = dividend_;


EuropeanCall::~EuropeanCall(void)



short EuropeanCall::getSign() const

    return 1;




double EuropeanCall::price(const OptionPricer& optionPricer, double rate) const

    return optionPricer.computePrice(*this, rate);

OptionPricer.h

#pragma once
#include "EuropeanOption.h"

class OptionPricer

public:
    OptionPricer(void);

    virtual double computePrice(const EuropeanOption& option, double rate) const =0;
    virtual ~OptionPricer(void);
;

OptionPricer.cpp

#include "OptionPricer.h"


OptionPricer::OptionPricer(void)




OptionPricer::~OptionPricer(void)

在我的主函数中，当尝试像这样实例化 EuropeanCall 时：

EuropeanCall myCall(spot,strike,maturity,vol);

我收到以下错误消息： 不允许抽象类类型“EuropeanCall”的对象

我不明白为什么编译器将 EuropeanCall 视为一个抽象类。请帮忙？

【问题讨论】：

你听说过MVCE吗？

【参考方案1】：

你声明：

virtual double price(double rate, const OptionPricer& optionPricer) const = 0;

在您的基类中，但在派生类中以错误的方式获取参数：

double price(const OptionPricer& optionPricer, double rate) const;

这不被视为覆盖。

如果某个成员函数 vf 在类 Base 中被声明为 virtual，并且 一些派生类，直接或间接派生自 Base，具有相同的成员函数声明

名字

参数类型列表（但不是返回类型）

cv 限定符

引用限定符

那么 Derived 类中的这个函数也是虚的（无论是 不是在其声明中使用关键字 virtual）并覆盖 Base::vf（无论是否在其 声明）。

从 C++11 开始，您可以使用 override 说明符来确保函数确实是虚拟的，并且正在覆盖基类中的虚拟函数。

struct A

    virtual void foo();
    void bar();
;

struct B : A

    void foo() const override; // Error: B::foo does not override A::foo
                               // (signature mismatch)
    void foo() override; // OK: B::foo overrides A::foo
    void bar() override; // Error: A::bar is not virtual
;

【讨论】：

也许是一个很好的机会来提及旨在帮助修复此类错误的 override 关键字？

【参考方案2】：

功能

virtual double price(double rate, const OptionPricer& optionPricer) const = 0;

是纯虚函数，因此类是抽象的。您不能在具有纯虚函数的类的实例上进行实例化。

您尝试的覆盖与此函数签名不匹配；

double price(const OptionPricer& optionPricer, double rate) const;

参数的顺序很重要。要捕获此类问题，您可以使用 override 说明符，编译器将检查该函数是否被覆盖。

double price(const OptionPricer& optionPricer, double rate) const override;
// The override above will cause a compiler error.