标签:des style blog color 使用 io strong ar 文件
仅从形式上看,C程序就是由各种声明和定义组成的。它们是程序的骨架和外表,不仅定义了数据(变量),还定义了行为(函数)。规范中的纯语言部分,声明和定义亦花去了最多的篇幅。完全说清定义的语法比较困难,这里也只是个人的理解。
对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(); }
首先说明一下,规范中的“声明”包括了定义,下文中一般名词性的“声明”包含定义,其它都是我们常用的单纯“声明”。
结构(联合)的定义一般叫模板,结构、联合和枚举的类型名叫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 }
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 };
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 }
标签:des style blog color 使用 io strong ar 文件
原文地址:http://www.cnblogs.com/edward-bian/p/3870683.html