没有合适的默认构造函数可用 - 默认构造函数在哪里调用？答案

【问题标题】：No appropriate default constructor available - Where the default constructor called?没有合适的默认构造函数可用 - 默认构造函数在哪里调用？
【发布时间】：2016-07-18 22:38:55
【问题描述】：

编译下面的代码，我在第 105 行得到了这个 error C2512: 'PayOffBridge': no appropriate default constructor available

我的问题是：默认构造函数在哪里调用？我该如何解决？

注意：这里提供的大部分代码来自 Mark Joshi - Design Patterns and Derivatives Pricing

#include <iostream>
#include <boost/random/mersenne_twister.hpp>
#include <boost/random/normal_distribution.hpp>
#include <boost/random/variate_generator.hpp>
#include <cmath>
#include <boost/shared_ptr.hpp>
#include <stdio.h>
#include <vector>

// *********************  PayOff3

class PayOff{
    public:
        PayOff(){};
        virtual double operator()(double Spot) const = 0 ;
        virtual PayOff* clone() const = 0;
        virtual ~PayOff(){}

    private:
};


class PayOffCall : public PayOff{
    public:
        PayOffCall(double Strike_);
        virtual double operator()(double Spot) const ;
        virtual ~PayOffCall(){}
        virtual PayOff* clone () const ;
    private:
        double Strike;
};

PayOffCall::PayOffCall(double Strike_) : Strike(Strike_) {

}

double PayOffCall::operator()(double Spot) const {
    return std::max(Spot - Strike, 0.0 );
}

PayOff* PayOffCall::clone () const {
    return new PayOffCall(*this);
}

// ********************* PayOff Bridge

class PayOffBridge {
    public :
        PayOffBridge(const PayOffBridge& original);
        PayOffBridge(const PayOff& innerPayOff);
        PayOffBridge& operator = (const PayOffBridge& original);
        ~PayOffBridge();

        inline double operator()(double Spot) const;

    private:
        PayOff* ThePayOffPtr;
};

inline double PayOffBridge::operator() (double Spot) const {
    return ThePayOffPtr->operator()(Spot);
}

PayOffBridge::PayOffBridge(const PayOffBridge& original){
    ThePayOffPtr = original.ThePayOffPtr->clone();
}

PayOffBridge::PayOffBridge(const PayOff& innerPayOff){
    ThePayOffPtr = innerPayOff.clone();
}

PayOffBridge& PayOffBridge::operator = (const PayOffBridge& original){
    if (this != &original){
        delete ThePayOffPtr;
        ThePayOffPtr = original.ThePayOffPtr->clone();
    }
    return *this;
}

PayOffBridge::~PayOffBridge(){
    delete ThePayOffPtr;
}

// *********************  Vanilla2

class VanillaOption {

    public:
        VanillaOption(const PayOffBridge& thePayOff, double expiry);
        VanillaOption(const VanillaOption& original);
        VanillaOption& operator() (const VanillaOption& original);
        ~VanillaOption();

        double GetExpiry() const ;
        double OptionPayOff(double Spot) const ;

    private:
        double Expiry;
        PayOffBridge ThePayOffBridge;
};

VanillaOption::VanillaOption(const PayOffBridge& thePayOff, double expiry) : Expiry(expiry), ThePayOffBridge(thePayOff){
}

VanillaOption::VanillaOption(const VanillaOption& original){
    Expiry=original.GetExpiry();
    ThePayOffBridge = original.ThePayOffBridge;
}


double VanillaOption::GetExpiry() const {
    return Expiry;
}
double VanillaOption::OptionPayOff(double Spot) const {
    return ThePayOffBridge(Spot);
}

VanillaOption& VanillaOption::operator() (const VanillaOption& original){
    if (this != &original){
        Expiry=original.GetExpiry();
        ThePayOffBridge = original.ThePayOffBridge;
    }
    return *this;
}

VanillaOption::~VanillaOption(){
}



int main (){

}

【问题讨论】：

在VanillaOption的复制构造函数中，你不使用构造函数的初始化列表，因此它必须默认构造VanillaOption的所有成员。就像参数化的构造函数一样

标签： c++ default-constructor

【解决方案1】：

VanillaOption(const VanillaOption& original) 没有初始化列表，这意味着成员必须是默认构造的。实现它

VanillaOption::VanillaOption(const VanillaOption& original)
  : Expiry(original.GetExpiry()),
    ThePayOffBridge(original.ThePayOffBridge)
{}

【讨论】：

或者在这种情况下只是VanillaOption::VanillaOption(const VanillaOption&) = default;。
为什么这样做与初始化列表不同？我怎么知道我必须使用初始化列表而不是在复制构造函数中编写代码？
您的原始代码尝试默认构造这两个成员，然后分配给他们。复制构造和复制分配是两个不同的东西：int x = 42; 与int x; x = 42; 不太一样至于你如何知道 - 我想你学习任何其他语言特征的方式相同：从你的教科书，你的老师，您的在线教程，或在 StackOverflow 上提问。