我有以下课程:
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视为抽象类。有些帮忙吗?
答案 0 :(得分:5)
你宣布:
virtual double price(double rate, const OptionPricer& optionPricer) const = 0;
在您的基类中但在派生类中获取参数的方法是错误的:
double price(const OptionPricer& optionPricer, double rate) const;
这不被视为覆盖。
如果某个成员函数vf在类Base中声明为virtual,并且 Derived,派生的,直接或间接派生的 Base,具有相同的成员函数声明
名称
参数类型列表(但不是返回类型)
cv修饰符
REF-限定符
然后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
};
答案 1 :(得分:1)
功能
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.