8 ms·

One thing I've noticed about a lot of these "strict C" developers is that quite often they actually refuse to learn C++. One of the most common complaints of C

• 01100011 4mo ago
  A lot of us are too busy solving problems. Learning about the latest language features, which we often won't be able to use anyway due to the trouble of moving a large dev environment to a newer standard, feels like academic masturbation. C++ folks are very much into their language, and can't seem to understand that most folks don't want to dedicate significant amounts of mental resources purely to language details.
  • pjmlp 4mo ago
    Like implementing the compilers used by C devs.
    • uecker 4mo ago
      GCC was implemented in C and there are plenty of other C compilers written in C. GCC has been converted to C++ at some point, but large parts are still essentially C and I do not think the change to C++ was actually helpful (but others may disagree). In any case, the idea that one needs C++ to have C compilers is certainly simply wrong.
      • delta_p_delta_x 4mo ago
        Clang/LLVM with its more permissive licence sees _much_ wider use and is written purely in C++. PlayStation, automotive, platforms and runtimes like Chromium/V8, Android, etc. are all built with Clang.
        • uecker 4mo ago
          How is this relevant? (also wider use for C I would doubt)
        • lelanthran 4mo ago
          Clang usage is a fraction of GCC usage. Regards, an embedded dev.
          • pjmlp 4mo ago
            A decade ago surely, in 2026 I doubt it. With Android, iDevices, PlayStation, Switch, and everyone that had proprietary compilers down using downstream forks from clang, due to the more appealing license. Who is left still using GCC, other than existing projects lacking a clang backend for a snowflake embed CPU? In any case, if it is a modern GCC release past 2012, it was compiled with C++ as well.
            • uecker 4mo ago
              The license is indeed the big reason for many proprietary forks (not so much that llvm is written in C++). This is not a good thing though.
      • pjmlp 4mo ago
        Naturally GCC was originally written in C, given its age, and the original GNU coding standards document. With time, the GCC developers acknowledged the benefits of using C++ over C, and migrated the code. GCC requires a C++ compiler to bootstrap since around 2012, and GNU coding standards has been updated to several languages beyond C, time to go up with times.
        • uecker 4mo ago
          I think the fallacy of this argument is obvious.
          • pjmlp 4mo ago
            Not really, given that GCC no longer compiles with a pure C compiler. Unless of course, you don't have anything to do, and feel like bootstraping GCC 16, using a compiler chain all the way back to 2012 thereabouts.
            • uecker 4mo ago
              The question is whether GCC is a good example of the benefits of C++ for compilers. Considering the code looks to 95% like C code and uses data structures that we originally implemented in C, I don't see this argument.
              • jstimpfle 4mo ago
                I told him the same thing multiple times, just open a random code location in GCC, or a recently committed change, and see that it's basically C. But he keeps repeating that ridiculous argument like a broken record.
      • WalterBright 4mo ago
        My original C compiler was implemented in C and then bootstrapped. Zortech C++ was implemented in Zortech C, and then bootstrapped. D was implemented in "C with Classes" and then translated to D and bootstrapped. There isn't a line of C code in it. Over time, we gradually replace the C-isms and C++isms and anachronisms in it to native D-isms.
  • bluGill 4mo ago
    Moving to new C++ is a non event, change the compiler / flags and done. Using the new features requires some learning but not a big deal since you can figure out what you need from a summary and learn what is useful for your problem. The problems of the code I'm writing far exceeds the complexity of the language. Your complaint about complexity fall flat to me, unless you are working on a trivial program you need to deal with things far more complex than any language.
    • 01100011 4mo ago
      It's really not. For us, changing compiler versions has noticeable effects throughout our codebase. I'm glad you don't have to deal with that though.
• IncreasePosts 4mo ago
  If we accept the maximum that "any sufficiently advanced technology is indistinguishable from magic", then c++ is indeed magic. It's so advanced that one of the worlds foremost experts in the language(herb sutter) has determined that the language is too complex and we need a whole new language(confront) which is simpler and can be converted to c++.
  • rfgplk 4mo ago
    C++ is actually obscenely complex, I don't deny that. Just mastering object lifetime rules is crazy difficult due to all the edge cases, but it comes with the territory.
    • tialaramex 4mo ago
      > it comes with the territory In the sense that C++ is complicated because it's C++, which is complicated? That's just a tautology. If you mean "the territory" in some other sense there's no reason to believe this.
• lelele 4mo ago
  > y'know you can check if an operator has been overloaded And there lies the problem with C++: to be sure, you have to check. C++ code can't be taken at face value -- the most innocuous-looking code could be a ticking bomb.
  • LoganDark 4mo ago
    > C++ code can't be taken at face value -- the most innocuous-looking code could be a ticking bomb. You can't take C code at face value either. The name of a method or type doesn't tell you what it does. It could longjmp for all you know.
    • lelele 4mo ago
      See my reply to a similar objection: https://news.ycombinator.com/item?id=48520416 https://news.ycombinator.com/item?id=48520416
  • rfgplk 4mo ago
    But isn't this a problem with all code? Looking at a Rust function signature how can you be sure that it does what it says it does? Or python?
    • lelele 4mo ago
      See my reply to a similar objection: https://news.ycombinator.com/item?id=48520416 https://news.ycombinator.com/item?id=48520416
    • dwattttt 4mo ago
      To the extent that one doesn't try to suppress compiler warnings & errors / actively break the language, you get what the compiler confirms is true about a function signature. For Python, it's very little (nothing?). For Rust, you get more than most; lifetimes tell you whether it holds onto a pointer you give it.
  • pjmlp 4mo ago
    Just like any C function without looking into the translation unit, don't say you blindly believe on the function name.
