Geek asks and answers

Expect 'struct netif *', but the argument is of type 'struct netif *'

I get the following error in gcc when I declare struct netif *from the scope (where the compilation does not complain) to the global scope:

src/main.c:114:3: warning: passing argument 1 of 'low_level_init' from incompatible pointer type [enabled by default]
src/main.c:62:13: note: expected 'struct netif *' but argument is of type 'struct netif *'

Why does the compiler give the following “insensitive” complaint?

expected 'stuct netif *' but argument is of type 'struct netif *'

+3
source share
4 answers

This "full program"

void foonetif(struct netif *dst) {
  if (dst) return;
  return;
}

struct netif {
  double bar;
};

int main(void) {
  struct netif *netif = 0; /* NULL */
  foonetif(netif);
  return 0;
}

generates this output from gcc 10398683.c(gcc version 4.6.3), so with all the default options

10398683.c: 1: 22: warning: 'struct netif' declared inside parameter list [enabled by default]
10398683.c: 1: 22: warning: its scope is only this definition or declaration, which is probably not what you want [enabled by default]
10398683.c: In function 'main':
10398683.c:12:3: warning: passing argument 1 of ‘newnetif’ from incompatible pointer type [enabled by default]
10398683.c:1:6: note: expected ‘struct netif *’ but argument is of type ‘struct netif *’

( ):)

+4

- . struct netif . struct netif . , , , . , int i; int i; - , .

+2

; ; - .


R, ( and goes out of scope after that function ends..)

:
(1) ISO C99 6.7.2:

, . 6.7.2 , 6.7.3 6.7.5 .46) , , , , : , ....


(2) C


Anyway, here is some code (~ a couple of translation units), which, we hope, demonstrates some, perhaps, amazing behavior for those who have not yet touched on this problem:

blah.c:

#include <stdio.h>

struct bar  {int a; int b;} stbar; 
struct bar_ {int a; int d;} stbar_; 

void foo(struct bar* pst);
void foo_(struct bar st);


void callfoo() 
{ 
    /*no warnings; possibly surprising results ! */
    stbar.a=313;
    stbar.b=31313;
    foo(&stbar);
    printf("called foo() with stbar:  %d, %d\n", stbar.a, stbar.b);

    /*generates incompatible types warnings:
    blah.c:23:5: warning: passing argument 1 of ‘foo’ from incompatible pointer type [enabled by default]
    blah.c:6:6: note: expected ‘struct bar *’ but argument is of type ‘struct bar_ *’    */
    stbar_.a=313;
    stbar_.d=31313;
    foo(&stbar_);
    printf("called foo() with stbar_: %d, %d\n", stbar_.a, stbar_.d);


    /*generates incompatible types warnings:
    blah.c:31:5: warning: passing argument 1 of ‘foo’ from incompatible pointer type [enabled by default]
    blah.c:6:6: note: expected ‘struct bar *’ but argument is of type ‘struct bar *’      */
    struct bar  {float s; float t;} stbar; 
    foo(&stbar);
    printf("called foo() with locally defined stbar:  %f, %f\n", stbar.s, stbar.t);    
}


void callfoo_()
{
    stbar.a=313;
    stbar.b=31313;

    //passing in incompatible type by value ~ no warnings; possibly surprising results ! 
    foo_(stbar); 

    /*uncomenting next line generates compiler error: 
    blah.c:47:5: error: incompatible type for argument 1 of ‘foo_’
    blah.c:7:6: note: expected ‘struct bar’ but argument is of type ‘struct bar_’     */
    //foo_(stbar_); 
}


void main() 
{
    callfoo();
    callfoo_();
}

blah_.c:

#include <stdio.h>

struct bar {int x; float z;} stbar; 

void foo(struct bar* pst)
{
    printf("foo : %d, %f\n", pst->x, pst->z);
    pst->x=13;
    pst->z=13.13;
}

void foo_(struct bar st)
{
    printf("foo_ : %d, %f\n", st.x, st.z);
    st.x=13;
    st.z=13.13;
}

output:

$ gcc  blah.c blah_.c
blah.c: In function ‘callfoo’:
blah.c:23:5: warning: passing argument 1 of ‘foo’ from incompatible pointer type [enabled by default]
blah.c:6:6: note: expected ‘struct bar *’ but argument is of type ‘struct bar_ *’
blah.c:31:5: warning: passing argument 1 of ‘foo’ from incompatible pointer type [enabled by default]
blah.c:6:6: note: expected ‘struct bar *’ but argument is of type ‘struct bar *’

$ ./a.out
foo : 313, 0.000000
called foo() with stbar:  13, 1095898235
foo : 313, 0.000000
called foo() with stbar_: 13, 1095898235
foo : 13274075, 0.000000
called foo() with locally defined stbar:  0.000000, 13.130000
foo_ : 313, 0.000000

$ gcc --version
gcc (Ubuntu/Linaro 4.6.1-9ubuntu3) 4.6.1 ...


Consequence of the investigation: praise the gods for C ++ namespaces.

+1
source

Your "complete program" will not compile.

struct netif is not declared before the foonetif that uses it. Try moving the structure definition to its first use.

0
source

More articles: