Overloading explicit constructor in C++

Question

I am reading a book and got some code for class designing that I do not really understand.

class Queue {
public:
    Queue(size_t capacity) {}
    explicit Queue(int capacity) : entries_(capacity) {}
...
private:
    vector<int> entries_;
...
};

And another similar one,

class LruCache {
public:
    LruCache(size_t capacity) {}
    explicit LruCache(int capacity) : capacity_(capacity) {}
...
private:
    int capacity_;
...
};

I have two questions,

Could we overload methods purely on the explicit keyword, like the const keyword? In my case, the argument type is a little different though, an int and a size_t.
A more important question is why. Why do we need a overloaded explicit constructor? In C++ primer, I believe it says overloading functions with similar argument types is not recommended.

edit:

My 2nd question is more about the code piece above. Why does it have a constructor with an int argument and then an explicit constructor with a size_t argument, and int and size_t are types that are really close. So it should not be necessary to define two constructors, for each of them. I believe the author defines two constructors for a reason, but I do not know why, and that should be my 2nd question about. Not a general question about what does explicit keyword do. Sorry.

`int` and `size_t` are different types. The code isn't "overloaded on explicit", it's overloaded on `size_t` and `int`; and if an explicit constructor is chosen where it is not allowed, the code is ill-formed — M.M, Jun 11 '18 at 05:21
The `explicit` is not part of the function signature, so functions can't be overloaded by it. — Some programmer dude, Jun 11 '18 at 05:21
Does the book talk about why it has these constructors? It seems like a poor idea to me just based on what is posted. — M.M, Jun 11 '18 at 05:22
1. No; 2. explicit has nothing to do with overloading, it simply prevents given ctor to be considered for automatic conversions; affects only one-parameter ctors — C.M., Jun 11 '18 at 05:22
@C.M. - It affects more since C++11. https://stackoverflow.com/questions/39122101/explicit-constructor-taking-multiple-arguments — StoryTeller - Unslander Monica, Jun 11 '18 at 05:25
Folks, your answers would be excellent if you wrote them as answers instead of comments... — , Jun 11 '18 at 05:25
@M.M I guess not. That's why I am asking. I ignored it when I first saw it because I thought it was not a big deal but it keeps coming again. The book is "Elements of Progamming Interviews" btw — Sean, Jun 11 '18 at 05:26
@NickyC I cannot answer part 2 of the question, it would require more context (and it might turn out that the answer is just "there is no answer, this code is rubbish") — M.M, Jun 11 '18 at 05:38

R Sahu · Answer 1 · 2018-06-11T05:50:00.687

Could we overload methods purely on the explicit keyword

No.

Why do we need a overloaded explicit constructor?

To avoid implicit conversions.

Let's say Queue had been defined as:

class Queue {
  public:
    // No constructor with a size_t.
    Queue(int capacity) {}
  ...
};

With that, an int will be implicitly converted to Queue when needed.

void bar(Queue const& q) { ... }

bar(10); // This would be valid without the explicit keyword.
         // 10 will be implicitly converted to Queue(10).

Sometimes such implicit conversions lead to hard to understand and maintain code. The explicit qualifier is used to avoid such implicit conversions.

With the explicit qualifier in place, you'll be required to use

bar(Queue(10));

which is a lot easier to understand.

Why does it have a constructor with an size_t argument and then an explicit constructor with a int argument,

I don't see any reason why you would need the two overloads -- explicit or not. If the book does not explain why they are needed, we can only attribute it to lack of clarity on the part of the author.

`bar(10)` is valid in the existing code though, since the non-explicit `size_t` constructor is chosen. (Which has different semantics ot the existing constructor) — M.M, Jun 11 '18 at 05:36
That shouldn't be true. "10" shouldn't have type size_t. bar(10z) or bar((size_t)10) could choose the Queue(size_t) constructor. — William Cushing, Aug 21 '20 at 18:36

Overloading explicit constructor in C++

1 Answers1