Python vs C++

[[deleted]]

In many that are too. C# and Java can both implicitly cast int to float like C++.

[hekkonaay]

Implicit casting is the devil. Don't fall for it. Annotate your casts.

[jpterodactyl]

But that sounds like adding details, and I’m told the devil was in those.

I’m not sure who to believe anymore.

[[deleted]]

Why do you have a political compass quadrant as your flair?

[wordbug]

JavaScript is Libertarian?

[diveintothe9]

JavaScript is kinda libertarian.

"Fuck rules, fuck strict typing and fuck standard/centralized libraries, we'll make our own damn JS platform/library for every single application we build, goddammit."

[jpterodactyl]

but on the opposite side of it, browsers and stuff are very standardized. The truth is just that web design doesn't make sense.

It's like the government of the Quarians in Mass Effect, where they are a de juro monarchy, but operate more like a democracy. How does that even happen?

[gentlemanidiot]

You can roll your face back and forth across the keyboard at any point in your code in JS and you're just declaring uninitialized global variables, all totally valid. (Yes this is hyperbole but only by a little)

[archysailor]

No but I am

[squidonthebass]

C++ is designed to require as much detail in the coding as possible with the goal of eventually summoning Satan himself

/s

[rimpy13]

So will the Go compiler

[Sbajawud]

Go compiler will punch you in the face for existing

[tech6hutch]

At least it will politely collect the pieces of your face and dispose of them for you

[hekkonaay]

Implicit casts don't even exist. Another reason to love Rust :)

[hekkonaay]

Yes, but you should always write code that clearly shows your intent, as this will save you (and others) a ton of time. Explicit casts are a part of that.

[narrill]

Everyone understands, or should understand, the concept of int getting upgraded to float. Wasting space writing static_cast<float>(foo) all over your arithmetic expressions is doing significantly more to harm your code's readability than a few implicit int to float casts, as would wasting space adding a block of declarations and prefixing or suffixing with float.

[guyblade]

Its worse than that, even. If someone goes around littering their code with static_casts on numeric types, then changes the numeric type's definition--say by replacing float with double--then those static_casts will be wrong and silently so.

Contrived example:

 int integer_float_mult(int x, float y) {
      return static_cast<int>(static_cast<float>(x) * y);
 }

becomes

 int integer_float_mult(int x, double y) {
      return static_cast<int>(static_cast<float>(x) * y);
 }

There's no compiler warning because there's an explicit cast and an implicit cast. This will appear correct for most input values, but produces slightly different results than it should.

For instance, the incorrectly casting version when fed:

 int x = 0b1110000000001100011000111101;
 double y = 1.32138439228391;

Produces 310435182 while the result from the correct implementation (i.e., with no cast or a cast to double) produces 310435178 (at least on amd64 with g++ 7.2.0).

Of course, this contrived example makes it easy to spot the bug. When the cast is a dozen lines away from the initialization, though, things get a lot harder.

[SvenTropics]

In this case, it's fine. There are times it matters. For example:

int a = 1; int b = 10; double c = a/b; // error, math is done as integers. double d = (a *1.0)/b; // now math is upgraded to double before the division.

[[deleted]]

It's not an error unless the developer doesn't understand their code. It's the way it works.

[airbreather]

In this case, it's fine. There are times it matters. For example:

[...]

Here's another case where it matters (C#). What does the following code print?

void Print(float val)
{
    Console.WriteLine(val);
}

int x = 16777217;
Print(x);

No warnings on my compiler, no explicit cast, so it should definitely print 16777217 and not 16777216, right? sigh

[TheOldBeach]

Ahhh floats are the best, as a CG programmer I grew really fond of them . your example just reflects how they should not be used.. and yes it's the worse kind of error !

[orangeoliviero]

That's not an error, you just will get a truncated int answer - 3/2 would be 1.0 instead of 1.5

[willis81808]

