Overload Resolution: What is the role of explicit and the initialization syntax?

Question

Suppose I have an immutable String class as follows:

#include <iostream>
#include <string>

class String
{
public:
    explicit String(const char *Value) : Size(std::strlen(Value)), Value(new char[Size + 1])
    {
        std::memcpy(this->Value, Value, Size + 1);
        std::cout << Value << ", novice." << Size << std::endl;
    }
    template <typename T, std::size_t N> String(const T (&Value)[N]) : Size(N - 1), Value(new char[N])
    {
        std::memcpy(this->Value, Value, N);
        std::cout << Value << ", expert." << Size << std::endl;
    }
    ~String()
    {
        delete[] Value;
    }
private:
    const std::size_t Size;
    char *Value;
};

void main()
{
    auto &s = "Welcome to C++";
    String string = s;
    String str {s};
    String st(s);
    return;
}

I want to know the role explicit plays and how the initialization syntax makes a difference when the constructor overload is chosen.

I understand that for str and st, I am explicitly calling the constructor that takes a pointer to const char, so they print out:

Welcome to C++, novice.
Welcome to C++, novice.

But I don't understand why for string

Welcome to C++, expert.

is printed out. Please clarify how the overload is being selected.

Your string class is only immutable if you initialize it with another immutable C-style string. If you have a non-constant array of characters and create a `String` object from that array, then you can still modify the array and the supposedly immutable `String` object will also change. — Some programmer dude, Nov 14 '16 at 14:35
@BoPersson I do not think that dupe is right. It plays a part but there is other things going on here as well. — NathanOliver, Nov 14 '16 at 14:38
@Nathan - I think the answers to the other question is a very good match, [like this one](http://stackoverflow.com/a/121216/597607) using `explicit String`and everything. But you guys can reopen if you don't agree. — Bo Persson, Nov 14 '16 at 14:40
I did use `new` in the constructor initializer-list, and copied the string. Is it bad to do `new` in initializer list? — Anirban Sarkar, Nov 14 '16 at 15:02
@AnirbanSarkar Oops. I missed that. I'll delete the comment. — NathanOliver, Nov 14 '16 at 15:06

NathanOliver · Accepted Answer · 2016-11-14T15:12:18.810

1

With

String str {s};
String st(s);

The

explicit String(const char *Value)

The reason the pointer overload is chosen is because it is not templated. Both the pointer and the array constructors are considered as an exact match to s so it would be an ambiguity but since the array constructor is a template it is consider less of a match then the pointer constructor. Even if you removed the explicit the pointer overload would still be chosen.

Now with

String string = s;

explicit does matter because s is not a String. This means the compiler needs to implicitly convert it to one so it chooses the array constructor as it is an exact match and the only viable constructor as explicit constructors cannot be used in implicit conversions.

edited Nov 14 '16 at 15:12

answered Nov 14 '16 at 15:06

NathanOliver

171,901
28
288
402

So without `explicit` the pointer overload would be called since it is non-templated? – Anirban Sarkar Nov 14 '16 at 15:09
1

@AnirbanSarkar Yes, because the template has a lower precedence then the pointer constructor. – NathanOliver Nov 14 '16 at 15:10
Thank you for the clarification. – Anirban Sarkar Nov 14 '16 at 15:10

Overload Resolution: What is the role of explicit and the initialization syntax?

1 Answers1