码迷,mamicode.com
首页 > 其他好文 > 详细

【C】 05 - 声明和定义

时间:2015-04-19 14:46:39      阅读:120      评论:0      收藏:0      [点我收藏+]

标签:c语言   声明定义   

  仅从形式上看,C程序就是由各种声明和定义组成的。它们是程序的骨架和外表,不仅定义了数据(变量),还定义了行为(函数)。规范中的纯语言部分,声明和定义亦花去了最多的篇幅。完全说清定义的语法比较困难,这里也只是个人的理解。

1. 标识属性

  对C编译器而言,标识(identifier)包括对象名、函数名、复合类型及枚举tag、typedef类型名、label和枚举常量。标识的各种属性构成了C的复杂功能,理清这些概念对C的高级使用尤其重要。

  域(scope)可以看做是标识的活动范围,一个编译单元中该范围是层次结构的。最外层当然就是整个编译单元(file scope),它其中包含了各种块(block scope)和子块,这些构成了域的层次结构。这里的块是个宽泛的概念(非规范定义),包括类型定义、函数声明和函数定义。每一个域中的按照标识类型又可以划分为不同的名字空间(name space),同一名字空间的标识不可重名(冲突)。一般情况下,一个父域中的标识可以在子域中活动,但当子域中有与其冲突的标识时,该标识即覆盖父域的标识,使其不可见。大部分标识的可见范围是从其完整定义到其所处域的结尾,tag的可见范围是从其标识结束即开始的,枚举常量从其定义结束可见,label的可见范围是整个函数(function scope)。另外,函数定义不可以出现在块域中,而函数声明、结构和联合则可以。

typedef struct S {         // file scope
    struct S* p;           // S can be used, p block scope
    struct T {int i;} t;   // ok
} S;                       // file scope
enum {
    RED,                   // file scope
    BLACK = RED            // ok
};
void f(int i);             // f file scope, i block scope
int a;                     // file scope

void f(int i)              // i block scope
{
LABEL:                     // function scope
    goto LABEL;
    int m;                 // ok in C99
    int a;                 // ok, cover global a
    void fun(void) {}      // illegal
    extern void fun(void); // ok
    struct T {int i;} t;   // ok
}

  名字空间可分为:label、tag、其它(非规范定义)。这样的分类是按照标识在语法出现的位置决定的,label总是后面跟冒号,tag前面总有关键字struct、union或enum,所以他们总是可以区分出来的。而其它标识可能出现在相同语境中,重名会造成歧义。

typedef struct S {int i;} S; // ok
struct T {
     int T;                  // ok
} S;                         // name conflict
enum {
    S,                       // name conflict
    T                        // ok
}
void F(void)
{
F:                           // ok
    int F;                   // name conflict
}

  域的概念一般出现在编译过程中,而链接属性(linkage)出现在链接过程中,它只针对对象和函数。所有extern修饰的对象和函数都有外部链接(external linkage)的属性,所有文件域的标识都有链接属性,其中含有static修饰符的是内部链接(internal linkage),不含static的是外部链接,其它所有标识皆没有链接属性。外部链接的标识会存储在编译结果中,链接过程负责把标识替换为真实地址,而内部链接的标识符外部不可用。对于未初始化的外部链接对象,如果含有extern则仅是声明,不分配空间,否则是定义。

struct S {int i;};           // no linkage
extern int a[];              // external, declare only
static int b;                // intenal
extern int m = 0;            // define
int n;                       // define
static void f1(void) {}      // internal

void f2(void)                // external
{
    extern void fun(void);   // external, declare only
    static int m;            // no linkage
    int n;                   // no linkage
}

  存储类型(storage class)表示运行时对象的存储方法,分为静态存储(static)、动态存储(dynamic)和自动存储(aotomatic)。所有文件域和有static标识符的对象都是静态存储的,它们在程序生命周期中一直存在。动态存储是通过库函数产生的对象,它们存储在特殊的区域(堆),由用户负责申请和释放。块域的对象在进入块时分配空间(新规范支持在块中间定义),在退出块时释放空间,唯一的例外是变长数组在定义时才分配空间。自动存储的对象默认由auto修饰,也可以由register修饰,它建议把对象存放在寄存器中。但其实现代编译器的优化可以做到这一点,所以register已经过时。

int m;                      // static
static int n;               // static
register int r;             // illegal

