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
– James McNellis, Commented Nov 8, 2010 at 5:41
the above remark from James is not to be taken seriously; just for the naive beginner — Jaywalker
– Jaywalker, Commented Nov 8, 2010 at 6:20
To Potatoswatter, just define the constructor without using explicit. -- thank you — q0987
– q0987, Commented Nov 9, 2010 at 4:37

Jerry Coffin · Accepted Answer · 2010-11-08 05:10:14Z

15

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.

answered Nov 8, 2010 at 5:10

Jerry Coffin

494k83 gold badges656 silver badges1.2k bronze badges

Sign up to request clarification or add additional context in comments.

Comments

Tony Delroy · Accepted Answer · 2012-03-12 01:31:32Z

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)

Collectives™ on Stack Overflow

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

2 Answers 2

Comments

Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related