this post was submitted on 29 Dec 2024

342 points (98.9% liked)

Programmer Humor

22349 readers

2642 users here now

Welcome to Programmer Humor!

This is a place where you can post jokes, memes, humor, etc. related to programming!

For sharing awful code theres also Programming Horror.

Rules

Keep content in english
No advertisements
Posts must be related to programming or programmer topics

founded 2 years ago

MODERATORS

Feyter@programming.dev

anzo@programming.dev

BurningTurtle@programming.dev

pylapp@programming.dev

342

I love new features (lemmy.zip)

submitted 3 months ago by Maven@lemmy.zip to c/programmer_humor@programming.dev

40 comments fedilink hide all child comments

top 40 comments

sorted by: hot top controversial new old

[–] Swedneck@discuss.tchncs.de 94 points 3 months ago (2 children)

the :================D operator

[–] sunoc 21 points 3 months ago

Ebin :D

[–] ZILtoid1991@lemmy.world 7 points 3 months ago

New language idea:

:====D
:==========D 0
:=======0==D~~~
:==========D ~0

[–] Flipper@feddit.org 87 points 3 months ago

I'm not sure if this is serious or not and that scares me.

[–] Blackmist@feddit.uk 20 points 3 months ago (3 children)

I honestly don't know why they even have -> instead of just a dot like everyone else. The compiler knows whether it's a record, object, pointer, or any level of pointer to pointers.

Why make the programmer do the donkey work?

[–] Morphit@feddit.uk 12 points 3 months ago

It's important for objects that can be dereferenced. Smart pointers have methods that can be accessed with dot syntax like swap(). You can still dereference through a smart pointer using arrow syntax to access methods on the referenced type since they overload the operator->() method.

[–] gencha@lemm.ee 6 points 3 months ago

Operator overloading allows you to redefine what each operator does. It's essential to achieve a truly fucked up code base

[–] skulbuny 2 points 3 months ago

I love the arrow in functional programming. Some functional languages (like reasonml) has multiple arrow operators that did different things like this one -> would put the argument in the first position (a popular JS pattern) and the big arrow |> would put it last like most functional languages.

I know this is about CPP but honestly I love the way it looks, but I'm a weirdo lol

[–] mariusafa@lemmy.sdf.org 19 points 3 months ago (1 children)

C++26: remove C++

[–] WhyJiffie 5 points 3 months ago (1 children)

C++26: The Rust Book

[–] mariusafa@lemmy.sdf.org 1 points 3 months ago

I really hope so but they first need a language specification. Without that it's no use for me.

[–] witx@lemmy.sdf.org 15 points 3 months ago

Please don't give them ideas

[–] merthyr1831@lemmy.ml 15 points 3 months ago (1 children)

I pray for this to be real because it's the perfect syntactic sugar for C++. The kind that you'd think makes sense if you didn't have to write C++ for anything more complex than a high school project.

[–] mindbleach 5 points 3 months ago

Right? Every C++ feature needs to be lightly cursed.

[–] HauntingScience@programming.dev 12 points 3 months ago

TIHI

[–] state_electrician@discuss.tchncs.de 8 points 3 months ago

C++ is a joke.

[–] deadbeef79000@lemmy.nz 3 points 3 months ago

Violates the Law of Demeter

[+] bleistift2@sopuli.xyz -8 points 3 months ago (7 children)

Why do you even have pointers to pointers?

[–] gratux@lemmy.blahaj.zone 45 points 3 months ago (1 children)

many reasons, for example

multidimensional arrays
arrays of function pointers
pass by reference of a pointer

[–] xmunk 6 points 3 months ago* (last edited 3 months ago) (1 children)

In two of your cases this operator is pretty shit because at some point you'll probably want to offset the access (this isn't a knock at you but at the feature).

This operator would only really be relevant to the last case which rarely comes up outside of infrastructure/library work (building a tool building tool) and usually those code bases are cautious to adopt new features too quickly anyways for portability.

I've done serious C++ work (not much in the past decade though) - while references are absolutely amazing and you essentially want to pass by const ref by default I think well written maintainable C++ should maybe have a dozen heap objects tops. C++ is a better language if you generally forget that pointers and bare arrays exist.

Just again - I think you're right and the fact that your list is only three things long (and arguably two of them would be misuses) is a pretty clear sign that this is an incredibly niche feature.

[–] sukhmel@programming.dev 17 points 3 months ago* (last edited 3 months ago) (1 children)

I don't think this operator is a real feature, tbh 😅

[–] marcos@lemmy.world 6 points 3 months ago

The fact that he claims it's in C++ 29, while we are in 2024 is a good hint.

