I\'ve always been a little confused about what\'s going on here:
#include
int main() {
timeval tv;
tv.tv_sec = 1;
for (;;) {
It's just how C looks like. Therefore, the following patterns is pretty common in C:
typedef struct YourStructure
{
int x;
// more fields
} YourStructure;
Then you can reference it the same way like in C++.
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
.
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:
public
, private
etc)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#.
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.
It's simply a difference in the languages. C++ is more permissive in its struct syntax.
The way C does it came first, of course. Structs and classes in C++ are nearly identical, and it would have been very inconvenient to require class
with every class variable so it was simplified for both.