dwazegek posted:

I have a colleague who also does stuff like this. For whatever reason, he refuses to use return anywhere, except the last line of a method. This frequently results in methods with absurd amounts of indentation, or stuff like this:

code:

public bool HasValidItems(SomeClass[] items)
{
  bool retVal = false;
  foreach(SomeClass item in items)
  {
    retVal = retVal || item.IsValid;
  }
  return retVal;
}

public SomeClass FindSomeItem(SomeClass[] items)
{
  SomeClass retVal = null;
  foreach(SomeClass item in items)
  {
     if(item.MatchesWhateverWeAreLookingFor)
     {
       retVal = item;
     }
  }
  return retVal 
}

Who cares if we've already found what we're looking for, let's keep on looking

rotor posted:

When I used to work in the build department, I inherited some real doozies. The build scripts were giant shell scripts running under MKSTools. Probably half of the code we compiled was generated by a process I won't pretend I even came close to understanding. There was a lot of necessary complexity because we built for a shitload of different platforms, but one thing really stuck out.

The guy who wrote the bulk of the build scripts really wanted inheritance in his shell scripts. In order to accomplish this, the script searched through the 'parent' shell script for a particular line (not some kind of obvious comment delimiter like "#---THIS IS A DELIMITER---", just another line of a shell script), then took that line and the next 50 or however many, and piped it to a file. He then sourced that file, deleted it, then called functions that the now-deleted file had. It must have taken me a week to figure that poo poo out. And he did it in like four places.

such a nice boy posted:

Dude, whitespace changes can be incredibly annoying, and sometimes autocorrect functions don't work well.

chocojosh posted:

In all seriousness then, how would you encode N different options that can be on simultaneously? I always assumed the bitmask would work (and I would go so far to say that it is a simple and clear solution that should be efficient enough for small cases, n <= 8 or n <= 32).

chocojosh posted:

Alright, so then you also second the bitmask suggestion (which means I'm not totally crazy).

In C++ you can use the bitset

Flobbster posted:

I'm surprised nobody has mentioned this advantage yet. If I remember my Win32 API correctly, there's a window style called WS_EX_THICKFRAME. But it doesn't let me control the degree of thickness.

code:

DWORD exStyle = WS_EX_THICKFRAME; // thick
DWORD exStyle = WS_EX_THICKFRAME | WS_EX_THICKFRAME; // DAMMIT IT'S NOT THICKER

How restrictive! But if we redefined the styles to use prime numbers, imagine the thickability:

code:

DWORD exStyle = (DWORD) pow(WS_EX_THICKFRAME, 10);

Now THAT'S a thick-rear end window frame that will draw the attention that my awesome application deserves. I mean, come on.

yaoi prophet posted:

ShoulderDaemon posted:

Why? If you're about to dereference a pointer in a dynamically-allocated structure, then there's a very good chance you've lost memory locality and are about to stall on memory access anyway, so the check is essentially free. It inflates code size slightly, so I wouldn't do it inside a tight loop, but I'd be trying not to traverse large structures in a tight loop anyway.

TSDK posted:

Hungarian notation is an old technique that has no place in modern C++ programming, but there are one or two odd exceptions which are either genuinely useful, or are a strange hang-over.

tripwire posted:

God I hate hungarian notation. How in the hell did anyone ever think it was a smart idea

tripwire posted:

At the risk of opening a can of worms, its retarded in either form. You are only adding more headaches for yourself later on.

geetee posted:

There is no way &1 even compiles (right?) so I don't understand what this entire fiasco is about. The logical operator "AND" requires two ampersands, not one. I'm surprised none of your IDEs warned you about this. It's just a segfault waiting to happen. Just use modulus and move on.

No Safe Word posted:

*whoooosh*

edit: or "look at you, look how stupid you are" I guess