C语言的不完整类型和前置声明

声明与定义（Declaration and Definition）

开始这篇文章之前，我们先弄懂变量的declaration和definition的区别，即变量的声明和定义的区别。

一般情况下，我们这样简单的分辨声明与定义的区别：建立存储空间的声明称之为“定义”，而把不需要建立存储空间的称之为“声明”。

其实更为准确地描述的话，变量的声明可以分为两种情况：

（1）一种是需要建立存储空间的。例如：int a;在声明的时候就已经建立了存储空间。这种声明是定义性声明（defining declaration）。即我们平时所说的“定义”；

（2）另一种是不需要建立存储空间的，只是告诉编译器某变量已经在别处定义过了。例如：extern int a;其中，变量a是在别处定义的。这种声明是引用性声明（referning declaration）。即我们平时所说的“声明”。

所以，从广义的角度来说，声明中包含着定义，但是并非所有的声明都是定义。即，定义性声明既是定义又是声明，而引用性声明只是声明。例如，int a;它既是定义又是声明，而extern int a;就只是声明而不是定义。再来看具体的例子：

int a;        // 定义性声明，分配存储空间，初值不确定
int b = 0;    // 定义性声明，分配存储空间，赋初值
extern int c; // 引用性声明，不分配存储空间，只是告诉编译器变量c在别处分配过了  

 

C语言类型（C Types）

C语言将类型分为三类（C99 6.2.5）：

Types are partitioned intoobject types(types that fully describe objects),function types(types that  describe  functions),  andincomplete  types(types  that  describe  objects  but  lack information needed to determine their sizes).

（1）对象类型（object types）：对象的大小（size）、内存布局（layout）和对齐方式（alignment requirement）都很清楚的对象。

（2）不完整类型（incomplete types）：与对象类型相反，包括那些类型信息不完整的对象类型（incompletely-defined object type）以及空类型（void）。

（3）函数类型（function types）：这个很好理解，描述函数的类型 -- 描述函数的返回值和参数情况。

这里我们详细了解下不完整类型。先看哪些情况下一个类型是不完整类型：

再看标准的说明：

The void type comprises an empty set of values; it is an incomplete type that cannot be completed. （C99 6.2.5/19）

An array type of unknown size is an incomplete type. It is completed, for an identifier of that type, by specifying the size in a later declaration (with internal or external linkage). A structure or union type of unknown content (as described in 6.7.2.3) is an incomplete type. It is completed, for all declarations of that type, by declaring the same structure or union tag with its defining content later in the same scope.（C99 6.2.5/22）

总结如下

    （1）具体的成员还没定义的结构体（共用体）

    （2）没有指定维度的数组（不能是局部数组）

    （3）void类型（it is an incomplete type that cannot be completed） 

sizeof操作符不可以用于不完整类型，也不可以定义不完整类型的数组

为什么要有不完整类型

或者说不完整类型有哪些作用，C里为什么要有不完整类型？

可以这么说，C的不完整类型是提供给C实现封装抽象的唯一工具（这样说，不知道是不是有些武断，欢迎批评指正哈）。

举个例子，我们可以在list.c中定义

struct __list {
    struct __list *prev;
    struct __list *next;
    viud	  *data;
};

在list.h中这样：

typedef struct __list *list_t;

这样的话，链表结构的具体定义对用户来说就是透明的了，不能直接的访问结构成员，只能提供相应的接口来供访问，这样做的好处显而易见，可以防止用户随意破坏模块内部的抽象数据类型。

不完整类型的缺点

（1）使用不完整类型的话，我们也就只能使用指向该不完整类型的指针了，因为指针类型是平台相关的，即在特定的平台上指针变量的大小是已知的。

（2）在不完整类型还没有完整之前，sizeof操作符是获取不了该类型的大小的。

（3）头文件中我们也是不可以使用inline函数的，因为类型是不完整的，在inline函数中如果访问成员的话，编译器会报错。

前置声明（forward declaration） 

维基百科上的定义是：

