• onlinepersona@programming.dev
    link
    fedilink
    English
    arrow-up
    31
    arrow-down
    1
    ·
    20 days ago

    cpp and their operator overloads are also insane. It makes understanding cpp code impossible. A “+” could actually do something completely different or have insane side-effects. Truly superior language for spreading confusion.

    • red_tomato@lemmy.world
      link
      fedilink
      arrow-up
      22
      arrow-down
      1
      ·
      20 days ago

      Operator overloads is something that sounds like a good idea until you experience them firsthand. Just properly name your functions for fuck’s sake.

      • balsoft@lemmy.ml
        link
        fedilink
        arrow-up
        8
        ·
        20 days ago

        Operator overloading is awesome in a functional language. Haskell allows for a lot of creative stuff with operators, but since they can’t have side effects, must conform to predictable types, and have specific requirements they are somewhat understandable. Idris is also very ergonomic when it comes to operators.

        C++ allowing a library to override the + operator with system("rm -rf /") is a lot less awesome.

      • Chrobin@discuss.tchncs.de
        link
        fedilink
        arrow-up
        4
        ·
        20 days ago

        As a computational physicist, I appreciate operator overloading IF used properly.
        Example of a good use: + for matrix addition
        Example of a bad use: left shift operator << as a pipe
        I still don’t understand who’s in the C++ committee that they would choose this garbage over a function

      • unknownuserunknownlocation@kbin.earth
        link
        fedilink
        arrow-up
        5
        arrow-down
        1
        ·
        20 days ago

        Honestly, I’m glad to have them, it can make a number of things simpler. For instance, a program I wrote had a number of duration fields that had to be stored in XML files and updated every once in a while. It was something that had to occur very often in the code: add a value to the duration, set that value in the XML data, and save the XML file. So I created a class that stored the date/time value and a pointer the XML element (it could be assumed that nothing else would be changing the value in the XML file and if it did, then that change should be overwritten) and overloaded the += operator (among others), so then all I needed was to create the DurationField object, and then I could go durationFieldX += time2 - time1 for instance. I could abstract all the logic away and make it very clear and easy to write. Could I have made it so that I have to to durationFieldX.add(time2 - time1)? Of course I could have. But IMO that variant is less neat and less readable.

        • MangoCats@feddit.it
          link
          fedilink
          arrow-up
          4
          ·
          20 days ago

          I’ll jump on your unpopular side. With a decent IDE you should be able to point/click and decode what any operator is doing in any context. If I have two vectors, or quaternions, and I want to operate on them, why should I be forced to pass them to a standard function instead of clearly seeing what I’m doing. If you can’t be bothered to know the types of your variables in a strongly typed language… IDK.

    • Valmond@lemmy.dbzer0.com
      link
      fedilink
      arrow-up
      9
      arrow-down
      2
      ·
      20 days ago

      Yeah it’s like a knife, wildly superior to cut stuff up in the kitchen, but you can also like stick it in your eye (but why?).

    • boonhet@lemmy.zip
      link
      fedilink
      arrow-up
      6
      ·
      20 days ago

      Omg I have the best idea but I’m not writing any C++ so someone else will have to do it.

      Overload + to work as - in either some super rare condition or randomly with a very low chance

      Ship it

  • DrakeAlbrecht@lemmy.world
    link
    fedilink
    English
    arrow-up
    15
    ·
    20 days ago

    I have honestly never seen parentheses called “round brackets” before. It totally makes sense, I have no idea why it’s not used more often.

  • calcopiritus@lemmy.world
    link
    fedilink
    arrow-up
    15
    ·
    20 days ago

    Funny that you put rust as the “uses parenthesis for function calls”. When in rust you can use any bracket for macro invocations:

    let v1 = vec!(1,2,3);
    let v2 = vec![1,2,3];
    let v3 = vec!{1,2,3};
    

    These are valid and have the exact same meaning.

    • Flipper@feddit.org
      link
      fedilink
      English
      arrow-up
      5
      ·
      20 days ago

      To be fair, with Rust macros anything goes. There was an example where someone demoed descriping rust structs and enums nested as xml with a macro to parse it.

      • calcopiritus@lemmy.world
        link
        fedilink
        arrow-up
        3
        ·
        20 days ago

        That’s inside the macro though. Whatever you parse inside the macro is defined by the creator of the macro. The macro invocation itself is defined by the rust language.

        Rust allows you to use any bracket because it doesn’t know what the macro is supposed to do.

        Some macros work like functions:

        println!("Hello world");
        

        Some macros work like array declarations:

        let v = vec![1,2,3];
        

        And some macros work like a code scope:

        select!{
         a => myfunc(),
         b => my_other_func()
        }
        

        Since rust doesn’t know what your macro does, it just lets the user choose whatever the user sees more fitting for that specific macro invocation.

      • Ephera@lemmy.ml
        link
        fedilink
        arrow-up
        1
        ·
        20 days ago

        I always enjoy this one: https://crates.io/crates/inline-python

        Apparently, Python’s syntax is almost entirely a subset of Rust’s syntax + a few keywords, so even though you have to pass valid Rust tokens into a macro, that’s good enough to write Python with just a few quirks.

    • ExperimentalGuy@programming.dev
      link
      fedilink
      arrow-up
      2
      ·
      20 days ago

      That’s always funny to me. In a language that’s so particular about different syntax features, they let macros of all things have a little bit of arbitrariness.

  • Gladaed@feddit.org
    link
    fedilink
    English
    arrow-up
    12
    ·
    20 days ago

    Only one of those is a function, get it right. () Call functions <> Specialize Templates, can be used to do compile time calls to things that behave like functions. [] Accesses elements {} Calls constructors, aka functions that do the initial setup.

    Overloading these to do something else gets you in the naughty corner.

    Edit: the implementation of the {} fuckery is no great. Just save the sum instead of all numbers.

    • Kwdg@discuss.tchncs.deOP
      link
      fedilink
      arrow-up
      5
      ·
      20 days ago

      Good point regarding the {} implementation.

      I disagree slightly regarding your point that these aren’t function calls. Yes technically they are different things but effectively they are functions, I cann pass arguments and get a result based on some operations.

      Of course not all of these can do anything but only the constexpr value is actually pretty limited. The other ones are straight up functions

  • trxxruraxvr@lemmy.world
    link
    fedilink
    arrow-up
    8
    ·
    20 days ago

    I haven’t kept up to date with C++ development in the last 16 years, I only recognize the first two of those four.

    • Kwdg@discuss.tchncs.deOP
      link
      fedilink
      arrow-up
      7
      ·
      20 days ago

      You can overload the indexing operazor “[]” (std::vector does this for example), and since c++23 this operator can have more than one argument.

      The last one is a constructor call with an overloaded conversion operator. The {} syntax is possible since c++11 I think. The conversion operator was already available before that

      • xthexder@l.sw0.com
        link
        fedilink
        arrow-up
        1
        ·
        20 days ago

        Ah, that’s why… I didn’t think multiple arguments to operator[] was valid, but my brain is still catching up to C++20 features.

  • NeatNit@discuss.tchncs.de
    link
    fedilink
    arrow-up
    8
    ·
    20 days ago

    Good meme, but I’m really not sure why you wrapped everything in asserts which kind of ruins the aesthetics. IMO would have worked better as e.g.:

    x = sum(1, 2, 3); // x = 6
    
      • NeatNit@discuss.tchncs.de
        link
        fedilink
        arrow-up
        4
        ·
        20 days ago

        In example code, yes, but in this meme specifically which is all about function call syntax, it ruins the point. E.g. every line in the C++ snippet includes parentheses.

  • palordrolap@fedia.io
    link
    fedilink
    arrow-up
    2
    ·
    20 days ago

    You can do most if not all of this in Perl if you’re twisted enough. Some hoop jumping may be required*, but I can think of ways to do something that looks like each of these.

    *: The braces are especially tricky if warnings are turned on. I’d probably abuse the deprecated multidimensional syntax and tie a hash to the actual function.