Avoiding need to specify using operator= - c++

Question

I'm attempting to create a base class for creating helpers around various scoped operations, and to do so the base class allows the assignment of a callable. A simple predicate determines whether or not the callable is invoked. Regardless, the dtor is always invoked.
The catch is that each derived class needs to explicitly inherit the operator=. Is there a way to write the base class so that this is not required?
#include <functional>
#include <iostream>
using callback_t = std::function<void(void)>;
struct C
{
constexpr C(bool ok) : ok_{ok} {}
bool ok_ {false};
bool operator=(callback_t fn) const noexcept {
return ok_ ? fn(), true : false;
}
~C() noexcept {
std::cout << "end\n";
}
};
struct D final : public C
{
using C::operator=;
};
int main()
{
auto predicate = [] { return true; };
D{predicate()} = [] {
std::cout << "ok\n";
};
D{false} = [] {
std::cout << "wrong\n";
};
}
(also https://gcc.godbolt.org/z/eh8ncffos)
Removing the line from struct D
using C::operator=;
causes compile errors since Ds default copy-operator preempts C's custom operator=.
<source>: In function 'int main()':
<source>:24:9: error: no match for 'operator=' (operand types are 'D' and 'main()::<lambda()>')
24 | };
| ^
<source>:14:12: note: candidate: 'constexpr D& D::operator=(const D&)'
14 | struct D final : public C
| ^
<source>:14:12: note: no known conversion for argument 1 from 'main()::<lambda()>' to 'const D&'
<source>:14:12: note: candidate: 'constexpr D& D::operator=(D&&)'
<source>:14:12: note: no known conversion for argument 1 from 'main()::<lambda()>' to 'D&&'
<source>:27:9: error: no match for 'operator=' (operand types are 'D' and 'main()::<lambda()>')
27 | };
| ^
<source>:14:12: note: candidate: 'constexpr D& D::operator=(const D&)'
14 | struct D final : public C
| ^
<source>:14:12: note: no known conversion for argument 1 from 'main()::<lambda()>' to 'const D&'
<source>:14:12: note: candidate: 'constexpr D& D::operator=(D&&)'
<source>:14:12: note: no known conversion for argument 1 from 'main()::<lambda()>' to 'D&&'

Answer 1

The catch is that each derived class needs to explicitly inherit the operator=. Is there a way to write the base class so that this is not required?
No, this isn't possible.
The rule is that functions in different scopes do not overload. Since the derived class will always have something named operator= (either the derived class declares one itself, or the copy assignment operator is declared implicitly... even if it would be defined as deleted). So when you do derived = x;, name lookup for operator= will start in Derived and, having found candidates, stop there. It won't keep going to look into the base class... unless you bring in that candidate with a using-declaration like you demonstrated the question.
The only way to still use operator= but stash the functionality somewhere would be to actually invert your class hierarchy. Instead of:
struct C {
// ... implementation here ...
};
struct D : C {
using C::operator=;
};
// use D
you can do:
template <typename Derived>
struct C {
// implementation here
};
struct D { }
// use C<D>
This way, C is actually the class you're interacting with, so its operator= would be the first candidate considered.
Alternatively, if you simply don't use = as the spelling for this operation, every other operator is available and they would not need a using-declaration in the derived class to work.
Given the comment about wishing to avoid parentheses, your list of binary operators that would not require one are: ->*, +, -, *, /, %, ^, &, |, &&, ||, <, >, <<, and >> (plus the compound-assignment versions of those).
I'm deliberately excluding == and <=> from the list because those are special and just don't.