Ttdfjt

Adding to @RobertHarvey's excellent answer I believe there is only one legitimate reason I've ever encountered for saving commented code to source control, even temporarily: in case of non-obvious replacement code which should not or cannot be used right now for some reason. Even then most of the comment should be the explanation, not the replacement code. This could be a bug or a feature of the language which is not yet considered stable. It might look something like this:

# TODO: Replace with `foo = frobnicate(bar)` once <link.to/bug> is fixed
foo = [some complex workaround]

In this case, the work has already been done, but you can't yet take advantage of it, so deleting it means someone would have to rediscover it later. The same goes for suboptimal solutions which may seem superior on the face of it or conscious trade-offs against similar solutions.

Caution: Don't litter your code with alternative solutions. Every task can be done in infinitely many different ways, and it's not cost-effective to explore this space for a long time for every change. Code reviews can be a good place to discover such missing comments, when your colleague suggests an improvement which you have already discovered to be suboptimal.

Hmm, I read this question slightly differently from Robert who correctly asserts that commented out code should be removed.

If, however, you are looking for a convention to mark code for later removal, an old favorite of mine is:

//b = false; //TODO: remove

Some IDE's flag //TODO: comments or can be taught to. If not, it's usually a searchable string. It's best to follow whatever convention your shop has established because this can be done several ways. Every code base should do this one way. Keeps it searchable.

quickly parse which is which?

Without that mark the automated way to do this is with the compiler. If stripping the comment off produces code that compiles, it must have been commented code. Writing an IDE plugin that checks that wouldn't be hard. But it will leave buggy commented code behind.

This is why it's better to simply mark commented out code as code the moment you comment it out. This lets you work non-destructively while you decide if you really want it gone. Since we all get interrupted, and are somewhat forgetful, don't be surprised if some lines get checked in while in that state. If they do it's nice that they're at least clearly marked and searchable. Keyboard macros have helped me with this in the past. It's hard to get interrupted in the middle of this if you can do it with a single keystroke.

You can take this as far as enshrining the mark in your continuous integration tests. Oops, I'm trying to check in with outstanding TODO's again.

I use preprocessor directives to remove code, not comments at all:

//comment
active_code();
#if FALSE
inactive_code();
#endif

This makes a very easy thing to search for, and my syntax highlighter treats it as a comment. I can even collapse it into a single line: #if FALSE(...)

You can expand on that idea to have several options:

#if OPTION == 0
code_for_option_0();
#elif OPTION == 1
code_for_option_1();
#else
code_for_all_other_options();
#endif

And compile-time error-checking:

#if FOO >= 5
#error FOO should be less than 5!
#endif

Of course, you don't want to go overboard on this, or it becomes difficult to tell what's actually getting compiled and what isn't. But you get the idea, and it's the same problem as for commented code anyway...as long as you only use it statically. If your conditions are dynamic, it's worse.

To determine which is which in an existing codebase that didn't consider this problem at all, I don't think there is a universal solution. You'll have to find patterns yourself and probably code a regex to find them.

I agree with the answer stating that old code should be removed rather than commented out where possible, however I have observed a convention for those few occasions when commented-out code is needed.

(My basis is C# but this can be applied to any C-syntax language eg java)

// An explanatory comment has a space between the comment marker and the content.

// The following lines are commented out code so do not have the space (except where indented).
//var a = something();
//if(a==2) 
// doSomethingElse();
//

I am interpreting the question different still, thinking you want to find commented out code.

C-style code is bound to have semi-colons in it while comment is unlikely to have semi-colons in it. So for single line commented-out code you could use this regular expression:

s*//[sS]*;

For multi-line commented-out code it could be

/*[^;]*;[^;]**/

Note Visual Studio is a bit peculiar about line breaks in regular expressions, they do not count as whitespace, you need to specify an explicit n.

If you use an editor with a compiler running in the background (like Xcode and Clang), you can just try to compile the text of the comment. For example”a concise description” gives errors, “b = false;” doesn’t. You could then use different syntax highlighting.

A simpler method would be an IDE plugin that uses some heuristics, like multiple words in a row other than keywords points to comments, matched curly braced point to code etc.

Other answers have covered variations on the "don't comment out code" theme. But sometimes you do still want it around for reference.

If you genuinely need the code to stay around, a better solution is to surround the code with "#if 0 ... #endif", ideally with a comment to say why. This is the recommended strategy from various coding standards, including MISRA.