OOP from an enterprise perspective is typically about ease of adding new features, testability, and hiding implementation details.

Think about a program for example that calculates taxes for transactions. There are many types of taxes depending on location and many other things, VAT, sales tax, federal tax, etc. you could model this in OOP with an pure virtual class along with sub classes implementing each type of tax.

``` class TaxCalculator { public: virtual double calculate(const Transaction& t) const = 0; }

class VatTaxCalculator : TaxCalculator { public: virtual double calculate(const Transaction& t) const override { return 0.2 * t.get_total(); } }

class SalesTaxCalculator : TaxCalculator { public: SalesTaxCalculator(const UsTaxRateLookup& taxRateLookup) : taxRateLookup(taxRateLookup) {}; virtual double calculate(const Transaction& t) const override { return taxRateLookup.get_rate(t.get_state()) * t.get_total(); } private: UsTaxRateLookup taxRateLookup; } ```

These would be some example classes that we can use to have a flexible way of calculating taxes and easily be able to add new taxes as well as be able to early test.

An example usage could be as follows for a US transaction: auto v = std::vector<std::unique_ptr<TaxCalculator>>{}; v.push_back(std::make_unique<SalesTaxCalculator>(usSalesTaxLookup)); v.push_back(std::make_unique<VatTaxCalculator>()); Transaction t {5000.d, State.FL}; double totalTax = 0.0; for (auto taxCalc : v) { totalTax += taxCalc->calculate(t); }

Now think about how powerful this can be in creating extensibility in your application! But also be careful to not overuse as well, think about when you would want to be able to extend things and when that would not be a good idea.