C++ oop in a nutshell

MazonnaCara89@lemmy.ml to Programmer Humor@programming.dev – 616 points –
19

"Oh, so we're actually not friends" Walks away, as she should

Ohhh gottem!

She is now legally obligated to sex this man.

edit: programmers code

Normies hate this trick!

What's the point of having friends when the whole point of private fields is to ensure that you don't break other parts when changing those?

It’s just another option, don’t gotta use it. Maybe you find yourself needing something like this, and the only other choice is making it public. At least with friend classes, you know which classes are friends so you can go look for any dependencies

It’s just another option, don’t gotta use it

It's not a choice of mine when I'm trying to read through / modify some legacy code base

Meh, that already comes with infinite problems, so what's one more?

There's infinite ways to organize code. In C# or Rust where this isn't an option, you might use nested classes or traits hidden behind a module/namespace.

Good use cases are data structures with associated helper classes. For example, a collection/tree and an iterator/tree-walker for working with elements of the collection. Or for something like a smart memory allocator (an arena or slab allocator), you might use a friend-class to wrap elements returned from the allocator, representing their connection back to it (for freeing up when done or to manage the allocation structure in ie a heap or sorted tree).

Does C++ actually have something like that? That sounds like something made up for the joke?

Huh, do Java and other oop languages have them too and what are some good reasons to use them?

It allows for more fine grained access control and to implement afterthoughts.

Think having some private function that can break things if called improperly, but also allow you to avoid significant overhead when calling it the correct way. For example you could be avoiding input validation in a public wrapper for that function. If your friendly class already does it, or cannot produce invalid inputs, there is no need for that.

You could also implement logging after the fact, because your friendly logger object to read private members.

Arguably it's a questionable design decision tho, as you could do all of this in other ways and it basically breaks any guarantees private would usually give you.

That was a problem I saw with it but I guess it's useful too. I like structs.