void f(void)
{                           // alloc a
    n = m;
    static int s;           // static
    auto int a;             // automatic, the same as int a
    {                       // alloc b
        a = s;
        register int b[2];  // automatic
        int c[a];           // alloc c
    }                       // free b, c
}                           // free a

  C中对对象有一些限定符(qualifier),它们一般起到限制和优化的作用。const所修饰的对象不可通过相应变量直接修改,所以只能在定义时初始化,编译器可能把它当常量使用。volatile所修饰的对象可能被外部改变(系统时间),提醒编译器每次使用时从内存加载。restrict修饰符只作用于指针(受限指针),表示在该指针生命周期内,所指对象(可以是多个)只能直接或间接通过该指针修改,编译器可以对此进行优化。受限指针可以由子域中的另一个受限指针“接管”,而没有未定义行为。

const int c = 0;
const int *pc;
int *pi;
volatile int v = 0;
const volatile long long sys_tick;  // system time
retrict int n;                      // illegal

c = 1;                              // illegal
pc = &c;                            // ok
pi = &c;                            // illegal
pi = (int*)&c;                      // ok
*pc = 1;                            // illegal
*pi = 1;                            // ok
v;                                  // may be not 0

void f(restrict int* p)
{
    restrict int *q = p;            // undefind
    {
        restrict int *s = p;        // ok
    }
}

  函数修饰符(function specifier)作用于函数,包括inline和_Noreturn,它们不能用于main函数。inline建议编译器优化函数代码,它一般在编译单元内部使用,但也可以外部访问(对外是函数形式)。_Noreturn表示函数不会返回,一般直接结束程序(比如abort)。对齐修饰符(alignment specifier)限定对象的对齐方式(已介绍过),当作用于组合类型时,它对每一个成员其作用。

// file 1
extern void f(void);
_Noreturn void fun(void)
{
    f();                  // function call
    return;               // illegal
}

// file 2
inline void f(void) {}
_Noreturn int main(void)  // illegal
{
    f();                  // inline
    abort();
}

2. 一般声明

  首先说明一下,规范中的“声明”包括了定义,下文中一般名词性的“声明”包含定义,其它都是我们常用的单纯“声明”。

  结构(联合)的定义一般叫模板,结构、联合和枚举的类型名叫tag。结构(联合)可以声明(incomplete type),可用于头文件中隐藏具体细节,亦可用于结构(联合)间的互相应用。结(联合)在花括号之后成为完整类型,相互赋值时空隙部分并不赋值。可以有长度为0位域,它结束当前word,但不可以有名字。当成员是结构(联合)且没有变量名,它称为匿名结构(联合),其成员成为上层结构(联合)的成员。枚举不可以声明,它的定义中可有一个多余的逗号。枚举常量的类型为int型,枚举变量为整型(基于实现),枚举变量的值在调试时可显示为枚举常量(比普通整型好)。

// head file
struct S;                       // declaration
void f(struct S* p);            // ok
void f(struct S s);             // illegal

struct S2;
struct S1 {
    struct S2 *ps2;             // ok
    struct S1 s1;               // illegal
} s1;                           // ok
struct S2 {struct S1 *ps1;};

struct S {
    char c;
    int a   : 20;
    int b   : 0;                // illegal
    int     : 0;                // end the word
} s1, s2;
s1 = s2;                        // not the same as memcpy

struct S {
    struct T {
        int m;
        struct {int n};         // anonymous
    };                          // anonymous
    int m, n;                   // name conflict
} s;
s.m + s.n;                      // ok

enum E;                         // illegal
enum E {ONE,};                  // ok
enum E e = ONE;

  函数和栈结构可以及时释放临时变量,提高内存利用率。函数可以递归调用(包括main),但会消耗更多的内存和时间。函数返回类型的修饰符会被忽略,只需有函数修饰符,函数不返回数组或函数。函数本地参数叫形参(parameter),调用者传递的值叫实参(argument),该定义同样适用于宏。参数列表由逗号隔开是来源于旧规范(见示例),其实分号做分隔符更好。函数参数格式上可以是数组或函数(提示作用),但它们等价于对应的指针形式,register是唯一可以使用的存储类型修饰符。C支持变长参数列表,仅需在最后一个参数后加三个点,之后不可再有参数定义。必须要有显式参数,用来获得变长参数列表的起始地址。标准库<stdarg.h>提供了使用变长参数的方法,但三个点本身不需要库支持。值得一提的是,变长参数列表只能由调用者自己清理(calling convention),而windows中默认是函数清理栈(__stdcall),需要使用__cdecl修饰符支持变长参数列表。函数原型(prototype)可协助进行编译时类型检查,仍支持旧规范中的空参数,它表示参数不确定(在定义中表示没有参数)。函数原型中的参数名可与定义中不同,甚至可以没有参数名。函数参数和函数体属于同一个block,注意名字冲突。

