Why does C need "struct" keyword and not C++?

Solution 1:

Syntactically both treat struct almost the same. Only C++ has added an extra rule that allows to omit the struct (and class) keyword if there is no ambiguity.

If there is ambiguity, also C++ requires the struct keyword in some places. A notorious example is stat on POSIX systems where there is a struct stat and a function stat.

Solution 2:

Consider the original idea of C++ (or, when it was just an idea, "C with classes"), that of an OO-oriented language that was compatible with C to the point where most valid C programs were also valid C++ programs.

C++ built its class model by starting with C's struct and adding some further functionality:

1. Inheritance (though you can come close in C with having the first member of a struct the struct you want to "inherit" from).
2. Information hiding (through public, private etc)
3. Member methods (which were originally turned by macros into C code outside the struct with an added this parameter - many implementations are still similar in practice).

At this point there were two problems. The first is that the default access had to be public, since C has no information hiding and therefore from a C++ perspective has everything public. For good OO one should default to private. This was solved by adding class which is pretty much identical to struct except for the default is private rather than public.

The other is that this OO perspective should have timeval or any other class/struct on the same "footing" as int or char, rather than constantly annotated in the code as special. This was solved by relaxing the rule that one must place struct (or class) before the name of the type in declaring a variable of that type. Hence struct timeval tv can become timeval tv.

This then influenced later C-syntax OO languages, like Java and C# to the point where, for example, only the shorter form (timeval tv) would be valid syntax in C#.

Solution 3:

I would say it's a design decision of both languages.

Structs in C are just structured records and have different usage then built-in type.

C++ has ctors and operator overloads and so they act as types.

struct foo x;         // create a structure of pattern foo
typedef foo foo_type; // "define" a type
foo_type x;           // create an instance of type foo_type

C++:

foo x; // create an instance of type foo

As a side-note, struct foo is still allowed in C++. struct foo is easier to parse then typedef'dfoo as the name-lookup is simpler.