On 4/29/26 09:18, Sebastian Wittmeier via Std-Proposals wrote:
AW: [std-proposals] Translation-unit-local functions that access private class fields

Hi André,

I think you got the point itself.

As Thiago pointed out, it does not have to be necessarily templates.

It probably is enough, if the member function is defined inside the header file, e.g. directly within the declaration of the class or marked as inline.

 

Then overload resolution could differ even for calls (to private member functions) within the class.


Not sure I understand. Is this what you mean?

class Foo {
 public:
  Foo() {
    F(5); // Calls double overload
  }
 private:
  void F(double) { }
};

private void Foo::F(int) { }

As I'm trying to word it in the proposal, the call to F would resolve to the double overload because F(int) is not yet declared at that point. Though if Foo were a templated class and instantiated after F(int) is available, F(int) would participate in overload resolution. I don't quite understand why you refer to this as ODR violations ?

Regards,
André

 

Currently there are already possible ODR violations for calls outside the class, if a different (e.g. free) function is called.

 

Internal linkage, which should protect the class encapsulation could give the wrong picture about those private extension functions. Shifting the image from unique and declared upfront per class to declared per TU and not only private in the class, but also exclusive to the TU.

 

The mental picture should still be that all private functions are clearly separate from each other (even over several TUs). And if they have the same name/signature, then they should not be called by any of the functions defined in a header file: templates, functions defined in the declaration and inlined functions.