Use a friend function.   -----Ursprüngliche Nachricht----- Von:Frederick Virchanza Gotham via Std-Proposals <std-proposals_at_[hidden]> Gesendet:Fr 01.09.2023 23:28 Betreff:[std-proposals] Real World Programming, private = public An:std-proposals <std-proposals_at_[hidden]>; CC:Frederick Virchanza Gotham <cauldwell.thomas_at_[hidden]>; This past week I've been talking about C++ as a real-world programming language where we sometimes have to improvise and do a repair job, and so I suggested marking a function as 'verbose' to tell the compiler to disable all optimisations. All of us who work a 9 to 5 writing code need to improvise once in a while, whether we're compensating for a bug, or avoiding an ABI break, or compensating for somebody else having avoided an ABI break. Today I'm programming an Arduino microcontroller in C++ that's running a webserver over a wifi connection. It's fine for small files... even as big as 64 megabytes. But you can forget about going up near a gigabyte... the transfer will always finish with bytes missing. The problem is that the HTTP server is operating a TCP connection that does not wait for the ACK before sending out another segment, and so sometimes two packets get sent out without an ACK in between. This is leading to data loss. I have access to the header files for the web server, and I can see where the HTTP class contains a handle to the TCP connection, but of course the internals of the HTTP class are all private. I need access to the TCP handle though because I want to make sure that:    count_segments_sent == count_segments_acknowleged before I send out more data. My solution is as follows:    #define private public    #define protected public    #include "WebServer.h" This works fine on my own particular compiler here, but on another compiler it might not work if the names get mangled differently or if the class layout changes. What if we were to standardise this hack? You'd hope we would never have to use it but those of us programming in the real world have to do this stuff once in a while. We would have to standardise it in such a way that it doesn't break SFINAE. So let's say you have a class called 'WebServer', and you want to have access to all of its members, well how about if we could use typedef as follows:    typedef WebServer WebServerFreeForAll : private=public; Then we could use it as follows:    typedef WebServer WebServerFreeForAll : private=public, protected=public; or even:    typedef WebServer WebServerNotSureWhy : public=protected; And so then in our code, let's say we have a function that manipulates a webserver, well we could do:    void Manipulate( WebServer &web )    {        static_cast<WebServerFreeForAll&>(web).some_private_member = 77;    } -- Std-Proposals mailing list Std-Proposals_at_[hidden] https://lists.isocpp.org/mailman/listinfo.cgi/std-proposals