In computer programming, a forward declaration is a declaration of an identifier (denoting an entity such as a type, a variable, or a function) for which the programmer has not yet given a complete definition. It is required for a compiler to know the type of an identifier (size for memory allocation, type for type checking, such as signature of functions), but not a particular value it holds (in case of variables) or definition (in the case of functions), and is useful for one-pass compilers. Forward declaration is used in languages that require declaration before use; it is necessary for mutual recursion in such languages, as it is impossible to define these functions without a forward reference in one definition. It is also useful to allow flexible code organization, for example if one wishes to place the main body at the top, and called functions below it. 

我们可以从上面定义中提取出如下信息:
（1）前置声明是针对类型，变量或者函数而言的
（2）前置声明是个不完整的类型
（3）前置声明会加快程序的编译时间

其实上面的typedef struct __list *list_t;就是建立在前置声明基础上的。

前置声明有哪些作用

（1）前置声明可以有效的避免头文件循环包含的问题，看下面的例子

// circle.h
#include "point.h"

struct circle {
    struct coordinate center;
}; 

// point.h
#include "circle.h"

struct coordinate {
    struct circle cir;
};

#include "circle.h"

int main(int argc, const char *argv[])
{
    struct circle cir;
    return 0;
}

如果编译这个程序，你会发现因为头文件循环包含而发生编译错误，即使修改头文件如下也还是不行：

#ifndef __CIRCLE_H__
#define __CIRCLE_H__
// circle.h
#include "point.h"

struct circle {
    struct coordinate center;
};
#endif

#ifndef __POINT_H__
#define __POINT_H__
// point.h
#include "circle.h"

struct coordinate {
    struct circle cir;
};
#endif

这个时候就可以使用前置声明轻松的解决这个问题，但是必须要使用指向不完整类型的指针了。

#ifndef __CIRCLE_H__
#define __CIRCLE_H__
// circle.h
//#include "point.h"

struct coordinate;
struct circle {
    struct coordinate *center;
};
#endif

#ifndef __POINT_H__
#define __POINT_H__
// point.h
//#include "circle.h"

struct circle;
struct coordinate {
    struct circle *cir;
};
#endif

可以发现我们连头文件都不用包含的，这就可以缩短编译的时间了。

因为前置声明是个不完整类型，所有不完整类型的优缺点和注意事项完全适用于前置声明。

 

参考链接：

http://blog.csdn.net/xiaoyusmile/article/details/5420252

http://blog.csdn.net/tonywearme/article/details/8136530

http://blog.csdn.net/candcplusplus/article/details/38498707

http://blog.sina.com.cn/s/blog_6f70a9530101en3a.html

http://www.embedded.com/electronics-blogs/programming-pointers/4024893/Incomplete-types-as-abstractions

http://everything.explained.today/Opaque_data_type/

http://verplant.org/oo_programming_in_c.shtml

http://www.tamabc.com/article/459136.html

http://blog.aaronballman.com/2011/07/opaque-data-pointers/

http://jatinganhotra.com/blog/2012/11/25/forward-class-declaration-in-c-plus-plus/

http://accu.org/index.php/journals/1593 

http://spin.atomicobject.com/2014/05/19/c-undefined-behaviors/

https://akrzemi1.wordpress.com/2013/12/11/type-erasure-part-iii/

http://ericniebler.com/2014/11/13/tiny-metaprogramming-library/

http://hubicka.blogspot.com/2014/09/devirtualization-in-c-part-6-enforcing.html

http://jguegant.github.io/blogs/tech/sfinae-introduction.html

《C语言不透明结构体句柄--数据隐藏》

《C语言开发函数库时对外接口隐藏库内结构体实现细节的方法》

《Opaque Type Oriented Programming in C》

《不透明类型》http://os.is-programmer.com/posts/40846.html?utm_source=tuicool&utm_medium=referral

《Log4c中的接口实现分离 – 以Appender为例》

《Opaque Pointers——不透明指针》

《不透明结构体使用》

《C语言抽象数据类型及不透明指针》

《关于不透明指针》

《C及虚拟内存总结》