What we should have is a top-level business rule that says something to the effect that we’re going to give the customer the best price currently available on their order. To do this, we want something like this:

std::vector possible_prices;

possible_prices.push_back(base_price);

for (auto const &discount : current_discounts)
if (discount.applies_to(order))
possible_prices.push_back(discount(order));

Price discounted_price = *std::min_element(possible_prices.begin(), possible_prices.end());

Price final_price = std::max(discounted_price, item.minimum_price);

Then, each `applies_to` only has to deal with *one* question: does this discount apply to this particular order? So, for your case of a sale that applies solely to online-only items, it would just be:

bool applies_to(Order order) {
return isSoldOnlineOnly(order.item);
}

Likewise for the red-tag, and so on.

This has substantial advantages beyond mere readability of the code. It also means that we’ve de-coupled the code for the individual discounts. When the sales manager decides to add some new discount, we define one new discount, and add it to `current_discounts`. When some sale ends, we remove it from `current_discounts`. Our overall logic is unaffected by the details of an individual discount.

This de-coupling also means that the code for any one discount is generally quite trivial–we have a business rule that relates to when one specific discount applies, and we embody that rule, by itself, in our code. Somebody who wants to modify the online-only sale doesn’t need to even see the code for the red-tag sale, not to mention figuring out how to fit in his change without affecting the other discounts.

Now, it may be that this doesn’t apply to the original code you were looking at (hard to guess since I’ve never seen it, and don’t eve have a clue of what sort of situation it’s dealing with). It is, however, my experience that if you’re running into the basic problem of complex and/or deeply nested `if` statements, you usually have a fundamental design problem. Expressing those complex conditions more clearly is obviously good, but it’s clearly a lot better to correct the design to eliminate the problem entirely (and that’s possible not only in this case, but in my experience in most others as well).

I agree about the negation when an “if” is followed by an “else” clause.
In my opinion, the code is more readable without the blank return statement. For example:

if(isSoldOnlineOnly()) {

} else {

}

Thanks, typo corrected.

I like your second one because most people find it easier to read positive logic in if() statements. I’d go even further and eliminate the else clauses since each branch is exclusive of the other. This way you know they’re not related to each other, and there is no further processing to be done

void Item::applyDiscount() {
  if(hasRedTag()) {
    return;
  }

  if(isSoldOnlineOnly()) {
    if(hasSpecialDayDiscount()) {
      price_ = std::max(minimumPrice, price_ - getSpecialDayDiscount());
    }
    return;
  }

  price_ *= 1 - getSaleDiscount();
}

Looks good to me!

Your version follows the specification in a more clear way, so adding only the guard and keeping the rest of the code as is could be a better alternative. e.g.

void Item::applyDiscount()
{
    if (hasRedTag()) {
        return;
    }
    
    if (isSoldOnlineOnly()) {
        if (hasSpecialDayDiscount()) {
            price_ = std::max(minimumPrice, price_ - getSpecialDayDiscount());
        }
    } else {
        price_ *= 1 - getSaleDiscount();
    }
}

Thanks Giannis, glad you liked it.
I think the guard is a good idea; it decreases nesting while following the spec. I actually intended to write about this in a later post, as a matter of fact.
And do you find the rest of your snippet more natural? This would typically be a case to discuss with the domain people then.

How about something like the following as an alternative solution for the applyDiscount method?

void Item::applyDiscount()
{
    if (hasRedTag()) {
        return;
    }
  
    if (!isSoldOnlineOnly()) {
        price_ *= 1 - getSaleDiscount();
    } else if (hasSpecialDayDiscount()) {
        price_ = std::max(minimumPrice, price_ - getSpecialDayDiscount());
    }
}