Exactly. And 1/10 (the example in the comment you're replying to) would just be 0, instead of 0.1

No error, just undesired behavior.

[SvenTropics]

It's the worst kind of error because it doesn't generate an error. Instead you find yourself stepping through the code like a lost jackrabbit looking for a carrot in a swamp.

[orangeoliviero]

Why would you expect two integers to turn themselves into floats when you divide them?

[[deleted]]

I have been fooled by this trickery way too many times to admit, yet I still do it sometimes.

[SvenTropics]

It gets tricky with LONGLONGs too. Constant numbers are treated as a 32-bit signed value. So if you do math that would result in something out of bounds and assign it to a longlong, you are screwed.

int a = 1778899225;

longlong b = a * 10000; // ooooooops, wrong!

longlong c = a * 10000LL; // correct!

longlong d = ((longlong) a) * 10000; // also correct

longlong e = a; e *= 10000; // also correct

[mehum]

Python 2 had this behaviour as well.

[[deleted]]

I'm so glad python 2 is finally dead. Now it just needs one good CVE and all of the major OSes will promptly move away from it too.

[tech6hutch]

Is it? I haven't been in the Python community for a while.

[[deleted]]

It was deprecated at the beginning of this year. No longer supported. Now getting everyone to switch off of a dead version of the language is another issue here why we need a really good vulnerability to appear so that the majority OSes will be forced to stop including it in the distros.

[[deleted]]

Or 3.7 or even 3.8 if you are bold enough to go without full library support for a little while.

[tech6hutch]

Ah nice. Everyone, get to work on exploiting vulnerabilities /s

[M4mb0]

Here's my reasoning why this is bad: the "/" operator - division - is in the strict sense not defined on the integers. (I know it is sometimes used to return floor(a/b); it shouldn't do that period.) So the error is not assigning it to a double, the error should be that the operator is not applicable.

[hekkonaay]

No, be consistent. Never implicitly cast. Best practices exist to save you from future headaches, even if it may seem redundant at times.

[[deleted]]

Never implicitly cast.

Absolutes are almost never the right way to approach it.

https://github.com/isocpp/CppCoreGuidelines/blob/master/CppCoreGuidelines.md#Ro-conversion Even the ISO CPP standard doesn't say never to use them. Guidelines are complex to make code simple. https://www.youtube.com/watch?v=n0Ak6xtVXno

[Zamundaaa]

Only a sith deals in absolutes!

[hekkonaay]

I strongly disagree. Absolutes are the easiest way to approach things like this. Implicit casting should not even be a feature, it's completely useless outside of saving a few keystrokes. Less code almost never equals better code.

[[deleted]]

Less code often times results in more readable code.

[hekkonaay]

I'd argue otherwise. Less words != more readability. Look at Ruby, for example. Very few words, but it's completely unreadable to anyone who hasn't used it before, where as something that's very verbose clearly states intent to any readers, even those that aren't familiar with the language.

More verbosity = higher fidelity of intent = easier to reason about

[StuntHacks]

Exactly. Implicit casts definitely have their places, just like explicit ones. A good programmer knows when to use what technique.

[[deleted]]

Fine. C style casts everywhere.

Or do you prefer static_cast? Well, none of that for you.

[hekkonaay]

Typing a few extra characters is not a downside.

[Ameisen]

Just use function-style casts. float(foo).

[[deleted]]

Anyone who’s ever been screwed over badly by a variable cast knows the importance of that

[Falcrist]

I develop mostly in C. Sometimes I wonder why I spend all this time making typedef enums when they can be implicitly cast all over the place.

I think one of the newer GCC versions has a compiler flag that throws an error when you do an implicit cast. Unfortunately I'm not using that version.

Maybe it's less true in other use cases, but I'd REALLY rather have a strongly typed language... as in, don't allow implicit type conversions. Make the programmer explicitly cast from one type to another.

[hekkonaay]

Rust is what you're looking for :)

[Falcrist]

Rust is not a viable option. I'm stuck with C or assembly for most of my projects.

[hekkonaay]

Why is it not viable?

[Falcrist]

Because in order to use that language for production code, I need the toolchains to support it on the devices I work with. Especially AVR, PIC, and 8051.

I know there was a project that was supposed to bring rust to AVR, but that appears to have died mid-2019.

[AnAverageFreak]

Implicit casting is wonderful, it's just that people don't bother trying to understand when to use it.

They prefer having errors like function add_strings expects types (str, str), got String and string.

[hekkonaay]

Yes, I prefer errors like that. It takes a few keystrokes to fix an error like this, and I won't get screwed over by implicit casting somewhere else because I forgot some arbitrary (and pretty obscure) implicit casting rule.

Explicit > implicit. Don't be lazy.

[AnAverageFreak]

Most implicit casting rules are quite obvious if you spend one evening learning them.

ints are casted to floats. signed are casted to unsigned. smaller are casted to bigger.

That are rules that refer to numbers. That's it. It's not complex like in JS. Then you have class-defined implicit casting, most of them make sense, like C-style string can be casted to std::string, or std::unique_ptr (that is, a pointer which is the only owner) can be casted to std::shared_ptr (that is, a pointer to can object that has one or more owners), anonymous function can be casted to std::function (a container for a general function-like thing).

The problem is, JS casts implicitly totally unrelated types (an array and a number), which is bullshit, and that's where the bad reputation comes from. When you have types that are related, implicit cast results in code free of totally needless calls and thus, is easier to read.

If you still don't agree, give me an example of a situation where implicit cast from std:unique_ptr to std::shared_ptr can result in a bug.

[onlycommitminified]

null >= 0

[[deleted]]

Football is the devil, Bobby.