Semicolon in C++?

Question

Is the "missing semicolon" error really required? Why not treat it as a warning?

When I compile this code

int f = 1
int h=2;

the compiler intelligently tells me that where I am missing it. But to me it's like - "If you know it, just treat it as if it's there and go ahead. (Later I can fix the warning.)

  int sdf = 1, df=2;
  sdf=1 df =2

Even for this code, it behaves the same. That is, even if multiple statements (without ;) are in the same line, the compiler knows.

So, why not just remove this requirement? Why not behave like Python, Visual Basic, etc.

Summary of discussion

Two examples/instances were missing, and a semi-colon would actually cause a problem.

1.

return
 (a+b)

This was presented as one of the worst aspects of JavaScript. But, in this scenario, semicolon insertion is a problem for JavaScript, but not for C++. In C++, you will get another error if ; insertion is done after return. That is, a missing return value.

2

int *y;
int f = 1
*y = 2;

For this I guess, there is no better way than to introduce as statement separator, that is, a semicolon.

Answer 1

It's very good that the C++ compiler doesn't do this. One of the worst aspects of JavaScript is the semicolon insertion. Picture this:

return
  (a + b);

The C++ compiler will happily continue on the next line as expected, while a language that "inserts" semicolons, like JavaScript, will treat it as "return;" and miss out the "(a + b);".

Instead of rely on compiler error-fixing, make it a habit to use semicolons.

Answer 2

There are many cases where a semicolon is needed.

What if you had:

int *y;
int f = 1
*y = 2;

This would be parsed as

int *y;
int f = 1 * y = 2;

So without the semicolons it is ambiguous.

Answer 3

First, this is only a small example; are you sure the compiler can intelligently tell you what's wrong for more complex code? For any piece of code? Could all compilers intelligently recognize this in the same way, so that a piece of C++ code could be guaranteed portable with missing semicolons?

Second, C++ was created more than a decade ago when computing resources aren't nearly what they are now. Even today, builds can take a considerable amount of time. Semicolons help to clearly demarcate different commands (for the user and for the compiler!) and assist both the programmer and the compiler in understanding what's happening.

Answer 4

; is for the programmer's convenience. If the line of code is very long then we can press enter and go to second line because we have ; for line separator. It is programming conventions. There must be a line separator.

Answer 5

Having semi-colons (or line breaks, pick one) makes the compiler vastly simpler and error messages more readable.

But contrary to what other people have said, neither form of delimiters (as an absolute) is strictly necessary.

Consider, for example, Haskell, which doesn’t have either. Even the current version of VB allows line breaks in many places inside a statement, as does Python. Neither requires line continuations in many places.

For example, VB now allows the following code:

Dim result = From element in collection
             Where element < threshold
             Select element

No statement delimiters, no line continuations, and yet no ambiguities whatsoever.

Theoretically, this could be driven much further. All ambiguities can be eliminated (again, look at Haskell) by introducing some rules. But again, this makes the parser much more complicated (it has to be context sensitive in a lot of places, e.g. your return example, which cannot be resolved without first knowing the return type of the function). And again, it makes it much harder to output meaningful diagnostics since an erroneous line break could mean any of several things so the compiler cannot know which error the user has made, and not even where the error was made.

Answer 6

In C programs semicolons are statement terminators, not separators. You might want to read this fun article.

Answer 7

+1 to you both.

The semi-colon is a command line delimiter, unlike VB, python etc. C and C++ ignore white space within lines of code including carriage returns! This was originally because at inception of C computer monitors could only cope with 80 characters of text and as C++ is based on the C specification it followed suit.

I could post up the question "Why must I keep getting errors about missing \ characters in VB when I try and write code over several lines, surely if VB knows of the problem it can insert it?"

Auto insertion as has already been pointed out could be a nightmare, especially on code that wraps onto a second line.

Answer 8

I won't extend much of the need for semi-colon vs line continuation characters, both have advantages and disadvantages and in the end it's a simple language design choice (even though it affects all the users).

I am more worried about the suggestion for the compiler to fix the code.

If you have ever seen a marvelous tool (such as... hum let's pick up a merge tool) and the way it does its automated work, you would be very glad indeed that the compiler did not modify the code. Ultimately if the compiler knew how to fix the code, then it would mean it knew your intent, and thought transmission has not been implemented yet.

As for the warning ? Any programmer worth its salt knows that warnings should be treated as errors (and compilation stopped) so what would be the advantage ?

Answer 9

int sdf = 1,df=2;
sdf=1 df =2

I think the general problem is that without the semicolon there's no telling what the programmer could have actually have meant (e.g may-be the second line was intended as sdf = 1 + df - 2; with serious typos). Something like this might well result from completely arbitrary typos and have any intended meaning, wherefore it might not be such a good idea after all to have the compiler silently "correct" errors.

You may also have noticed that you often get "expected semicolon" where the real problem is not a lack of a semicolon but something completely different instead. Imagine a malformed expression that the compiler could make sense out of by silently going and inserting semicolons.

The semicolon may seem redundant but it is a simple way for the programmer to confirm "yes, that was my intention".

Also, warnings instead of compiler errors are too weak. People compile code with warnings off, ignore warnings they get, and AFAIK the standard never prescribes what the compiler must warn about.