Why is the C++ syntax so complicated?

Python is high-level language. C++ is middle-level language.

This reminds me of The Evolution of a Programmer. Some of the languages and technologies demonstrated are a bit dated now, but you should get the general idea. 🙂

You include <iostream> when you want to output things to the console. Since printing “Hello world” involves console output, you need iostream.

The main function is called by the operating system, basically. It gets called with the command-line arguments passed to the program. It returns an integer because the program must return an error code to the operating system (this is the standard way for determining if the last command was successful).

You can always use printf("hello world"); instead of std::cout << "hello world"; if you want to go C style. It’s a bit quicker to write and lets you do formatted output.

You return 0 from main to indicate that the program executed successfully.

The compiler does not automatically include all the standard libraries and use namespace std because sometimes name collisions can result between your code and library code that you may not actually need at all. You don’t always need all the libraries. Likewise, sometimes you are using a different main routine (Windows development comes to mind with its own, different WinMain starting function). The compiler also does not automatically return 0 because sometimes the program needs to indicate that it completed unsuccessfully.

There are good reasons for all these things. C++ is a very broad language it is used for everything from small embedded systems to giant applications built by 100s of programmers. The use case of a guy building a small program to run on a desktop is by no means the only one. So sometimes you are building library components. In that case no main(). Sometimes you are working on a tiny system with no standard library. In that case no std. Sometimes you want to build a Unix tool that works with other Unix text tools and signals its completion status with an int returned from main().

In other words the things you complain about are boilerplate to you. But they are vital details that vary to other users of the language.

In response to your questions at the end of the post, it can be summed up with the philosophy of C++:

You don’t pay for what you don’t use.

You don’t always need to use stdin or stdout (Windows/GUI apps?), nor will you always be using the STL, nor will everything you write necessarily use the standard main (winAPI) etc. As a previous poster said, C++ is lower level than Python. You will be exposed to more of the details, which offers you more control over what you’re doing.

As people have said, the simple answer is that they’re different languages, with different goals. To answer your specific questions…

… do you have to include the <iostream> everytime? Do you ever not need it?

<iostream> is one of the header files for iostreams, the part of the C++ standard library responsible for input/output; in this instance, you need it to gain access to std::cout. If you’re not doing I/O operations in a source file, you don’t need to include it — for example, most files containing class definitions probably won’t need <iostream>.

… same question for the standard library, when do you not need std::*?

std is the name of namespace containing classes in the standard library; it’s there to avoid name collisions. Python has packages and modules to do this.

You can use the using statement to bring items from another namespace into your current scope, see this FAQ entry for an example (and an explanation of why it’s bad to blindly bring all of std into scope!).

… why is the “main” part a function? Do you ever call the main function? Why is it an integer? Why does C++ need to have a main function but Python doesn’t?

Executable statements in C++ have to be contained within a function, and the main function is defined as where execution begins. In Python, executable statements can be placed at the top-level of a file, and execution is defined to .

You can call main() if you wish — it’s just a function, after all — but there’s not often a reason to do this. Behind the scenes, most implementations of C++ call main() for you once some startup housekeeping has been done by the runtime library.

The return value of main() is returned back to the operating system. This stems from C and UNIX, in which application programs are required to provide a 1-byte exit status code, and returning that value from main() is a clear way of expressing this.

… why do you need “std::cout << “? Isn’t that needlessly long and complicated compared to Python?

This is just a design difference. iostreams is a fairly complex beast with lots of features, and one of the side-effects of this is that the syntax is a bit ugly for simple tasks at times.

… why do you need to return 0 even when you are never going to use it?

You do use it; this is the value returned to the operating system as the exit status of the program.

… do you have to include the
everytime? Do you ever not
need it?

You don’t need it if you’re not going to use iostreams in that module. In larger programs, few modules do any actual IO directly, and so few actually need to use iostreams.

Turning the question around: in python you need to import sys and/or os in most non-trivial programs. Why?

… same question for the standard
library, when do you not need std::*?

You can have the using line or you can use the std:: prefix. This is very similar to the choice python gives you of either saying “from sys import *” or “import sys” and then having to prefix things with “sys.”. In python you have to say “sys.stdout”. Is “std::cout” really any worse?

… is the “main” part a function? Do
you ever call the main function? Why
is it an integer? Why does C++ need to
have a main function but Python
doesn’t?

Yes, main is a function. Typically you wouldn’t call main yourself. The name “main” is reserved for the entry-point of your program. It returns an integer because the value returned is used as the status code of your program. In Python you can use sys.exit if you want to return a non-zero status code.

Python doesn’t have the same convention because with Python you can have code in a module not in a function. This code is executed when you load the module. Interestingly, many people feel it is bad style to have code at the top-level of a module and will instead create a main function by doing something like this:

def main(argv):
  # program goes here

  return 0

if __name__ == '__main__':
  sys.exit(main(sys.argv))

Also, in Python you tell the interpreter with module is the “main” module when you run it. eg: “python foo.py”. In C, the “main” module is (effectively) the one with a function called main. (If there are multiple modules with a main function, it’s a linker error.)

… do you need “std::cout << “? Isn’t
that needlessly long and complicated
compared to Python?

The equivalent in Python is actually “sys.stdout.write(…)”. Python’s print statement is a special-case short-hand.

That said, many people do feel the iostreams convention of using bit-shifting operators for IO was a bad idea. Ironically, Python seems to have been “inspired” by this syntax. If you want to use print to write to somewhere other than stdout you can say:

print >>file, "Hello"

… do you need to return 0 even when
you are never going to use it?

You aren’t going to use it, but your program will. As mentioned earlier, the value you return is the status code of your program.

Aside: I actually do feel that C++ is overcomplicated, but not because of any of the points you mention. All of the differences you mention go away (in the sense that you need just as much complexity in Python) once you start writing non-trivial programs that have multiple modules and do more than just writing to stdout.

Baldur:

You don’t always need <iostream>. The only things that you will always need are:

1. A main function (or a WinMain, if you’re writing Win32 apps).
2. Variables, functions, operators, language constructs (if, while, etc.).
3. The ability to include functionality from libraries into your program.

Everything else is application-specific.

As other posters say, the return value of the main function is an error code¹. If main returns 0, be happy: everything worked OK!

¹This is useful when you write programs that “communicate” with other programs. The most simple way that a program can “tell” another whether it executed properly is using an error code.

One of the reasons C++ is rather complicated is because it was designed to address problems that crop up in large programs. At the time C++ was created as AT&T, their biggest C program was about 10 million lines of code. At that scale, C doesn’t function very well. C++ addresses many of the problems you get with that kind of program.

With that said, it’s also possible to answer the original questions:

• You would include <iostream> where it’s needed. If you’ve got 10.000 C++ files, it’s quite common that less than 1000, sometimes less than 100 will produce user-visible output.
• A statement like print "Hello, world" assumes that there is a default output, but makes it hard to generalize. The cout << "Hello, world" form makes it explicit where the output goes, but the same form also allows cerr << "Goodbye, world" and MyTmpFile << "Starting phase #" << i
• The standard library is in the std:: namespace. My 10.000 files will be in an additional 25 namespaces.
• main is an oddity in many ways, being the startup function.