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

时间:2016-02-16 11:29:08

标签: c++ inheritance visual-c++ abstract-class

我有以下课程:

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视为抽象类。有些帮忙吗?

2 个答案:

答案 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.