• jstimpfle 4mo ago
  Trust me, I know more C++ than most or all of my peers (working two jobs simultaneously), and I know a million ways that C++ features suck. Also standard library and containers. If you want I'll point out the ways in which std::deque, and even std::map, std::unordered_map, even std::vector (!) suck. IMO, just don't do it.
  • rfgplk 4mo ago
    The standard library implements really do suck (in some cases), but this should be separated from C++ (the language). Even the standard splits the language grammar from the standard library cleanly.
    • wavemode 4mo ago
      You can't really separate the two, firstly because some parts of the standard library interact directly with the language's syntax (e.g. <initializer_list>), and secondly because the language standard dictates things about the behavior of the standard library that limit implementation options. For example, the standard says that adding elements to an <unordered_map> is not allowed to invalidate references to keys or elements within the map. That makes it impossible for any standards-compliant C++ implementation to use a high-performance implementation in which keys and elements are stored contiguously in a flat array.
      • gpderetta 4mo ago
        Which sucks... unless you really need reference stability.
        • jstimpfle 4mo ago
          std::vector has left the chat.
      • nly 4mo ago
        Your map example only concerns the standard library, not the language.
• deleted 4mo ago
  [deleted]
• flohofwoe 4mo ago
  > Malloc and memory allocation methods are at least 10k+ lines of code for instance. Only the really big ones, e.g. here is Emscripten's allocator that focuses on small binary size and is implemented in about 1.5 kloc (ignoring comments and whitespace it's actually under 1 kloc), and that allocator is perfectly fine for most use cases (especially C code bases which typically don't have a high allocation frequency): https://github.com/emscripten-core/emscripten/blob/main/system/lib/emmalloc.c https://github.com/emscripten-core/emscripten/blob/main/syst... ...and Seb Aaltonen's offset allocator (used for allocating GPU buffers in his Vulkan API wrapper) has under 500 lines of code: https://github.com/sebbbi/OffsetAllocator/blob/main/offsetAllocator.cpp https://github.com/sebbbi/OffsetAllocator/blob/main/offsetAl... Right tool for the job etc... big general-purpose allocators like jemalloc or mimalloc are usually a bandaid to somewhat salvage a failed memory management strategy.
• Chaosvex 4mo ago
  [dead]
• EPWN3D 4mo ago
  C programmers aren't complaining about the "magic" being tens of thousands of lines of code. They're complaining about the magic including bizarre side effects that brazenly violate the principle of least astonishment. In C++, you can overload the comma operator to do shit. I've seen it done. There's no reason to do it, and no reasonable person would ever expect it in a code base they're unfamiliar with. To find bug in that ultimately roots back to that implementation, you have to go eliminate every other whack-job possibility before it even occurs to you that maybe the weirdo who wrote this code chose to overload the comma operator. I'm not going to argue with anyone who wants to use C++ in their own projects, you do you. But let's be real about what C programmers are complaining about. It's not line count. It's syntactic obfuscation. I don't just level this criticism at C++ either. Basically every major new language has its own byzantine syntactic constructs to some degree.
• uecker 4mo ago
  I was programming in C++ before switching to C and I would say that C++ adds a huge amount of mental load compared to C. I think one can understand how much of a relieve it is to not worry about everything C++ does only after not using C++ for a quite a while.
  • PaulDavisThe1st 4mo ago
    Any time I go back to C from C++, it's only comfortable if I've got a C utility library that replaces most of std:: And that utility library (there are dozens of them) is just as subject to debate and issues as libstdc++ I am not going to implement my own C versions of 90% of the stuff std:: provides, sorry.
    • uecker 4mo ago
      There is a difference between "needing a library" and "implement my own". One can just pick one. And even when implementing things yourself, one has to do this just once.
• fasterik 4mo ago
  I don't think "refusing to learn C++" is the right way to frame it. I want to use the language features that are actually useful to me, without being forced into a specific programming style. I can't speak for every "orthodox C++" programmer, but for me that means using exclusively plain-old-data structs, non-member functions, and "dumb" pointers. I have no issue with learning to use a C++ feature when it's directly useful to a problem I'm trying to solve. As one example, I recently found templated lambdas useful in making animations. https://www.youtube.com/watch?v=cw-h0dePYZM https://www.youtube.com/watch?v=cw-h0dePYZM
  • rramadass 4mo ago
    Right. Use/Choose those features you are most knowledgeable/comfortable with. That is why C++ has such a smorgasbord of features and supports multiple paradigms. Over time, as one learns "better ways" (for a certain definition and one is convinced of it) of doing something change/modify as needed. That is all there is to it.
• nuc1e0n 4mo ago
  c memory allocation functions can be implemented in 1000 lines or so. I've done it myself. Maybe more are needed to handle strange operating systems or architectures, as glib does.
• lelanthran 4mo ago
  All the foot guns in C are still in C++, and C++ adds a significant multiple more.
  • ReactiveJelly 4mo ago
    The regular table saw is still in the new workshop, and the new workshop adds a SawStop and another regular table saw.
  • fluoridation 4mo ago
    Literally untrue. Two words: stronger typing.
    • flohofwoe 4mo ago
      Memory corruption magnets like iterator invalidation, std::string_view or std::span are on a whole different level than the footguns that were inherited from C. At least with C style raw pointers you know that you have to be careful when you see one, in C++ the unsafety is lurking in hidden places sprinkled all over the stdlib and comes in all shapes and forms.
• amomchilov 4mo ago
  “It’s so much magic! Now if you’ll excuse me, I have to go use my generic container library rewritten in 50 layers of preprocessor macros.”