this post was submitted on 08 Jun 2024
1060 points (98.5% liked)
Programmer Humor
19623 readers
1 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 1 year ago
MODERATORS
you are viewing a single comment's thread
view the rest of the comments
view the rest of the comments
This graph cuts off early. Once you learn that pointers are a trap for noobs that you should avoid outside really specific circumstances the line crosses zero and goes back into normal land.
C++ is unironically my favorite language, especially coding in python feels so ambiguous and you need to take care of so many special cases that just wouldn't even exist in C++.
But can you read someone else's C++ code?
Why should I do that?
Typically, I can read an "average" open source programmers code. One of the issues I have with C++ is the standard library source seems to be completely incomprehensible.
I recently started learning rust, and the idea of being able to look at the standard library source to understand something without having to travel through 10 layers of abstraction was incredible to me.
AAAAAAhhh I once read a Stroustrup quote essentially going "if you understand vectors you understand C++", thought about that for a second, coming to the conclusion "surely he didn't mean using them, but implementing them", then had a quick google, people said llvm's libc++ was clean, had a look, and noped out of that abomination instantly. For comparison, Rust's vectors. About the same LOC, yes, but the Rust is like 80% docs and comments.
I think some of those abominational constructs were for compile-time errors. Inline visibility macro is for reducing bynary size, allowing additional optimizations and improving performance and load time.
In my projects I set default visibility to hidden.
I wonder what went into their minds when they decided on coding conventions for C++ standard library. Like, what’s up with that weird ass indentation scheme?
You can absolutely read my code. The ability (similar to functional languages) to override operators like crazy can create extremely expressive code - making everything an operator is another noob trap... but using the feature sparingly is extremely powerful.
Your graph also cuts out early. Eventually you want to get performance gains with multi-threading and concurrency, and then the line drops all the way into hell.
Good Afternoon Sir, have you heard about our lord and savior pthreads?
I'm not saying you can't do multi-threading or concurrency in C++. The problem is that it's far too easy to get data races or deadlocks by making subtle syntactical mistakes that the compiler doesn't catch. pthreads does nothing to help with that.
If you don't need to share any data across threads then sure, everything is easy, but I've never seen such a simple use case in my entire professional career.
All these people talking about "C++ is easy, just don't use pointers!" must be writing the easiest applications of all time and also producing code that's so inefficient they'd probably get performance gains by switching to Python.
That's the problem of most general-use languages out there, including "safe" ones like Java or Go. They all require manual synchronization for shared mutable state.
There's a difference between "You have to decide when to synchronize your state" and "If you make any very small mistake that appears to be perfectly fine in the absence of extremely rigorous scrutiny then this code block will cause a crash or some other incomprehensible undefined behavior 1/10000 times that it gets run, leaving you with no indication of what went wrong or where the problem is."
Damn, this goes hard for no reason.
Well, threadsanitizer catches them in runtime. Not sure about GCC static analyser and other SA tools.
I use thread sanitizer and address sanitizer in my CI, and they have certainly helped in some cases, but they don't catch everything. In fact it's the cases that they miss which are by far the most subtle instances of undefined behavior of all.
They also slow down execution so severely that I can't use them when trying to recreate issues that occur in production.
They caught lock inversion, that helped to fix obscure hangs, that I couldn't reproduce on my machine, but were constantly happening on machine with more cores.
Wasn't biggest part of pthreads added in C11/C++11?
So... I'm old. All my time working in C++ was pre-C++11
I've been using C++ almost daily for the past 7 years and I haven't found a use for shared_ptr, unique_ptr, etc. At what point does one stop being a noob?
Given that you probably are using pointers, and occasionally you are allocating memory, smart pointers handle deallocation for you. And yes, you can do it yourself but it is prone to errors and maybe sometimes you forget a case and memory doesn't get deallocated and suddenly there is a leak in the program.
When you're there, shared_ptr is used when you want to store the pointer in multiple locations, unique_ptr when you only want to have one instance of the pointer (you can move it around though).
Smart pointers are really really nice, I do recommend getting used to them (and all other features from c++11 forward).
You’re recommending him to give up his sanity and/or life?
I would have said the same thing a few years ago, but after writing C++ professionally for a while I have to grudgingly admit that most of the new features are very useful for writing simpler code.
A few are still infuriating though, and I still consider the language an abomination. It has too many awful legacy problems that can never be fixed.
This guy probably still uses a char*.
What have you been using it daily for? arduino development? I’m hoping no company still lives in pre C++17 middle ages.
My company still uses c90. I just want to
for(uint8 i = 0;;)🥹C99 is better. Always will be.
Fight me.
C11 atomics
well, if I have an object on the heap and I want a lot of things to use it at the same time, a shared_ptr is the first thing I reach for. If I have an object on the heap and I want to enforce that no one else but the current scope can use it, I always reach for a unique_ptr. Of course, I know you know all of this, you have used it almost daily for 7 years.
In my vision, I could use a raw pointer, but I would have to worry about the lifetime of every object that uses it and make sure that it is safe. I would rather be safe that those bugs probably won't happen, and focus my thinking time on fixing other bugs. Not to mention that when using raw pointers the code might get more confusing, when I rather explicitly specify what I want the object lifetime to be just by using a smart pointer.
Of course, I don't really care how you code your stuff, if you are comfortable in it. Though I am interested in your point of view in this. I don't think I've come across many people that actually prefer using raw pointer on modern C++.
I just never learned smart pointers and write C++ code like it's C for aesthetic reasons.
Best to join a C++ community on some social media then. They'll tell you immediately why "C with classes" isn't C++.
I recognize that trick question. For C++, the answer is always "soon".
Shared poibters are used while multithreading, imagine that you have a process controller that starts and manages several threads which then run their own processes.
Some workflows might demand that an object is instantiated from the controller and then shared with one or several processes, or one of the processes might create the object and then send it back via callback, which then might get sent to several other processes.
If you do this with a race pointer, you might end in in a race condition of when to free that pointer and you will end up creating some sort of controller or wrapper around the pointer to manage which process is us8ng the object and when is time to free it. That's a shared pointer, they made the wrapper for you. It manages an internal counter for every instance of the pointer and when that instance goes out of scope the counter goes down, when it reaches zero it gets deleted.
A unique pointer is for when, for whatever reason, you want processes to have exclusive access to the object. You might be interested in having the security that only a single process is interacting with the object because it doesn't process well being manipulated from several processes at once. With a raw pointer you would need to code a wrapper that ensures ownership of the pointer and ways to transfer it so that you know which process has access to it at every moment.
In the example project I mentioned we used both shared and unique pointers, and that was in the first year of the job where I worked with c++. How was your job for you not to see the point of smart pointers after 7 years? All single threaded programs? Maybe you use some framework that makes the abstractions for you like Qt?
I hope these examples and explanations helped you see valid use cases.
When you bring threads into it, these exotic features make more sense. I have been doing single-threaded stuff for the most part.
Do you still use raw pointers? You know they've discovered fire? (Jk coming from C I too havent learnt how to use smart pointers yet)
Smart pointers are like pointers, but without the same burden of having to worry about memory leaks.
First year programming in the late 90s .. segmentation fault? I put printfs everywhere. Heh. You'd still get faults before the prints happened, such a pain to debug while learning. Though we weren't really taught your point of the comment at the time.
Least that was my experience on an AIX system not sure if that was general or not, the crash before a print I mean.
Yea, pointer arithmetic is cute but at this point the compiler can do it better - just type everything correctly and use
[]... and, whenever possible, pass by reference!Faust bless Stallman for creating GDB.
pointers are fine, but when you learn about the preprocessor and templates and 75% of the STL it goes negative again
c++ templates are such a busted implementation of generics that if I didn't have context I'd assume they were bad on purpose like malbolge
Pointers are great for optional references.
But I need pointers for almost everything