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) {
|