int main();                              // old C, not know parameter
int main()                               // old C, no parameter
{
    static s = 4;
    if (0 == s) return 0;
    else return main() + s--;            // ok
}

int fun(x, y) int x; int y; {return 1;}  // old C
void fun(int x, y);                      // illegal
void fun(int);                           // ok
void fun(register int m);                // ok
void fun (int a) {int a;}                // name conflict

const int f(int a[2]) {return 1;}        // the same as int f(int* a)
void g(int f(int*)) {}                   // the same as void g(int (*f)(int*))
int m = f((int[]){1, 2 ,3});             // ok
g(f);                                    // ok

void fun(...);                           // illegal
void fun(int, ..., int);                 // illegal
void fun(int, ...);                      // ok, no need <stdarg.h>
void __cdecl fun(int, ...);              // necessary in windows

  新规范中数组参数可以有更丰富的形式,array_specifier是数组参数方括号里的内容。本节的语法仍只是说明性的,非规范定义,除特别说明方括号表示可选。

array_specifier:
    [type_qulifier_list] [assignment_exp]
    static [type_qulifier_list] assignment_exp
    type_qulifier_list static assignment_exp
    [type_qulifier_list] *

    当然这里的数组是指第一维的,它会转换成指针,指针的类型限定符可以写到方括号里。这里的表达式(不可以是逗号表达式)一般没有实际意义,static修饰符被复用,用来提醒调用者数组长度至少为表达式的值。对高维数组的其它维,方括号里仅可以是表达式或星号,其中星号仅用于函数原型。

void f(int a[1, 2]);            // illegal
void f(int a[const 2]);         // the same as const int* a
void f(int a[const static 2]);  // ok
void f(int a[static const 2]);  // ok
void f(int a[static 2 const]);  // illegal
void f(int a[const *]);         // ok
void f(int a[*][*]);            // ok
void f(int n, int a[n][n]);     // ok
void f(int a[*][*]) {}          // illegal

  一般数组长度必须为常整型,const变量也不行。新规范中支持变长数组(VLA,variable length arrary),VLA定义时数组长度是整型表达式(非常数)。VLA只能在块域,它在每次定义时确定长度并分配空间,但一旦确定长度,在生命周期内不会改变。VLA和任何数组是类型兼容的,其指针可互相赋值。指向VLA的指针一般叫VM(variably modified),它也必须在块域并且无连接。VM可以是静态存储,而VLA则不可以,VM和VLA都不可以出现在结构或联合里。

int const n = 2;
int a[n];                 // illegal, static VLA
extern (*p)[n];           // illegal, linkage VM
int b[2];
struct S {
    int a[n];             // illegal, VLA in struct
    int (*p)[n];          // illegal, VM in struct
};

int main(void)
{
    int m = 2;
    int a[m++];           // ok, auto VLM
    sizeof(a);            // sizeof(int) * 2
    static int b[n];      // illegal, static VLA
    extern int b[n];      // illegal, linkage VLA
    extern (*p)[n];       // illegal, linkage VM
    static (*p)[n] = &b;  // ok, no linkage block VM
}

3. 复杂声明

declare:
    declare_specifier [init_declarator_list]

declare_specifier:
    storage_class_specifier [declare_specifier]
    alignment_specifier [declare_specifier]
    function_specifier [declare_specifier]
    type_qualifier [declare_specifier]
    type_specifier [declare_specifier]
    
init_declarator:
    declarator [= initializer]

storage_class_specifier:
    one of {typedef, extern, static, auto, register}

alignment_specifier:
    _Alignas(type or int_const)

function_specifier:
    one of {inline, _Noreturn}

type_qualifier:
    one of {const, volatile, restrict}

type_specifier:
    one of {void, char, short, int, long, float, double, signed, unsigned, _Bool, _Complex}
    struct_union_specifier
    enum_specifier
    typedef_name

    声明语句由声明修饰(declare_specifier)和声明列表(init_declarator_list)组成,其中声明列表用逗号作分割符。一个完整的声明可以粗略分为三个部分(非规范定义):属性、类型和扩展(非规范定义)。扩展部分包含附加操作、声明对象名和初始化,附加操作是对声明对象的类型补充(见下段)。属性包括存储类型(storage_class_specifier)、对齐(alignment_specifier)和函数性质(function_specifile),它们所修饰的是最终声明对象。声明中只能有一个存储类型,typedef在使用形式上与存储类型一致,所以也统一到该类中。类型包括类型限定(type_qualifier)和类型修饰(type_specifier),它们都可以看做是类型的一部分,所修饰的是整个扩展部分(非声明对象,也不互相修饰)。类型限定可以组合使用,类型修饰要么是定义中第一类的组合,要么是后三者之一(四类不可组合使用)。从定义中可以看出,所有属性和类型的的顺序是随意的,但建议按习惯的顺序使用。

