CODEWITHSUNDEEP
c
bubble
bubble

Reputation: 3526

Why GCC compiles this erroneous code?

I tried to compile something like:

struct A
{   int a;
    struct B
    {    int c;
    };
};

Now when I compile this code the compiler gives me a warning message that:

declaration does not declare anything [enabled by default]

I know that I have not defined any instance of struct B. That will mean that I shall not be able to access variable c. Still compiler compiles this code with a warning. What's the whole point ? Why does not the compiler give a compilation error instead ?

ADDED Info:
The size of the struct A is equal to the size of int on my machine!!

Upvotes: 1

Views: 160

Answers (4)

Eric Postpischil
Eric Postpischil

Reputation: 222669

Generally, a warning means the code likely does not do what you intended but is legal in the language. The compiler is saying, “This is likely not what you really wanted to do, but I must allow you to do it because the language says it is allowed.” The compiler cannot give you an error for this code because the C standard permits it, so it must be allowed (unless you specifically ask for errors for such things, as by using GCC’s -Werror option to turn warnings into errors).

The C standard does not attempt to define everything that makes sense in a program. For example, these things are legal in C:

3;
if (x) then foo(); else foo();
x = 4*0;

The first statement has no side effects, and its return value is not used. But it is legal in C, since a statement may be just an expression. The second statement just calls foo(), so the if is pointless. In the third statement, multiplying by four is pointless.

It would be extremely difficult to write a C standard that prohibited all things that did not make sense. And it is certainly not worth the effort. So this is part of your answer: When the committee writing the C standard builds the language, do they want to spend a lot of time rewriting the technical specification to exclude things that do not make sense? Sometimes yes, if it seems valuable to avoid something that could cause serious bugs. But much of the time, it is just not worth their time and would complicate the specification unnecessarily.

However, compilers can recognize some of these things and warn you. This helps catch many typographical errors or other mistakes.

On the other hand, sometimes these constructions arise from unusual circumstances. For example, a program may have preprocessor statements that define struct A in different ways when building for different targets or different features. In some of those targets, it may be that the struct B member is not needed in struct A, so it is not declared, but the declaration of struct B (the type, not the object) remains present just because it was easier to write the preprocessor statements that way.

So the compiler needs to permit these things, to avoid interfering with programmers writing a wide variety of programs.

Upvotes: 3

Useless
Useless

Reputation: 67733

Because you can do this:

struct A
{   int a;
    struct B
    {    int c;
    };
};

int main()
{
    struct A a = {1};
    struct B b = {2};

    return a.a + b.c;
}

Note:

  • you need a semicolon after declaring B, which your code is missing
  • this isn't particularly useful, but I suppose it might serve some documentary purpose (ie,to suggest a relationship or grouping between types)
  • in C++, the second variable would have type A::B, but C doesn't have the same scoping rules (all structs just belong to the global struct namespace, in effect)

As to the motivation for allowing it ...

struct Outer {
    struct {
        int b;
    } anon;
    /* this ^ anonymous struct can only be declared inside Outer,
       because there's no type name to declare anon with */

    struct Inner {
        int c;
    } named;
    /* this ^ struct could be declared outside, but why force it to be
       different than the anonymous one? */

    struct Related {
        double d;
    };
    /* oh no we have no member declared immediately ... should we force this
       declaration to be outside Outer now? */

    struct Inner * (*function_pointer)(struct Related *);
    /* no member but we are using it, now can it come back inside? */

    struct Related excuse;
    /* how about now? */
};

Once you've allowed nested type declarations like this, I doubt there's any particular motivation to require there be a member of that type right away.

Upvotes: 4

William Pursell
William Pursell

Reputation: 212248

It's legal (but extremely bad style) to do:

struct A {   
    int a;
    struct B {    
        int c;
    };
};
struct B B_instance;
struct A A_instance;

And the compiler doesn't know about the later variables that use the struct types, so it really should not error out.

Upvotes: 3

singpolyma
singpolyma

Reputation: 11241

You are, in fact, declaring struct B here, but you are not declaring a variable of that type.

This is a warning, but one you should fix. Perhaps you meant:

struct A
{   int a;
    struct B
    {
        int c;
    } c;
};

Upvotes: 1

Related Questions