标识（Identifiers）
有效标识由字母(letter)，数字(digits)和下划线 ( _ )组成。标识的长度没有限制，但是有些编译器只取前32个字符（剩下的字符会被忽略）。
空格(spaces)，标点(punctuation marks)和符号(symbols) 都不可以出现在标识中。 只有字母(letters)，数字(digits) 和下划线(_)是合法的。并且变量标识必须以字母开头。标识也可能以下划线（_）开头，但这种标识通常是保留给为外部连接用的。标识不可以以数字开头。
必须注意的另一条规则是当你给变量起名字时不可以和C++语言的关键字或你所使用的编译器的特殊关键字同名，因为这样与这些关键字产生混淆。例如，以下列出标准保留关键字，他们不允许被用作变量标识名称：
asm, auto, bool, break, case, catch, char, class, const, const_cast, continue, default, delete, do, double, dynamic_cast, else, enum, explicit, extern, false, float, for, friend, goto, if, inline, int, long, mutable, namespace, new, operator,
private, protected, public, register, reinterpret_cast, return, short, signed, sizeof, static, static_cast, struct, switch, template, this, throw, true, try, typedef, typeid, typename, union, unsigned, using, virtual, void, volatile, wchar_t, while
变量初始化（Initialization of variables）
当一个本地变量( local variable)被声明时，它的值默认为未定(undetermined)。但你可能希望在声明变量的同时赋给它一个具体的值。要想达到这个目的，需要对变量进行初始化。C++中有两种初始化方法：
第一种，又叫做类C (c-like) 方法，是在声明变量的时候加上一个等于号，并在后面跟上想要的数值：
type identifier = initial_value ;
例如，如果我们想声明一个叫做a的int变量并同时赋予它0这个值，我们可以这样写：
int a = 0;
另外一种变量初始化的方法，又叫做构造函数(constructor)初始化， 是将初始值用小括号（parenthesis ()）括起来:
type identifier (initial_value) ;
例如：
int a (0);
数学运算符Arithmetic operators ( +, -, *, /, % )
C++语言支持的5种数学运算符为：
- + 加addition
- - 减subtraction
- * 乘multiplication
- / 除division
- % 取模module
加减乘除运算想必大家都很了解，它们和一般的数学运算符没有区别。
唯一你可能不太熟悉的是用百分号(%)表示的取模运算（module）。取模运算是取两个整数相除的余数。例如，如果我们写a = 11 % 3;，变量a的值将会为结果2，因为2是11除以3的余数。
参数按数值传递和按地址传递(Arguments passed by value and by reference)
到目前为止，我们看到的所有函数中，传递到函数中的参数全部是按数值传递的(by value)。也就是说，当我们调用一个带有参数的函数时，我们传递到函数中的是变量的数值而不是变量本身。 例如，假设我们用下面的代码调用我们的第一个函数addition ：
int x=5, y=3, z;
z = addition ( x , y );
在这个例子里我们调用函数addition 同时将x和y的值传给它，即分别为5和3，而不是两个变量：
这样，当函数addition被调用时，它的变量a和b的值分别变为5和3，但在函数addition内对变量a 或b 所做的任何修改不会影响变量他外面的变量x 和 y 的值，因为变量x和y并没有把它们自己传递给函数，而只是传递了他们的数值。
但在某些情况下你可能需要在一个函数内控制一个函数以外的变量。要实现这种操作，我们必须使用按地址传递的参数（arguments passed by reference），就象下面例子中的函数duplicate：
| // passing parameters by reference
#include <iostream.h> void duplicate (int& a, int& b, int& c) { a*=2; b*=2; c*=2; } int main () { int x=1, y=3, z=7; duplicate (x, y, z); cout << "x=" << x << ", y=" << y << ", z=" << z; return 0; } |
x=2, y=6, z=14 |
第一个应该注意的事项是在函数duplicate的声明(declaration)中，每一个变量的类型后面跟了一个地址符ampersand sign (&)，它的作用是指明变量是按地址传递的（by reference），而不是像通常一样按数值传递的（by value）。
当按地址传递（pass by reference）一个变量的时候，我们是在传递这个变量本身，我们在函数中对变量所做的任何修改将会影响到函数外面被传递的变量。
用另一种方式来说，我们已经把变量a, b，c和调用函数时使用的参数(x, y和
z)联系起来了，因此如果我们在函数内对a 进行操作，函数外面的x 值也会改变。同样，任何对b 的改变也会影响y，对c 的改变也会影响z>。
这就是为什么上面的程序中，主程序main中的三个变量x, y和z在调用函数duplicate 后打印结果显示他们的值增加了一倍。
如果在声明下面的函数：
void duplicate (int& a, int& b, int& c)
时，我们是按这样声明的：
void duplicate (int a, int b, int c)
也就是不写地址符 ampersand (&)，我们也就没有将参数的地址传递给函数，而是传递了它们的值，因此，屏幕上显示的输出结果x, y ，z 的值将不会改变，仍是1，3，7。
这种用地址符 ampersand (&)来声明按地址"by reference"传递参数的方式只是在C++中适用。在C 语言中，我们必须用指针(pointers)来做相同的操作。
按地址传递(Passing by reference)是一个使函数返回多个值的有效方法。例如，下面是一个函数，它可以返回第一个输入参数的前一个和后一个数值。
| // more than one returning value
#include <iostream.h> void prevnext (int x, int& prev, int& next) { prev = x-1; next = x+1; } int main () { int x=100, y, z; prevnext (x, y, z); cout << "Previous=" << y << ", Next=" << z; return 0; } |
Previous=99, Next=101 |
参数的默认值(Default values in arguments)
当声明一个函数的时候我们可以给每一个参数指定一个默认值。如果当函数被调用时没有给出该参数的值，那么这个默认值将被使用。指定参数默认值只需要在函数声明时把一个数值赋给参数。如果函数被调用时没有数值传递给该参数，那么默认值将被使用。但如果有指定的数值传递给参数，那么默认值将被指定的数值取代。例如：
| // default values in functions
#include <iostream.h> int divide (int a, int b=2) { int r; r=a/b; return (r); } int main () { cout << divide (12); cout << endl; cout << divide (20,4); return 0; } |
6
5 |
我们可以看到在程序中有两次调用函数divide。第一次调用：
divide (12)
只有一个参数被指明，但函数divide允许有两个参数。因此函数divide 假设第二个参数的值为2，因为我们已经定义了它为该参数缺省的默认值(注意函数声明中的int b=2)。因此这次函数调用的结果是
6 (12/2)。
在第二次调用中：
divide (20,4)
这里有两个参数，所以默认值 (int b=2) 被传入的参数值4所取代，使得最后结果为 5 (20/4).
函数重载(Overloaded functions)
两个不同的函数可以用同样的名字，只要它们的参量(arguments)的原型(prototype)不同，也就是说你可以把同一个名字给多个函数，如果它们用不同数量的参数，或不同类型的参数。例如：
| // overloaded function
#include <iostream.h> int divide (int a, int b) { return (a/b); } float divide (float a, float b) { return (a/b); } int main () { int x=5,y=2; float n=5.0,m=2.0; cout << divide (x,y); cout << "\n"; cout << divide (n,m); cout << "\n"; return 0; } |
2
2.5 |
在这个例子里，我们用同一个名字定义了两个不同函数，当它们其中一个接受两个整型(int)参数，另一个则接受两个浮点型(float)参数。编译器 (compiler)通过检查传入的参数的类型来确定是哪一个函数被调用。如果调用传入的是两个整数参数，那么是原型定义中有两个整型(int)参量的函数被调用，如果传入的是两个浮点数，那么是原型定义中有两个浮点型(float)参量的函数被调用。
为了简单起见，这里我们用的两个函数的代码相同，但这并不是必须的。你可以让两个函数用同一个名字同时完成完全不同的操作。
Inline 函数（inline functions）
inline 指令可以被放在函数声明之前，要求该函数必须在被调用的地方以代码形式被编译。这相当于一个宏定义(macro)。它的好处只对短小的函数有效，这种情况下因为避免了调用函数的一些常规操作的时间(overhead)，如参数堆栈操作的时间，所以编译结果的运行代码会更快一些。
它的声明形式是：
inline type name ( arguments ... ) { instructions ... }
它的调用和其他的函数调用一样。调用函数的时候并不需要写关键字inline ，只有在函数声明前需要写。
递归（Recursivity）
递归(recursivity)指函数将被自己调用的特点。它对排序(sorting)和阶乘(factorial)运算很有用。例如要获得一个数字n的阶乘，它的数学公式是：
n! = n * (n-1) * (n-2) * (n-3) ... * 1
更具体一些，5! (factorial of 5) 是：
5! = 5 * 4 * 3 * 2 * 1 = 120
而用一个递归函数来实现这个运算将如以下代码：
| // factorial calculator
#include <iostream.h> long factorial (long a){ if (a > 1) return (a * factorial (a-1)); else return (1); } int main () { long l; cout << "Type a number: "; cin >> l; cout << "!" << l << " = " << factorial (l); return 0; } |
Type a number: 9
!9 = 362880 |
注意我们在函数factorial中是怎样调用它自己的，但只是在参数值大于1的时候才做调用，因为否则函数会进入死循环(an infinite recursive loop)，当参数到达0的时候，函数不继续用负数乘下去(最终可能导致运行时的堆栈溢出错误(stack overflow error)。
这个函数有一定的局限性，为简单起见，函数设计中使用的数据类型为长整型(long)。在实际的标准系统中，长整型long无法存储12！以上的阶乘值。
函数的声明（Declaring functions）
到目前为止，我们定义的所有函数都是在它们第一次被调用（通常是在main中）之前，而把main 函数放在最后。如果重复以上几个例子，但把main 函数放在其它被它调用的函数之前，你就会遇到编译错误。原因是在调用一个函数之前，函数必须已经被定义了，就像我们前面例子中所做的。
但实际上还有一种方法来避免在main 或其它函数之前写出所有被他们调用的函数的代码，那就是在使用前先声明函数的原型定义。声明函数就是对函数在的完整定义之前做一个短小重要的声明，以便让编译器知道函数的参数和返回值类型。
它的形式是：
type name ( argument_type1, argument_type2, ...);
它与一个函数的头定义（header definition）一样，除了：
- 它不包括函数的内容， 也就是它不包括函数后面花括号{}内的所有语句。
- 它以一个分号semicolon sign (;) 结束。
- 在参数列举中只需要写出各个参数的数据类型就够了，至于每个参数的名字可以写，也可以不写，但是我们建议写上。
例如：
| // 声明函数原型
#include <iostream.h> void odd (int a); void even (int a); int main () { int i; do { cout << "Type a number: (0 to exit)"; cin >> i; odd (i); } while (i!=0); return 0; } void odd (int a) { if ((a%2)!=0) cout << "Number is odd.\n"; else even (a); } void even (int a) { if ((a%2)==0) cout << "Number is even.\n"; else odd (a); } |
Type a number (0 to exit): 9
Number is odd. Type a number (0 to exit): 6 Number is even. Type a number (0 to exit): 1030 Number is even. Type a number (0 to exit): 0 Number is even. |
这个例子的确不是很有效率，我相信现在你已经可以只用一半行数的代码来完成同样的功能。但这个例子显示了函数原型（prototyping functions）是怎样工作的。并且在这个具体的例子中，两个函数中至少有一个是必须定义原型的。
这里我们首先看到的是函数odd 和even的原型：
void odd (int a);
void even (int a);
这样使得这两个函数可以在它们被完整定义之前就被使用，例如在main中被调用，这样main就可以被放在逻辑上更合理的位置：即程序代码的开头部分。
尽管如此，这个程序需要至少一个函数原型定义的特殊原因是因为在odd 函数里需要调用even 函数，而在even 函数里也同样需要调用odd函数。如果两个函数任何一个都没被提前定义原型的话，就会出现编译错误，因为或者odd 在even 函数中是不可见的(因为它还没有被定义)，或者even 函数在odd函数中是不可见的。
很多程序员建议给所有的函数定义原型。这也是我的建议，特别是在有很多函数或函数很长的情况下。把所有函数的原型定义放在一个地方，可以使我们在决定怎样调用这些函数的时候轻松一些，同时也有助于生成头文件。
常给数组赋值，或更具体些，给字符序列赋值的方法是使用一些函数，例如strcpy。strcpy (string copy) 在函数库cstring (string.h) 中被定义，可以用以下方式被调用：strcpy (string1, string2);
这个函数将string2 中的内容拷贝给string1。string2 可以是一个数组，一个指针，或一个字符串常量constant string。因此用下面的代码可以将字符串常量"Hello"赋给mystring：
strcpy (mystring, "Hello");
另一个给数组赋值的常用方法是直接使用输入流(cin)。在这种情况下，字符序列的值是在程序运行时由用户输入的。
当cin 被用来输入字符序列值时，它通常与函数getline 一起使用，方法如下：
cin.getline ( char buffer[], int length, char delimiter = ‘ \n‘);
这里buffer 是用来存储输入的地址（例如一个数组名），length 是一个缓存buffer 的最大容量，而delimiter 是用来判断用户输入结束的字符，它的默认值（如果我们不写这个参数时）是换行符newline character (‘\n‘)。
下面的例子重复输出用户在键盘上的任何输入。这个例子简单的显示了如何使用cin.getline来输入字符串：
| // cin with strings
#include <iostream.h> int main () { char mybuffer [100]; cout << "What‘s your name? "; cin.getline (mybuffer,100); cout << "Hello " << mybuffer << ".\n"; cout << "Which is your favourite team? "; cin.getline (mybuffer,100); cout << "I like " << mybuffer << " too.\n"; return 0; } |
What‘s your name? Juan
Hello Juan. Which is your favourite team? Inter Milan I like Inter Milan too. |
注意上面例子中两次调用cin.getline 时我们都使用了同一个字符串标识 (mybuffer)。程序在第二次调用时将新输入的内容直接覆盖到第一次输入到buffer 中的内容。
你可能还记得，在以前与控制台(console)交互的程序中，我们使用extraction operator (>>) 来直接从标准输入设备接收数据。这个方法也同样可以被用来输入字符串，例如，在上面的例子中我们也可以用以下代码来读取用户输入：
cin >> mybuffer;
这种方法也可以工作，但它有以下局限性是cin.getline所没有的：
- 它只能接收单独的词(而不能是完整的句子)，因为这种方法以任何空白符为分隔符，包括空格spaces，跳跃符tabulators，换行符newlines和回车符arriage returns。
- 它不能给buffer指定容量，这使得程序不稳定，如果用户输入超出数组长度，输入信息会被丢失。
因此，建议在需要用cin来输入字符串时，使用cin.getline来代替cin >>。
字符串和其它数据类型的转换(Converting strings to other types)
鉴于字符串可能包含其他数据类型的内容，例如数字，将字符串内容转换成数字型变量的功能会有用处。例如一个字符串的内容可能是"1977"，但这一个5个字符组成序列，并不容易转换为一个单独的整数。因此，函数库cstdlib (stdlib.h) 提供了3个有用的函数：
- atoi: 将字符串string 转换为整型int
- atol: 将字符串string 转换为长整型long
- atof: 将字符串string 转换为浮点型float
字符串操作函数(Functions to manipulate strings)
函数库cstring (string.h) 定义了许多可以像C语言类似的处理字符串的函数 (如前面已经解释过的函数strcpy)。这里再简单列举一些最常用的：
strcat: char* strcat (char* dest, const char* src);
//将字符串src 附加到字符串dest 的末尾，返回dest。strcmp: int strcmp (const char* string1, const char* string2);
//比较两个字符串string1 和string2。如果两个字符串相等，返回0。strcpy: char* strcpy (char* dest, const char* src);
//将字符串src 的内容拷贝给dest，返回dest 。strlen: size_t strlen (const char* string);
//返回字符串的长度。
注意：char* 与char[] 相同。
3.3 指针 （Pointers）
地址或反引用操作符Operator of address or dereference (&)
它被用作一个变量前缀，可以被翻译为“…的地址”("address of")，因此：&variable1 可以被读作 variable1的地址("address of variable1" )。
引用操作符Operator of reference (*)
它表示要取的是表达式所表示的地址指向的内容。它可以被翻译为“…指向的数值” ("value pointed by")。
* mypointer 可以被读作 "mypointer指向的数值"。
指针和数组Pointers and arrays
数组的概念与指针的概念联系非常解密。其实数组的标识相当于它的第一个元素的地址，就像一个指针相当于它所指向的第一个元素的地址，因此其实它们是同一个东西。例如，假设我们有以下声明：
int numbers [20];
int * p;
下面的赋值为合法的：
p = numbers;
这里指针p 和numbers 是等价的，它们有相同的属性，唯一的不同是我们可以给指针p赋其它的数值，而numbers 总是指向被定义的20个整数组中的第一个。所以，p只是一个普通的指针变量，而与之不同，numbers 是一个指针常量(constant pointer)，数组名的确是一个指针常量。因此虽然前面的赋值表达式是合法的，但下面的不是：
numbers = p;
因为numbers 是一个数组(指针常量)，常量标识不可以被赋其它数值。
在定义数组指针的时候，编译器允许我们在声明变量指针的同时对数组进行初始化，初始化的内容需要是常量，例如：
char * terry = "hello";
函数指针Pointers to functions
C++ 允许对指向函数的指针进行操作。它最大的作用是把一个函数作为参数传递给另外一个函数。声明一个函数指针像声明一个函数原型一样，除了函数的名字需要被括在括号内并在前面加星号asterisk (*)。例如：
| // pointer to functions
#include <iostream.h> int addition (int a, int b) { return (a+b); } int subtraction (int a, int b) { return (a-b); } int (*minus)(int,int) = subtraction; int operation (int x, int y, int (*functocall)(int,int)) { int g; g = (*functocall)(x,y); return (g); } int main () { int m,n; m = operation (7, 5, addition); n = operation (20, m, minus); cout <<n; return 0; } |
8 |
在这个例子里， minus 是一个全局指针，指向一个有两个整型参数的函数，它被赋值指向函数subtraction，所有这些由一行代码实现：
int (* minus)(int,int) = subtraction;
这里似乎解释的不太清楚，有问题问为什么(int int)只有类型，没有参数，就再多说两句。
这里 int (*minus)(int int)实际是在定义一个指针变量，这个指针的名字叫做minus，这个指针的类型是指向一个函数，函数的类型是有两个整型参数并返回一个整型值。
整句话“int (*minus)(int,int) = subtraction;”是定义了这样一个指针并把函数subtraction的值赋给它，也就是说有了这个定义后minus就代表了函数subtraction。因此括号中的两个int int实际只是一种变量类型的声明，也就是说是一种形式参数而不是实际参数。
3.4 动态内存分配 （Dynamic memory）
操作符new 和new[ ]
操作符new的存在是为了要求动态内存。new 后面跟一个数据类型，并跟一对可选的方括号[ ]里面为要求的元素数。它返回一个指向内存块开始位置的指针。其形式为：
pointer = new type
或者
pointer = new type [elements]
第一个表达式用来给一个单元素的数据类型分配内存。第二个表达式用来给一个数组分配内存。
例如：
int * bobby;
bobby = new int [5];
删除操作符delete
既然动态分配的内存只是在程序运行的某一具体阶段才有用，那么一旦它不再被需要时就应该被释放，以便给后面的内存申请使用。操作符delete 因此而产生，它的形式是：
delete pointer;
或
delete [ ] pointer;
第一种表达形式用来删除给单个元素分配的内存，第二种表达形式用来删除多元素（数组）的内存分配。在多数编译器中两种表达式等价，使用没有区别， 虽然它们实际上是两种不同的操作，需要考虑操作符重载
ANSI-C 中的动态内存管理Dynamic memory in ANSI-C
操作符new 和delete 仅在C++中有效，而在C语言中没有。在C语言中，为了动态分配内存，我们必须求助于函数库stdlib.h。因为该函数库在C++中仍然有效，并且在一些现存的程序仍然使用，所以我们下面将学习一些关于这个函数库中的函数用法。
函数malloc
这是给指针动态分配内存的通用函数。它的原型是：
void * malloc (size_t nbytes);
其中nbytes 是我们想要给指针分配的内存字节数。这个函数返回一个void*类型的指针，因此我们需要用类型转换(type cast)来把它转换成目标指针所需要的数据类型，例如：
char * ronny;
ronny = (char *) malloc (10);
这个例子将一个指向10个字节可用空间的指针赋给ronny。当我们想给一组除char 以外的类型（不是1字节长度的）的数值分配内存的时候，我们需要用元素数乘以每个元素的长度来确定所需内存的大小。幸运的是我们有操作符sizeof，它可以返回一个具体数据类型的长度。
int * bobby;
bobby = (int *) malloc (5 * sizeof(int));
这一小段代码将一个指向可存储5个int型整数的内存块的指针赋给bobby，它的实际长度可能是 2，4或更多字节数，取决于程序是在什么操作系统下被编译的。
函数calloc
calloc 与malloc 在操作上非常相似，他们主要的区别是在原型上：
void * calloc (size_t nelements, size_t size);
因为它接收2个参数而不是1个。这两个参数相乘被用来计算所需内存块的总长度。通常第一个参数(nelements)是元素的个数，第二个参数 (size) 被用来表示每个元素的长度。例如，我们可以像下面这样用calloc定义bobby：
int * bobby;
bobby = (int *) calloc (5, sizeof(int));
malloc 和calloc的另一点不同在于calloc 会将所有的元素初始化为0。
函数realloc
它被用来改变已经被分配给一个指针的内存的长度。
void * realloc (void * pointer, size_t size);
参数pointer 用来传递一个已经被分配内存的指针或一个空指针，而参数size 用来指明新的内存长度。这个函数给指针分配size 字节的内存。这个函数可能需要改变内存块的地址以便能够分配足够的内存来满足新的长度要求。在这种情况下，指针当前所指的内存中的数据内容将会被拷贝到新的地址中，以保证现存数据不会丢失。函数返回新的指针地址。如果新的内存尺寸不能够被满足，函数将会返回一个空指针，但原来参数中的指针pointer 及其内容保持不变。
函数 free
这个函数用来释放被前面malloc, calloc 或realloc所分配的内存块。
void free (void * pointer);
数据结构 （Data Structures）
一个数据结构是组合到同一定义下的一组不同类型的数据，各个数据类型的长度可能不同。它的形式是：
struct model_name {
type1 element1;
type2 element2;
type3 element3;
.
.
} object_name;
结构指针(Pointers to structures)
就像其它数据类型一样，结构也可以有指针。其规则同其它基本数据类型一样：指针必须被声明为一个指向结构的指针：
struct movies_t {
char title [50];
int year;
};
movies_t amovie;
movies_t * pmovie;
这里 amovie 是一个结构类型movies_t 的对象，而pmovie 是一个指向结构类型movies_t 的对象的指针。所以，同基本数据类型一样，以下表达式正确的：
pmovie = &amovie;
下面让我们看另一个例子，它将引入一种新的操作符：
| // pointers to structures
#include ?iostream.h? #include ?stdlib.h? struct movies_t { char title [50]; int year; }; int main () { char buffer[50]; movies_t amovie; movies_t * pmovie; pmovie = & amovie; cout << "Enter title: "; cin.getline (pmovie->title,50); cout << "Enter year: "; cin.getline (buffer,50); pmovie->year = atoi (buffer); cout << "\nYou have entered:\n"; cout << pmovie->title; cout << " (" << pmovie->year << ")\n"; return 0; } |
Enter title: Matrix
Enter year: 1999 You have entered: Matrix (1999) |
上面的代码中引入了一个重要的操作符：->。这是一个引用操作符，常与结构或类的指针一起使用，以便引用其中的成员元素，这样就避免使用很多括号。例如，我们用：
pmovie->title
来代替：
(*pmovie).title
以上两种表达式pmovie->title 和 (*pmovie).title 都是合法的，都表示取指针pmovie 所指向的结构其元素title 的值。我们要清楚将它和以下表达区分开：
*pmovie.title
它相当于
*(pmovie.title)
表示取结构pmovie 的元素title 作为指针所指向的值，这个表达式在本例中没有意义，因为title本身不是指针类型。
下表中总结了指针和结构组成的各种可能的组合：
| 表达式 | 描述 | 等价于 |
|---|---|---|
| pmovie.title | 结构pmovie 的元素title | |
| pmovie->title | 指针pmovie 所指向的结构其元素title 的值 | (*pmovie).title |
| *pmovie.title | 结构pmovie 的元素title 作为指针所指向的值 | *(pmovie.title) |
自定义数据类型 （User defined data types）
定义自己的数据类型 (typedef)
C++ 允许我们在现有数据类型的基础上定义我们自己的数据类型。我们将用关键字typedef来实现这种定义，它的形式是：
typedef existing_type new_type_name;
这里 existing_type 是C++ 基本数据类型或其它已经被定义了的数据类型，new_type_name 是我们将要定义的新数据类型的名称。例如：
typedef char C;
typedef unsigned int WORD;
typedef char * string_t;
typedef char field [50];
联合(Union)
联合(Union) 使得同一段内存可以被按照不同的数据类型来访问，数据实际是存储在同一个位置的。它的声明和使用看起来与结构(structure)十分相似，但实际功能是完全不同的：
union model_name {
type1 element1;
type2 element2;
type3 element3;
.
.
} object_name;
union 中的所有被声明的元素占据同一段内存空间，其大小取声明中最长的元素的大小。例如：
union mytypes_t {
char c;
int i;
float f;
} mytypes;
定义了3个元素：
mytypes.c
mytypes.i
mytypes.f
每一个是一种不同的数据类型。既然它们都指向同一段内存空间，改变其中一个元素的值，将会影响所有其他元素的值。
枚举Enumerations (enum)
枚举(Enumerations)可以用来生成一些任意类型的数据，不只限于数字类型或字符类型，甚至常量true 和false。它的定义形式如下：
enum model_name {
value1,
value2,
value3,
.
.
} object_name;
例如，我们可以定义一种新的变量类型叫做color_t 来存储不同的颜色：
enum colors_t {black, blue, green, cyan, red, purple, yellow, white};
注意在这个定义里我们没有使用任何基本数据类型。换句话说，我们创造了一种的新的数据类型，而它并没有基于任何已存在的数据类型：类型color_t，花括号{}中包括了它的所有的可能取值。例如，在定义了colors_t 列举类型后，我们可以使用以下表达式 ：
colors_t mycolor;
mycolor = blue;
if (mycolor == green) mycolor = red;
实际上，我们的枚举数据类型在编译时是被编译为整型数值的，而它的数值列表可以是任何指定的整型常量 。如果没有指定常量，枚举中第一个列出的可能值为0 ，后面的每一个值为前面一个值加1。因此，在我们前面定义的数据类型colors_t 中，black 相当于0， blue 相当于 1， green 相当于2 ，后面依此类推。