c++ explicit keyword for function without arguments

itemprop="text">

Is
there a reason to use the explicit keyword for a function that
doesn't take any arguments? Does it have any effect? I'm wondering because I just came
across the line

explicit
char_separator()

near the end of
the page documenting boost::char_separator
( href="http://www.boost.org/doc/libs/1_47_0/libs/tokenizer/char_separator.htm"
rel="noreferrer">http://www.boost.org/doc/libs/1_47_0/libs/tokenizer/char_separator.htm
), but it's not explained any further there.

class="post-text" itemprop="text">

class="normal">Answer

Reading
href="http://www.boost.org/doc/libs/1_47_0/libs/tokenizer/char_separator.htm#members"
rel="noreferrer">explanation of members
:

explicit char_separator(const
            Char* dropped_delims,

 const Char* kept_delims = "",

            empty_token_policy empty_tokens = drop_empty_tokens)
explicit
            char_separator()

The
explicit keyword for the 1st constructor requires explicit
creation of objects of char_separator type.
href="https://stackoverflow.com/questions/121162/what-does-the-explicit-keyword-in-c-mean">What
does the explicit keyword mean in C++? covers the explicit keyword very
well.

The explicit
keyword for the 2nd constructor is a noise and is
ignored.

EDIT

From
the c++ standard :

7.1.2 p6 tells
:

The explicit
specifier shall be used only in declarations of
constructors within a class
declaration; see
12.3.1.

12.3.1
p2 tells :

An
explicit constructor constructs objects just like non-explicit
constructors,
but does so only where direct-initialization syntax
(8.5) or where casts
(5.2.9, 5.4) are explicitly used. A default
constructor may be an explicit
constructor; such a constructor will be
used to perform
default-initialization or value-initialization (8.5).

[Example:

class
            Z {
public:
explicit Z();
explicit Z(int);
//
            ...
};
Z a; // OK: default-initialization performed
Z a1 =
            1; // error: no implicit conversion

Z a3 = Z(1); // OK: direct
            initialization syntax used
Z a2(1); // OK: direct initialization syntax
            used
Z* p = new Z(1); // OK: direct initialization syntax used
Z a4
            = (Z)1; // OK: explicit cast used
Z a5 = static_cast(1); // OK:
            explicit cast
            used

—end
example]

So,
the default constructor with the explicit keyword is the same
as without this keyword.