Givens:

Requirements:

Python structure

class MarketMachine:
    def __init__(self):
        self.market_data_handle = 42.0   # shared-looking state

    def price(self) -> float:
        print(f"  MarketMachine::price()  (handle = {self.market_data_handle})")
        return 100.0


class Stock(MarketMachine):
    def price(self) -> float:
        print(f"  Stock::price() → equity / parity value  (handle = {self.market_data_handle})")
        return 150.0


class Bond(MarketMachine):
    def price(self) -> float:
        print(f"  Bond::price() → bond floor  (handle = {self.market_data_handle})")
        return 98.5


class Convertible(Stock, Bond):
    def price(self) -> float:
        print("Convertible::price() — trying to combine both sides with super():")

        # FAULTY: super() only follows MRO and calls ONE parent
        equity_value = super().price()          # This will call Stock.price (left-first)
        # There is no clean way to get the other parent via super()

        bond_floor = 98.5   # hard-coded fallback — ugly and wrong

        conversion_probability = 0.65
        blended = (conversion_probability * equity_value +
                   (1 - conversion_probability) * bond_floor)
        result = max(blended, bond_floor)

        print(f"  → final convertible price = {result}")
        return result


if __name__ == "__main__":
    cb = Convertible()
    print("Calling price() on Convertible:")
    print("Final result:", cb.price())
    print("\nMRO:", Convertible.__mro__)

C++ structure

#include <iostream>
#include <algorithm>   // for std::max

class MarketMachine {
public:
    virtual double price() const {
        std::cout << "  MarketMachine::price()\n";
        return 100.0;
    }
    virtual ~MarketMachine() = default;
};

// Equity side
class Stock : public MarketMachine {
public:
    double price() const override {
        std::cout << "  Stock::price() → equity / parity value\n";
        return 150.0;   // example: conversion value (stock price × ratio)
    }
};

// Bond side
class Bond : public MarketMachine {
public:
    double price() const override {
        std::cout << "  Bond::price() → bond floor\n";
        return 98.5;    // example: straight bond value (clean + accrued)
    }
};

// The hybrid — realistic convertible
class Convertible : public Stock, public Bond {
public:
    // Realistic override: call BOTH parents and blend
    double price() const override {
        std::cout << "Convertible::price() — combining both sides:\n";

        // Explicit calls (required because of the diamond)
        double equity_value = Stock::price();   // parity / conversion value
        double bond_floor   = Bond::price();    // bond floor

        // Simple but realistic market-condition weighting
        // (in real life this would be a full model: volatility, credit, etc.)
        double conversion_probability = 0.65;   // depends on how far ITM, vol, etc.

        double blended = conversion_probability * equity_value
                       + (1.0 - conversion_probability) * bond_floor;

        // Many desks also do: max(bond_floor, parity) as a quick lower bound
        double result = std::max(blended, bond_floor);

        std::cout << "  → final convertible price = " << result << "\n";
        return result;
    }
};

int main() {
    Convertible cb;

    std::cout << "Calling price() on Convertible:\n";
    double p = cb.price();

    std::cout << "\nFinal result: " << p << "\n";

    // Still have the diamond problems underneath:
    // 1. Two separate MarketMachine sub-objects (duplicated state)
    // 2. Cannot do: MarketMachine* m = &cb;   // ambiguous base
    // 3. Cannot call cb.MarketMachine::price(); without qualification

    return 0;
}

Givens:

Requirements: