关于编译错误－－提领指向不完全类型的指针

      前段时间调试c语言程序时，对一结构体的成员变量进行访问时，编译无法通过，
编译器错误提示为“提领指向不完全类型的指针”。

      因程序调用了一些动态链接库，里面使用了不些在动态库中定义的结构，为了了解程序的运行过程，
想知道结构体中的成员变量的值，加上些调试语句，如printf什么的，竟然无法通过编译了。

     一开始有点无解，可以通过结构体自身定义的函数进行访问，为什么直接操作的结构体时就出现编译错误，
翻了翻以前的c语言书才知道，对于结构体来说虽然所有的变量默认都是公有的，但是，如果想访问里面的成员变量，
必须有包含对其结构的定义，否则出现如上的错误，c编译器将无法识别结构里面的变量，一般想操作结构体里的成员变量，
都是通过调用结构体中定义的函数接口，来取得结构体中的值，如果想直接访问，在头文件或源文件中加入
结构体的定义就行了。

这种情况出现的可能有(test.h test.c)生成一动态链接库(test.so)，使用do.c文件进行测试，如下：

1. //file name : test.h
2. typedef struct _Test Test;
4. void set_value(Test *test, int value);
6. int  get_value(Test *test);
8. void set(Test *test);

1. //file name : test.c
3. #include "test.h"
5. struct _Test 
6. {
7.     int value;
8. };
10. void set_value(Test *test, int v)
11. {
12.     test->value = v;
13. }
15. int get_value(Test *test)
16. {
17.     return test->value;
18. }
20. void set(Test *test)
21. {
22.     test->value = 100;
23. }

1. //生成动态库test.so
   
2. # gcc -fpic -shared -o test.so test.c test.h

1. //file name : do.c
2. #include <stdio.h>
3. #include <malloc.h>
5. #include "test.h"
7. int main()
8. {
9.     Test *test = (Test *)malloc(sizeof(Test *));
10.     test->value = 20;
11.     printf("%d/n", get_value(test));
12.     set_value(test, 10);
13.     printf("%d/n", get_value(test));
14.     set(test);
15.     printf("%d/n", get_value(test));
16.     return 0;
17. }

1. #gcc do.c ./test.so -o do
2. #错误： 提领指向不完全类型的指针  //因为在do.c文件中只包含了test.h对结构的声明，没有实际的定义

将第10行的“test->value = 20;"注释后，便可通过编译，而且程序可以通过test.h定义的方法来操作成员变量的值。
如果在do.c中加入对Test结构体的描述便可以直接访问成员变量。

1. //file name : do.c
2. #include <stdio.h>
3. #include <malloc.h>
5. #include "test.h"
7. struct _Test
8. {
9.     int value;
10. };
12. int main()
13. {
14.     Test *test = (Test *)malloc(sizeof(Test *));
15.     test->value = 20;
16.     printf("%d/n", get_value(test));
17.     set_value(test, 10);
18.     printf("%d/n", get_value(test));
19.     set(test);
20.     printf("%d/n", get_value(test));
21.     return 0;
22. }
    

1. #gcc do.c ./test.so -o do   //通过编译，执行
2. #./do                                 //显示正常调用的结果
3. #20
4. #10
5. #100