[Bug c++/107958] New: Ambiguity with uniform initialization in overloaded operator and explicit constructor

["nruslan_devel at yahoo dot com" <gcc-bugzilla@gcc.gnu.org>]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=107958

            Bug ID: 107958
           Summary: Ambiguity with uniform initialization in overloaded
                    operator and explicit constructor
           Product: gcc
           Version: unknown
            Status: UNCONFIRMED
          Severity: normal
          Priority: P3
         Component: c++
          Assignee: unassigned at gcc dot gnu.org
          Reporter: nruslan_devel at yahoo dot com
  Target Milestone: ---

Suppose we have the following example with a class that has to keep two
pointers. (I actually encountered this error with a more complex example, but
this one is just for illustration.) The problem arises when I attempt to use
the assignment operator and curly braces.

If I understand correctly, two possibilities exist when passing curly braces:

1. Use the overloaded operator= (implicitly convert curly braces to a pair). In
this particular example, we could have probably used make_pair but I
deliberately put curly braces to show how this error is triggered.

2. Use the constructor to create a new PairPtr instance and then copy it to the
old object through operator=

Both clang and gcc complain unless I mark the corresponding constructor as
'explicit'. To avoid the ambiguity with the second case, I mark the
corresponding constructor as 'explicit' and expect that the overloaded
operator= to be used. That seems to work with clang/llvm but not with gcc (see
the error below).

#include <iostream>
#include <utility>

struct PairPtr {

    PairPtr() {}

    PairPtr(const PairPtr &s) {
        a = s.a;
        b = s.b;
    }

    explicit PairPtr(int *_a, int *_b) {
        a = _a;
        b = _b;
    }

    PairPtr& operator=(const PairPtr &s) {
        a = s.a;
        b = s.b;
        return *this;
    }

    PairPtr& operator=(const std::pair<int *, int *>& pair) {
        a = pair.first;
        b = pair.second;
        return *this;
    }

    int *a;
    int *b;
};

void func(int *a, int *b)
{
    PairPtr p;

    p = { a, b };
}


Error (note that clang/llvm can compile the above code successfully!):

Note that 'explicit' for the constructor fixes the problem for clang/llvm but
does not fix the problem for gcc.

2.cpp: In function ‘void func(int*, int*)’:
2.cpp:38:20: error: ambiguous overload for ‘operator=’ (operand types are
‘PairPtr’ and ‘<brace-enclosed initializer list>’)
   38 |         p = { a, b };
      |                    ^
2.cpp:18:18: note: candidate: ‘PairPtr& PairPtr::operator=(const PairPtr&)’
   18 |         PairPtr& operator=(const PairPtr &s) {
      |                  ^~~~~~~~
2.cpp:24:18: note: candidate: ‘PairPtr& PairPtr::operator=(const
std::pair<int*, int*>&)’
   24 |         PairPtr& operator=(const std::pair<int *, int *>& pair) {
      |