C++ -- Why should we use explicit in this constructor?

Question

Please refer to Wikipedia:Strategy Pattern (C++)

class Context
{
    private:
        StrategyInterface * strategy_;

    public:
        explicit Context(StrategyInterface *strategy):strategy_(strategy)
        {
        }

        void set_strategy(StrategyInterface *strategy)
        {
            strategy_ = strategy;
        }

        void execute() const
        {
            strategy_->execute();
        }
};

Why it is a good practice to use explicit for the constructor of Context?

Thank you

@Potatoswatter: Anywhere you have a class whose name can't be said aloud in polite company. — James McNellis, Nov 08 '10 at 05:41
the above remark from James is not to be taken seriously; just for the naive beginner — Jaywalker, Nov 08 '10 at 06:20
To Potatoswatter, just define the constructor without using explicit. -- thank you — q0987, Nov 09 '10 at 04:37

score 14 · Answer 1 · answered Nov 08 '10 at 05:10

Because it's generally a good idea to use explicit unless you really want to allow implicit conversion. Since you're unlikely to use a Context object in a situation where you really gain anything from an implicit conversion, you're better off making it explicit.

Tony Delroy · Accepted Answer · 2012-03-12T01:31:32.133

Well, explicit constructors are always safe, but can be inconvenient. explicit ensures a compilation error should you provide a StrategyInterface* where a Context is expected. In doing so, it prevents construction of a temporary Context. This becomes particularly important in certain circumstances, e.g.:

Context takes ownership of the pointed-to StrategyInterface, and deletes it in the destructor
Context construction/destruction performs other expensive or inappropriate actions
it disambiguates some operations implicitly, and makes others ambiguous, where it might be more appropriate to have the programmer consider how to resolve the ambiguity (e.g. should an attempt to compare a Context and a StrategyInterface* produce a compile-time error, result in comparing StrategyInterface*s, StrategyInterfaces or Contexts?)

If a Context is practically a drop-in-replacement for a StrategyInterface, just with some minor logging or other enhancements, then it may be appropriate to allow implicit construction, much as std::string can be constructed from const char*. When they're clearly independent things, or when the lifetime of a Context should exist beyond any given usage of a StrategyInterface, then an explicit constructor's indicated.

(Note: these guidelines are pretty rough - more a starting point than an end - comments welcome)

C++ -- Why should we use explicit in this constructor?

2 Answers2

Linked