实现利用多个其他非继承类的 C++ 类方法？

Question

所以，我将尽最大努力定义我的问题，所以请多多包涵。我正在从事一项基本的财务任务，其中我为不同的基类制作了多个头文件：它们是Assets、Position 和Portfolio。 Assets 是我的基类，Position 类包括通过前向声明对Assets 对象的引用，Portfolio 类通过前向声明包含对Position 类的类似引用。

现在，我正在尝试在 Portfolio 中创建一个名为 getPortfolioValue 的方法，该方法将根据该对象是否是 Asset 的派生类之一（Equity、Preferred）返回投资组合的 Position 对象的市场价值和Bond。

其中每个都有一个 getMarketValue 方法被调用（实际上生成数字答案），具体取决于它们继承的 getter getAssetType 告诉我它们的资产类型是什么。

getPortfolioValue 在Portfolio.hpp 中定义，并在Position.hpp 中实现（由于前向声明），但会出现各种“不完整类型”错误。有问题的部分在倒数第二个代码的底部 (Position.hpp)。

我已尝试提供最干净的 MWE。有人知道如何使这个必须跨越> 2个头文件的getPortfolioValue方法工作吗？非常感谢您。

错误图片：

这是我的代码：

Assets.hpp

#ifndef Assets_hpp
#define Assets_hpp
#include <stdio.h>
#include <fstream>
#include <string>
#include <cmath>

#include "Position.hpp"
#include "Portfolio.hpp"

using namespace std;


class Asset{
private:
    string assetType;
    double currentPrice;
    string securityIssuer;
    string securitySymbol;

public:
    Asset(const string& a = "n/a", const double& b = 0.0, const string& c = "n/a", const string& d = "n/a") :
    assetType(a), currentPrice(b), securityIssuer(c), securitySymbol(d)
    {
    };

    virtual string getAssetType();
    virtual double getMarketValue(const int& n);

    virtual ~Asset() {};

};

class Equity: public Asset{
public:

    Equity(const string& a = "EQUITY", const double& b = 0.0, const string& c = "n/a", const string& d = "n/a") :
    Asset(a, b, c, d) 
    {                       
    }:

    virtual string getAssetType(); //Virtual version of Asset's getAssetType
    virtual double getMarketValue(const int& n);


};

class Preferred: public Equity {
public:
    Preferred(const string& a = "PFD", const double& b = 0.0, const string& c = "n/a", const string& d = "n/a") :
    Equity(a, b, c, d)
    {
    };

    virtual double getMarketValue(const int& n);
};


class bond: public Asset{
private:
    double coupon_rate;
    double coupon_freq;
    double par;

public:
    bond(const string& a = "BOND", const double& b = 0.0, const string& c = "n/a", const string& d = "n/a", double e = 0.0, double f = 0.0, double g = 0.0) :
    Asset(a, b, c, d), coupon_rate(e), coupon_freq(f), par(g)
    {
    };

    double bond_value(int num_bonds);

    virtual string getAssetType(); //Virtual version of Asset's getAssetType
    virtual double getMarketValue(const int& n);

};

#endif /* Assets_hpp */

资产.cpp

#include "Assets.hpp"

string Asset::getAssetType() {
    return assetType;
}


string Equity::getAssetType() { //Virtual implementation for Equity.
    return "EQUITY";
}


string bond::getAssetType() { //Virtual implementation for bond.
    return "BOND";
}

Position.hpp

#ifndef Position_hpp
#define Position_hpp
#include <stdio.h>
#include <fstream>
#include <cmath>
#include <string>
#include "Portfolio.hpp"

using namespace std;

class Asset;

class Position{
private:
    Asset* base;
    int position_size;
    double cost_basis;
    double position_age;

public:
    Position(Asset* a, const int& b = 0.0, const double& c = 0.0,
             const double& d = 0.0) :
    base(a), position_size(b), cost_basis(c), position_age(d)              
    {                                                                      
    };

    Asset* getAssetBase() { return base;}      //Getter
    void setAssetBase(Asset* b) { base = b;}   //Setter

};

//  ****************PROBLEM RIGHT BELOW HERE********************************

inline double Portfolio::getPortfolioValue(const int& n) {
if (position->getAssetBase()->getAssetType() == "EQUITY") {
    return position->getAssetBase()->getMarketValue(const int& n);
}

else if (position->getAssetBase()->getAssetType() == "PREFERRED") {
    return position->getAssetBase()->getMarketValue(const int& n);
}

else if (position->getAssetBase()->getAssetType() == "BOND"){
    return position->getAssetBase()->getMarketValue(const int& n);
    }
}
#endif /* Position_hpp */

Portfolio.hpp

#ifndef Portfolio_hpp
#define Portfolio_hpp
#include <stdio.h>
#include <fstream>
#include <string>
#include <cmath>

class Position;

class Portfolio {
private:
    Position* position;
    int num_positions;

public:
    Portfolio(Position* a, const int& b) : position(a), num_positions(b)
    {
    };

    Portfolio(const Portfolio&);

    Position* getPosition() { return position;}     //Getter

    double getPortfolioValue(const int& n); //Both of these implemented in Position header.
    double PortolioCostBasis();


};

#endif /* Portfolio_hpp */

Answer 1

您的包含不是基于类的依赖关系，这是主要问题的来源。

从 "Assets.hpp" 中删除这些行，因为类 Asset、Equity、Preferred 和 bond 不依赖于 Position 和 Portfolio：

#include "Position.hpp"
#include "Portfolio.hpp"

这里有语法错误（去掉“:”，在类似函数后面也去掉“;”）：

Asset(a, b, c, d) 
{                       
}:

从“Position.hpp”中删除这一行，因为Position不依赖于Portfolio：

#include "Portfolio.hpp"

还将Portfolio::getPortfolioValue 的定义移动到它所属的“Portfolio.hpp”中：

class Portfolio {
public:
    double getPortfolioValue(const int& n) {
        if (position->getAssetBase()->getAssetType() == "EQUITY") {
            return position->getAssetBase()->getMarketValue(const int& n);
        }

        else if (position->getAssetBase()->getAssetType() == "PREFERRED") {
            return position->getAssetBase()->getMarketValue(const int& n);
        }

        else if (position->getAssetBase()->getAssetType() == "BOND"){
            return position->getAssetBase()->getMarketValue(const int& n);
        }
    }
    /* other stuff omitted for brevity */
};

现在您的Portfolio 类依赖于Position 和Asset，因此您必须在"Portfolio.hpp" 中包含它们的标题：

#include "Position.hpp"
#include "Assets.hpp"

同时从 "Portfolio.hpp" 中删除前向声明：

class Position;

当您调用Position 的方法时，前向声明是没有用的。您需要完整的声明。

这应该可以修复编译错误。

为什么你在getPortfolioValue() 中有这些ifs 仍然很奇怪。您在所有这些分支中都在做同样的事情......

Answer 2

问题是您需要使用if(position->getAssetBase()->getAssetType() == "Equity") 而不是if(position->getAssetBase()->getAssetType()= "Equity")。

希望这会有所帮助。

Answer 3

演示问题的内联方法取决于asset.h 中的定义，但您在定义问题函数时并未包含asset.h。我不确定在问题函数之前是否仅包含asset.h 是否可以解决问题（这里可能存在我没有看到的循环依赖关系）。