typedef static int INT;                  // illegal, 2 storage_class_specifier
typedef int INT;                         // ok
const restrict int *p;                   // ok, 2 type_qualifier, all apply on *p, not p
const struct S {int i;} s1;
struct S s2;
s1.i = 1;                                // illegal, s1 is const
s2.i = 1;                                // ok, S is not const
unsigned INT a;                          // illegal, 2 type_specifier

static _Alignas(4) unsigned long int a;  // ok, good style
static int _Alignas(4) a;                // ok
int static a;                            // ok
int typedef INT;                         // ok
static int long unsigned a;              // ok
long static int unsigned a;              // ok
unsigned int long typedef UL;            // ok

  以下是扩展部分的附加操作和声明对象名语法,除[array_specifier]外方括号皆表示可选。

declarator:
    identifier
    (declarator)
    * [type_qualifier_list] declarator
    declarator[array_specifier]
    declarator(parameter_list)

  附加操作也是声明对象类型的一部分,包括指针、数组和函数。类型顺序和操作优先级一致,因为后缀操作有限级高,有时指针需要加括号。指针后面可以跟类型限定符,它同样与指针都是类型的一部分。扩展部分是可选的,但仅用于模板定义中。没有扩展时结构和联合必须有tag,枚举可以没有tag。

int *a[2];             // array of pointer
int (*a)[2];           // pointer to array
int f(void)[2];        // illegal, function return array
int *a[2](void);       // illegal, array of function
int (*a[2])(void);     // ok, array of function pointer
int (*f(void))(void);  // ok, function return function pointer

const int *p;          // *p is const
int *const p;          // p is const
int *const *pp;        // *pp is const
struct {int i;} s;     // ok
struct S {int i;};     // ok, define
struct {int i;};       // illegal, but ok as a member
enum {ONE};            // ok

  以下是结构和联合的定义语法。

struct_union_specifier
    struct_or_union [identifier] {struct_declare_list}
    struct_or_union identifier

struct_declare:
    type_specifier_qualifier_list [struct_declarator_list];

struct_declarator:
    declarator
    [declarator]: int_const

  不管是tag还是整个定义,结构(联合)都是作为类型使用的。成员不可以是函数或不完全类型,当然在花括号之前定义本身也不完全。成员只能用类型,不能有属性修饰符。成员可以用列表形式,但不能初始化。

int n = 2;
struct S {int i;} const static s1;  // ok
struct S {
    void f(void);                   // illegal, funtion member
    int a[];                        // illegal, incomplete type
    struct S s;                     // illegal, incomplete type
    int m = 0;                      // illegal, can‘t init
    const int a, *b;                // ok
    static _Alignas(4) int c;       // illegal
};

  在有些场合只需要类型而不需要实例,比如强制转换、复合常量、函数原型。大部分场合类型只需声明中的类型和附加操作两部分,需要找到原本声明对象所在的位置来确定最终类型。大部分情况可以根据优先级找到类型起点,当出现空的圆括号时当函数看待。

(int(*)[2])0;          // cast to pointer to array
(int*[]){NULL, NULL};  // pointer array literal
(int(*[])()){NULL};    // functon pointer array literal 
void f(int());         // convert to int(*)()
void f(int(*)[*]);     // VM

  对于复杂类型,最好使用typedef重命名类型,以使定义更清晰。typedef不可与其它属性一起使用,但可以包括类型限定符。它可以重命名不完全的结构(联合),但在完整定义前仅能用其指针,不可以重命名不完全的枚举。重命名的不完全数组,可在数组定义时确定数组长度,重命名的VLA和VM在每次使用时确定数组长度。typedef仅是重命名,不改变原有定义的性质。

void (*signal(int id, void(*hdl)(int)))(int);  // from <signal.h>
typedef void (*sig_t)(int);
sig_t signal(int num, sig_t hdl);              // much more clear

typedef static int si;                         // illegal
typedef _Alignas(4) int ai;                    // illegal
typedef const int ci;                          // ok
typedef struct S S;                            // ok
typedef enum E E;                              // illegal