Or maybe he is a time traveler. Quick, go ask the next lottery numbers!

[–] Lightfire228@pawb.social 20 points 3 months ago* (last edited 3 months ago) (1 children)

Mostly because at the lowest level of computing (machine code and CPU instructions), pointers are the only method (that I know of) of any kind of indirection.

At the lowest level, there are 2 types of references:

CPU registers
memory addresses (pointers)

Every higher level language feature for memory management (references, objects, safe pointers, garbage collection, etc) is just an abstraction over raw pointers

Pointers themselves are really just abstractions over raw integers, whose sole purpose is to index into RAM

With that in mind, pointers to pointers are a natural consequence of any kind of nested object hierarchy (linked lists, trees, objects with references to other objects, etc)

The only other kind of indirection would be self-modifying machine code (like a Wheeler Jump). But the computing world at large has nixed that idea for a multitude of reasons

[+] bleistift2@sopuli.xyz -6 points 3 months ago (1 children)

linked lists, trees, objects with references to other objects

That’s not a pointer to another pointer, but a pointer to a data structure that happens to contain another pointer.

[–] Lightfire228@pawb.social 15 points 3 months ago* (last edited 3 months ago) (2 children)

The distinction is meaningless in the land of Opcode's and memory addresses

For example, a struct is just an imaginary "overlay" on top of a contiguous section of memory

Say you have a struct

struct Thing {
  int a;
  int b;
  Thing* child;
}

Thing foo {}

You could easily get a reference to foo->child->b by doing pointer arithmetic

*((*((*foo) + size(int)*2)) +size(int))

(I've not used C much so I've probably got the syntax wrong)

[–] bleistift2@sopuli.xyz 1 points 3 months ago (1 children)

Yes, you can do crazy shit if you try hard enough, but every reasonable programmer would access foo->child->b als foo->child->b and not via that crazy LISPy expression.

By question was: Why would you have a pointer to a memory address that itself only holds a pointer somewhere else?

So far the only reasonable explanation is from @Victoria@lemmy.blahaj.zone:

arrays of function pointers

pass by reference of a pointer

[–] Lightfire228@pawb.social 1 points 3 months ago

I'm more talking about theory than practical.

I've not developed anything in C/C++, so I don't know practical uses for a double pointer, aside from multidimensional arrays, or arrays of pointers

My point was that, conceptually, pointers to pointers is how most complex data structures work. Even if the C representation of said code doesn't have a int** somewhere

[–] bane_killgrind@slrpnk.net 1 points 3 months ago

Magic.

Blasphemy.

[–] Gladaed@feddit.org 17 points 3 months ago* (last edited 3 months ago) (1 children)

Because stuff can own other stuff and be owned at the same time. Also, arcane jackarsery.

Edit: if you want to give a function a pointer that it may change this may occur in a constructive way. I.e. replace an owned object.

[–] marcos@lemmy.world 5 points 3 months ago (1 children)

Yeah... But it's usually a good practice to put a struct somewhere between your 30 levels of ownership.

Exceptions exist, but they are not very common. Also, in C++, operators overloading may help you if you keep needing to write code like this.

[–] Gladaed@feddit.org 3 points 3 months ago (1 children)

In C++ you should never have owning raw pointers. Unless you have a good reason™.

Raw pointers are great, but not for ownership.

[–] qaz@lemmy.world 6 points 3 months ago* (last edited 3 months ago) (1 children)

I just use unique_ptr 99% of the time

[–] Gladaed@feddit.org 4 points 3 months ago

And you should.

It even works for classes whose constructors your implementation cannot see, if you aren't a bitch about it.

[–] BradleyUffner@lemmy.world 15 points 3 months ago

Pointers just point to memory addresses, and because pointers are stored in memory addresses, it just kind of naturally falls out that way.

[–] fibojoly 12 points 3 months ago

Pointer to pointer is fairly common stuff once you get serious with C++ but I've no idea what this abomination is supposed to even be, haha!

[–] Klnsfw@lemmynsfw.com 4 points 3 months ago

Because int main(int argc, char** argv)

[–] mindbleach 3 points 3 months ago (1 children)

Because pointers are real.

[–] bleistift2@sopuli.xyz 1 points 3 months ago (1 children)

That’s the best thing I’ve read in a while, and I’m only on page 2!

[–] mindbleach 2 points 3 months ago (1 children)

James Mickens does good work.

[–] bleistift2@sopuli.xyz 2 points 3 months ago

If the Mossad wants your data, they’re going to use a drone to replace your cellphone with a piece of uranium that’s shaped like a cellphone

That reads differently after 2024.