typedef char Array[] ;                         // ok
Array a = {1}, b = {1, 2};                     // sizeof(a) = 1, sizeof(b) = 2
void f(void)
{
    int n = 1;
    typedef char VLA[n], (*VM)[n];             // ok
    n++;
    VLA vla;                                   // sizeof(vla) = 2
    VM vm = &vla;                              // ok
}

typedef int T;
struct S {
    T t        : 10;                           // signed or unsigned 
    unsigned T : 10;                           // unsigned member named T
    const T    : 10;                           // anonymous member
};

4. 初始化

initilizer:
    assignment_exp
    {initilizer_list}
    {initilizer_list,}

  初始化包含在变量定义中,它为对象提供初始值。初始化列表含有一对花括号,以及其中由逗号分隔的初始化项,每个初始化项可以是初始化列表,也可以是表达式。由于逗号已经用作分隔符,所以初始化表达式不能是逗号表达式,列表末尾的逗号无意义。如果对象是度量值或浮点数,花括号可省略。如果对象是复合类型,也可直接互相赋值。对字符串类型,可直接用字符串赋值(可带花括号)。

int a = 1, 2;                        // illegal
int a = {1};                         // the same as int a = 1
int a[] = {1, 2, };                  // only two members
struct S {int i} s1 = {1}, s2 = s1;  // ok
char str[] = "hi";                   // the same as {"hi"}
char str[2] = "hi";                  // ok, sizeif(str) = 2

  组合类型的初始化列表依次初始化成员,如遇到组合类型成员则同样初始化其每个成员。位域中的匿名成员不参加初始化,联合只初始化第一个成员,其它成员若有空隙则按比特置零。若列表不足,则剩余的成员按类型置零(整数为0、浮点数为0.0、指针为空指针)。长度不定的数组以初始化列表的长度为准,否则以数组长度为准,列表长度不可以超过数组长度(字符串除外)。

typedef struct S {int a[2]; int b:20; int :12; int c, d;} S;
typedef union U {char c; int i;} U;

S s = {1, 2, 3, 4};                   // s.a[0] = 1, s.a[1] = 2, s.b = 3, s.c = 4, s.d = rand
U u = {a, 1};                       // illegal
U u = {a};                          // u.c = ‘a‘, other bits to 0
char* strs[2] = {"hi"};               // strs[1] = NULL
char str[2] = {h, i, \0};       // illegal

  一对花括号对应一个当前对象,即使正在初始化成员的成员,当前对象仍然是花括号所对应的对象。对成员也可以使用初始化列表,这时的当前对象切换为该成员,一切规则以当前对象执行。当前成员切换出来时,从下一个成员继续执行。新规范还支持指定初始化(designated initilization),可以在初始化列表中指定具体成员(及其成员)初始化,此过程也进行当前对象切换,切换回来后从被指定成员(当前对象的)的下一个成员继续执行。当然指定初始化可能覆盖之前的初始化,也可改变当前成员。

typedef struct S {int a[2][2]; int b} S;

S s = {1, 2, 3, 4, 5};                       // cur_obj not change
S s = {{1, 2, 3,}, 4};                       // cur_obj s -> s.a -> s
S s = {{[0] = {1, 2}, [1][1] = 3}, .b = 4};  // ok
S s = {.a[0][0] = 1, 2};                     // b = 2, cur_obj s -> s.a[0][0] -> s
S s = {.a = {[0][0] = 1, 2}};                // a[1][0] = 2, cur_obj s ->s.a -> s.a[0][0] -> s.a -> s
S w[] = {{1}, 2};                            // w[0].a[0][0] = 1, w[1].[0][0] = 2, cur_obj w -> w[0] -> w

  静态存储的对象的值存储在可执行文件的数据区,需要编译时确定,所以只能用常数初始化,自动存储的对象无此限制。静态存储变量只在运行初被初始化一次,未显示初始化的也按类型置为0。可变长数组和结构尾部的可变数组不可以初始化。初始化列表从左向右执行,但其中没有序列点,可能有不确定行为。

typedef struct S {struct S *p;} S;
typedef struct V {int i; int a[]} V;
int  i = 1;

int a[2] = {i++, i++};                  // a[1] = 1 or 2
V v = {1, 2};                           // illegal
S s1, *ps = &s1;                        // ok, s1.p = NULL
S s2 = {ps};                            // illegal
void f(void)
{
    static S s3 = {&s3};                // ok, only once
    S s4 = {ps};                        // ok
    int a[i] = {1};                     // illegal
}

【C】 05 - 声明和定义

标签:c语言   声明定义   

原文地址:http://blog.csdn.net/edward_bian/article/details/45127531

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!