1. 声明与初始化

1.1 我应该如何选择要使用的整数类型？

1.2 为什么标准类型的尺寸没有被精确定义？

1.3 C 没有精确定义尺寸，所以我一直使用这样的 typedef：int16和int32这样的 typedef。我可以根据我使用的机器，将这些 typedef 定义为int, short, long等等。这样应该可以解决所有问题，对吧？

1.4 在一个可以支持它的机器上，64 位类型应该是多少？

1.5 这个声明有什么问题？

char* p1, p2;

1.6 我正在尝试声明一个指针并为其分配一些空间，但它不起作用。这段代码有什么问题？

char *p;
*p = malloc(10);

1.7 声明和定义全局变量和函数有什么最佳方法？

1.8 如何在 C 中实现不透明（抽象）数据类型？

1.9 如何创建一个“半全局”变量，即一个对分散在多个源文件中的几个函数私有的变量？

1.10 同一个声明的所有...静态函数或变量的所有声明是否都必须包含存储类别？静态?

1.11 ...是什么意思？extern是什么意思？

1.12 ...是什么？auto关键字有什么用？

1.13 使用 ... 和 ... 有什么区别？typedef和#define定义用户自定义类型有什么区别？

1.14 我似乎无法成功定义一个链表。我试过

	typedef struct {
		char *item;
		NODEPTR next;
	} *NODEPTR;

1.15 如何定义一对相互引用的结构？我试过

	typedef struct {
		int afield;
		BPTR bpointer;
	} *APTR;

	typedef struct {
		int bfield;
		APTR apointer;
	} *BPTR;

1.16 这两个声明有什么区别？

	struct x1 { ... };
	typedef struct { ... } x2;

1.17 ...是什么意思？

typedef int (*funcptr)();

1.18 我有声明

	typedef char *charp;
	const charp p;

1.19 我不明白为什么我不能使用const值，例如

	const int n = 5;
	int a[n];

1.20 ...和...有什么区别？const char *p, char const *p，而char * const p?

1.20b

函数参数const是什么意思？这两个const在

	int f(const * const p)

1.21 如何构造复杂类型的声明，例如“指向返回指向返回指向char的指针的 N 个指针的数组”，或者如何理解类似复杂的声明？

1.22 一个函数如何能返回一个指向同类型函数的指针？我正在构建一个状态机，每个状态都有一个函数，每个函数都返回指向下一个状态的函数的指针。但我找不到声明函数的方法——我似乎需要一个返回指向函数指针的函数，该函数指针又返回一个函数指针...无穷无尽。

1.23 能否声明一个局部数组（或参数数组），其大小与传入的数组匹配，或由另一个参数设置？

1.24 我有一个extern数组定义在一个文件中，并在另一个文件中使用

file1.c:			file2.c:

int array[] = {1, 2, 3};	extern int array[];

1.25 我的编译器抱怨函数重声明无效，但我只定义和调用它一次。

1.25b ...的正确声明是什么？main?
是void main()正确的吗？

1.26 我的编译器抱怨函数原型不匹配，但它们在我看来是好的。

1.27 我在文件的第一个声明中出现了一些奇怪的语法错误，但它看起来是正确的。

1.28 我的编译器不允许我声明一个像这样的数组

double array[256][256];

1.29 如何确定哪些标识符可以安全使用，哪些是保留的？

1.30 对于未显式初始化的变量和数组，我被允许假设它们的初始值是什么？
如果全局变量最初为“零”，这对空指针和浮点零是否足够好？

1.31 这段直接来自书籍的代码无法编译

int f()
{
	char a[] = "Hello, world!";
}

1.31b 此初始化有什么问题？

char *p = malloc(10);

1.32 这些初始化之间有什么区别？

char a[] = "string literal";
char *p  = "string literal";

1.33 是char a[3] = "abc";合法的？

1.34 我终于弄明白了声明函数指针的语法，但现在如何初始化它？

1.35 可以初始化联合体吗？

2. 结构、联合和枚举

2.1 这两个声明有什么区别？

	struct x1 { ... };
	typedef struct { ... } x2;

2.2 为什么不...

struct x { ... };
x thestruct;

2.3 结构可以包含指向自身的指针吗？

2.4 如何在 C 中实现不透明（抽象）数据类型？

2.4b 有没有模拟 OOP 风格继承或其他 OOP 特征的好方法？

2.5 为什么声明

extern int f(struct x *p);

2.6 我看到一些代码声明结构像这样

struct name {
	int namelen;
	char namestr[1];
};

2.7 我听说结构可以赋值给变量并作为参数传递给函数，但 K&R1 说不行。

2.8 有办法自动比较结构吗？

2.9 结构传递和返回是如何实现的？

2.10 如何将常量值传递给接受结构参数的函数？如何创建无名、即时、常量结构值？

2.11 如何从数据文件中读取/写入结构？

2.12 为什么我的编译器会在结构中留空，浪费空间并阻止“二进制” I/O 到外部数据文件？我能否关闭此功能，或以其他方式控制结构字段的对齐？

2.13 为什么...sizeof报告的大小比我预期的结构类型要大，好像在末尾有填充？

2.14 如何确定字段在结构中的字节偏移量？

2.15 如何在运行时按名称访问结构字段？

2.16 C 是否有等同于 Pascal 的with语句吗？

2.17 如果数组名像数组基址的指针一样，为什么结构不是如此？

2.18 这个程序运行正常，但在结束时会核心转储。为什么？

	struct list {
		char *item;
		struct list *next;
	}

	/* Here is the main program. */

	main(argc, argv)
	{ ... }

2.19 结构和联合体之间有什么区别？

2.20 可以初始化联合体吗？

2.21 有没有自动跟踪联合体哪个字段正在使用的方法？

2.22 枚举和一组预处理器宏有什么区别？#define有什么区别？

2.23 枚举真的可以移植吗？
它们不像 Pascal 吗？

2.24 有没有简单的方法以符号方式打印枚举值？

2.25 我看到一些结构声明，字段旁边有冒号和数字，像这样

struct record {
	char *name;
	int refcount : 4;
	unsigned dirty : 1;
};

2.26 人们为什么如此频繁地使用显式掩码和位操作代码，而不是声明位字段？

3. 表达式

3.1 为什么这段代码不...

a[i] = i++;

3.2 在我的编译器下，这段代码

int i = 7;
printf("%d\n", i++ * i++);

3.3 我实验过代码

int i = 3;
i = i++;

3.3b 这是一个很棒的表达式

a ^= b ^= a ^= b

3.4 能否使用显式括号来强制我想要的求值顺序，并控制这些副作用？即使我不这样做，优先级不是也决定了它吗？

3.5 但是关于...&&和||我看到像“
while((c = getchar()) != EOF && c != '\n')这样的代码'' ...

3.6 ...的右侧是否可以安全地假定？&&和||运算符？

3.7 为什么...

printf("%d %d", f1(), f2());

3.8 如何理解像本节中的复杂表达式，并避免编写未定义的表达式？什么是“序列点”？

3.9 那么，如果我写

a[i] = i++;

3.10a 人们一直在说，...的行为i = i++的行为是未定义的，但我刚刚在一个符合 ANSI 标准的编译器上尝试了它，并得到了我预期的结果。

3.10b 人们告诉我，如果我评估了一个未定义的表达式，或者访问了一个未初始化的变量，我会得到一个随机的、垃圾值。但我试过了，得到了零。这是怎么回事？

3.11 如果我不想学习复杂的规则，我该如何避免这些未定义的求值顺序问题？

3.12a ...和...有什么区别？++i和i++?

3.12b 如果我不使用表达式的值，我应该使用++i或i++来递增变量吗？

3.13 我需要检查一个数字是否在另外两个数字之间。为什么不...

if(a < b < c)

3.14 为什么这段代码不...

int a = 1000, b = 1000;
long int c = a * b;

3.14b 如何确保整数算术不会溢出？

3.15 为什么代码...

double degC, degF;
degC = 5 / 9 * (degF - 32);

3.16 我有一个复杂的表达式，我必须根据条件将其分配给两个变量中的一个。我可以使用这样的代码吗？

	((condition) ? a : b) = complicated_expression;

3.17 我有一些代码包含像...这样的表达式

a ? b = c : d

3.18 警告“...的语义”是什么意思？>`

3.19 “无符号保留”和“值保留”规则之间有什么区别？

4. 指针

4.1 指针到底有什么用？

4.2 我正在尝试声明一个指针并为其分配一些空间，但它不起作用。这段代码有什么问题？

char *p;
*p = malloc(10);

4.3 ...吗？*p++递增p或者它指向的对象？

4.4 我正在尝试使用指针来操作一个...数组int数组。这段代码有什么问题？

	int array[5], i, *ip;
	for(i = 0; i < 5; i++) array[i] = i;
	ip = array;
	printf("%d\n", *(ip + 3 * sizeof(int)));

4.5 我有一个char *指针，它碰巧指向一些int，我想逐个遍历它们。为什么不行？

((int *)p)++;

4.6 为什么我不能对...执行算术运算？void *指针执行算术运算？

4.7 我有一些代码试图解包外部结构，但它因“未对齐访问”的消息而崩溃。这是什么意思？

4.8 我有一个函数接受并应该初始化一个指针

	void f(int *ip)
	{
		static int dummy = 5;
		ip = &dummy;
	}

	int *ip;
	f(ip);

4.9 假设我想写一个接受通用指针作为参数的函数，并且我想模拟通过引用传递它。我能给形式参数类型void **，并执行类似这样的操作？

	void f(void **);
	double *dp;
	f((void **)&dp);

4.10 我有一个函数

	extern int f(int *);

	f(&5);

4.11 C 甚至有“引用传递”吗？

4.12 我见过用于通过指针调用函数的不同语法。这是怎么回事？

4.13 什么是总的通用指针类型？当我尝试将函数指针塞进一个...时，我的编译器抱怨void *.

4.14 整数如何转换为指针，反之亦然？我能否暂时将整数塞进指针，或反之？

4.15 如何将一个...int转换为char *？我尝试了强制类型转换，但它不起作用。

4.16 这个声明有什么问题？

char* p1, p2;

4.17 “近”指针和“远”指针是什么意思？

5. 空指针

5.1 这个臭名昭著的空指针到底是什么？

5.2 如何在我的程序中获得空指针？

5.3 缩写的指针比较“...if(p)”用于检查非空指针是否有效？如果空指针的内部表示不是零呢？

5.4 ...是什么？NULL，它是如何定义的？

5.5 应该如何...NULL应该如何定义？

5.6 如果...NULL定义如下：

	#define NULL ((char *)0)

5.7 我的供应商提供了一些头文件，它们...#define NULL为0L。这是为什么？

5.8 是...NULL是否有效？

5.9 如果...NULL和0作为空指针常量是等效的，我应该使用哪一个？

5.10 但使用...会不会更好？NULL的值改变（可能在具有非零内部空指针的机器上），使用0（而不是NULL）不是更好吗？

5.11 我曾经用过一个需要...的编译器。NULL没有被使用，它就无法工作。

5.12 我使用预处理器宏

#define Nullptr(type) (type *)0

5.13 这很奇怪。NULL保证是0，但空指针却不是？

5.14 为什么围绕空指针会有这么多困惑？为什么这些问题如此频繁地出现？

5.15 我很困惑。我就是无法理解所有这些空指针的东西。

5.16 考虑到围绕空指针的困惑，要求它们在内部表示为零会不会更简单？

5.17 严重地，真的有实际机器使用非零空指针，或者对不同类型的指针使用不同的表示吗？

5.18 运行时值为 0 的整数，强制转换为指针，是否保证为空指针？

5.19 如何访问位于机器地址 0 的中断向量？如果我将指针设置为0，编译器可能会将其转换为某个非零的内部空指针值。

5.20 运行时“空指针赋值”错误是什么意思？如何跟踪它？

6. 数组和指针

6.1 我有定义char a[6]，而在另一个文件中，我声明了extern char *a。为什么它不起作用？

6.2 但我听说...char a[]与char *a.

6.3 那么 C 中“指针和数组的等价性”是什么意思？

6.4 如果它们如此不同，那么为什么数组和指针声明作为函数形式参数是可互换的？

6.4b 那么数组是按引用传递的，即使 C 的其余部分是按值传递的？

6.5 为什么我不能这样做？

	extern char *getpass();
	char str[10];
	str = getpass("Enter password: ");

6.6 如果不能对数组赋值，那么如何...

	int f(char str[])
	{
		if(str[0] == '\0')
			str = "none";
		...
	}

6.6b 还有这个呢？这难道不是数组赋值吗？

	char a[] = "Hello, world!\n";

6.7 既然不能给数组赋值，数组如何成为左值？

6.8 实际上，数组和指针的区别是什么？

6.9 有人向我解释说数组实际上就是常量指针。

6.10 我仍然很困惑。指针是一种数组，还是数组是一种指针？

6.11 我遇到了一些“笑话”代码，其中包含“表达式”5["abcdef"]这怎么会是合法的 C 代码？

6.12 由于数组引用会衰减为指针，如果arr是一个数组，那么arr和&arr?

6.13 如何声明指向数组的指针？

6.14 如何在运行时设置数组的大小？
我怎样才能避免使用固定大小的数组？

6.15 如何声明与传入数组大小匹配的局部数组？

6.16 如何动态分配多维数组？

6.17 这是一个很棒的技巧：如果我写

	int realarray[10];
	int *array = &realarray[-1];

6.18 当我将二维数组传递给期望指向指针的指针的函数时，我的编译器抱怨了。

6.19 如何编写接受二维数组的函数，但宽度在编译时未知？

6.20 在将静态和动态分配的多维数组传递给函数时，如何可互换地使用它们？

6.21 为什么不...sizeof当数组是函数参数时，不能正确报告数组的大小？我有一个测试例程

	f(char a[10])
	{
		int i = sizeof(a);
		printf("%d\n", i);
	}

6.22 在声明数组的文件中，代码如何...extern（即，它在一个其他文件中定义，并确定其大小）确定数组的大小？sizeof似乎行不通。

6.23 我想知道数组中有多少个元素，但是...sizeof返回字节大小。

6.24 有没有办法拥有一个位数组？

7. 内存分配

7.1 为什么这段代码片段不起作用？

	char *answer;
	printf("Type something:\n");
	gets(answer);
	printf("You typed \"%s\"\n", answer);

7.2 我无法让...strcat工作。我试过

	char *s1 = "Hello, ";
	char *s2 = "world!";
	char *s3 = strcat(s1, s2);

7.3 但是 man 页strcat说它接受两个char *作为参数。我应该如何知道分配内存？

7.3b 我刚才试了这段代码

char *p;
strcpy(p, "abc");

7.3c 指针变量分配多少内存？

7.4 我正在用这段代码从文件中读取行到数组中

	char linebuf[80];
	char *lines[100];
	int i;

	for(i = 0; i < 100; i++) {
		char *p = fgets(linebuf, 80, fp);
		if(p == NULL) break;
		lines[i] = p;
	}

7.5a 我有一个函数应该返回一个字符串，但当它返回给调用者时，返回的字符串是垃圾。

7.5b 那么返回字符串或其他聚合体的正确方法是什么？

7.6 为什么我对调用...的“警告：从整数赋值指针缺少类型转换”malloc?

7.7 为什么有些代码会仔细地转换...的返回值？malloc返回的值转换为正在分配的指针类型？

7.7b 转换...有什么问题？malloc的返回值有什么问题？

7.7c 在调用...中malloc时，像“无法将 `void *' 转换为 `int *''' 这样的错误是什么意思？

7.8 我看到像这样的代码

	char *p = malloc(strlen(s) + 1);
	strcpy(p, s);

7.9 我写了一个小的包装器malloc，但它不工作

	#include <stdio.h>
	#include <stdlib.h>

	mymalloc(void *retp, size_t size)
	{
		retp = malloc(size);
		if(retp == NULL) {
			fprintf(stderr, "out of memory\n");
			exit(EXIT_FAILURE);
		}
	}

7.10 我正在尝试声明一个指针并为其分配一些空间，但它不起作用。这段代码有什么问题？

char *p;
*p = malloc(10);

7.10a 此初始化有什么问题？

char *p = malloc(10);

7.10b 如何关闭...给我的“警告：可能的指针对齐问题”消息？lint对...的每一次调用？malloc?

7.11 如何动态分配数组？

7.12 如何查找有多少可用内存？

7.13 应该如何...应该做什么？返回一个空指针还是指向 0 字节的指针？

7.14 我听说有些操作系统实际上并没有分配...malloc分配的内存，直到程序试图使用它。这合法吗？

7.15 malloc返回了奇怪的指针值，但我确实读了问题 7.6，并且我包含了这一行

	extern void *malloc();

7.16 我正在为一些数字工作分配一个大数组，使用以下行

	double *array = malloc(300 * 300 * sizeof(double));

7.17 我的 PC 有 8MB 内存。为什么我似乎只能...malloc640K 左右？

7.18 我的应用程序严重依赖节点对数据结构的动态分配，而...malloc/free的开销正成为瓶颈。我该怎么办？

7.19 我的程序正在崩溃，似乎在某个地方卡在...malloc内部，但我看不出有什么不对。是malloc?

7.19b

我正在动态分配一个数组，像这样

	int *iarray = (int *)malloc(nints);

7.20 你不能在使用后使用动态分配的内存，对吗？

7.21 为什么在调用...之后指针不是空的？free?
释放指针后使用（赋值、比较）指针值有多不安全？

7.22 当我打电话给...malloc为一个函数中的局部指针分配内存时，我是否必须显式地free它？

7.23 我正在分配包含指向其他动态分配对象的指针的结构。当我释放一个结构时，是否也必须释放每个附属指针？

7.24 在程序退出前必须释放分配的内存吗？

7.25 我有一个程序，它...malloc了很多内存，之后又free了很多内存，但从操作系统上看，内存使用量并没有真正减少。

7.26 ...是如何工作的？free如何知道需要释放多少字节？

7.27 那么我能否查询 malloc 包以找出分配块的大小？

7.28 为什么不...sizeof能否告诉我一个指针指向的内存块的大小？

7.29 动态分配了数组（如问题 6.14 所示），能否更改其大小？

7.30 将空指针作为第一个参数传递给...是否合法？realloc是否合法？为什么会有人这样做？

7.31 ...和...有什么区别？calloc和malloc？我应该使用哪个？利用calloc的零填充是否安全？free是否适用于用calloc分配的内存，还是需要cfree?

7.32 ...是什么？alloca为什么不推荐使用它？

8. 字符和字符串

8.1 为什么不...

strcat(string, '!');

8.2 我正在检查一个字符串是否与特定值匹配。为什么这段代码不起作用？

	char *string;
	...
	if(string == "value") {
		/* string matches "value" */
		...
	}

8.3 如果我说...

	char a[] = "Hello, world!";

	char a[14];
	a = "Hello, world!";

8.4 我无法让...strcat工作。我试过

	char *s1 = "Hello, ";
	char *s2 = "world!";
	char *s3 = strcat(s1, s2);

8.5 这些初始化之间有什么区别？

char a[] = "string literal";
char *p  = "string literal";

8.6 如何获取与字符对应的数值（即 ASCII 或其他字符集代码），反之亦然？

8.7 C 是否有像其他语言中存在的“substr”（提取子字符串）例程？

8.8 我正在将用户输入的字符串读入数组，然后稍后打印它们。当用户输入像...这样的序列时\n，为什么它没有被正确处理？

8.9 我觉得我的编译器有问题：我刚注意到sizeof('a')是 2，而不是 1（即不是sizeof(char)).

8.10 我开始考虑多国字符集，并且我担心让...的影响sizeof(char)成为 2 以便表示 16 位字符集。

9. 布尔表达式和变量

9.1 C 中布尔值应该使用什么类型？是否有标准类型？我应该使用...#define或枚举类型来表示真和假值吗？

9.2 #define ...不是吗？TRUE定义为 1 是否危险，因为在 C 语言中任何非零值都被认为是“真”？如果内置的逻辑运算符或关系运算符“返回”的值不是 1 怎么办？

9.3 是...if(p)这样的表达式，其中p是指针，是否是有效且可移植的测试？

9.4 我应该使用符号名称，如...TRUE和FALSE这样的符号名称来表示布尔常量，还是使用普通的 1 和 0？

9.5 我开始使用的第三方头文件定义了自己的...TRUE和FALSE值与我已开发的的代码不兼容。我该怎么办？

10. C 预处理器

10.1 我正在尝试定义一些简单的类似函数的宏，例如

	#define square(x) x * x

10.2 这里有一些有趣的预处理器宏

	#define begin	{
	#define end	}

10.3 如何编写一个通用的宏来交换两个值？

10.4 编写多语句宏的最佳方法是什么？

10.5 使用 ... 和 ... 有什么区别？typedef和#define定义用户自定义类型有什么区别？

10.5b ...和...有什么区别？

	const MAXSIZE = 100;

and

	#define MAXSIZE 100

10.6 我正在将程序拆分成多个源文件，这是我第一次这样做，我正在考虑把什么放在....c文件中放入什么，又该在.h文件中放入什么。(“.h” 到底是什么意思？)

10.7 一个头文件可以...#include另一个？

10.8a ...和...有什么区别？#include <>和#include "" ?

10.8b 头文件搜索的完整规则是什么？

10.9 我在文件的第一个声明中出现了一些奇怪的语法错误，但它看起来是正确的。

10.10 我正在使用随附两个不同第三方库的头文件，它们“好心地”定义了公共宏，例如TRUE, FALSE, Min()，而Max()，但它们的定义相互冲突，也与我自己在头文件中已建立的定义冲突。我该怎么办？

10.10b 我正在 #include 我正在使用的库函数的正确头文件，但是链接器总是说它是未定义的。

10.11 我正在编译一个程序，似乎缺少它需要的一个头文件。有人能寄给我一份副本吗？

10.12 如何构造预处理器#if表达式来比较字符串？

10.13 ...是否？sizeof运算符在预处理器#if指令中是否有效？

10.14 能使用...#ifdef中#define一行使用，像这样以两种不同的方式定义东西？

	#define a b \
	#ifdef whatever
		c d
	#else
		e f g
	#endif

10.15 有没有像...这样的东西？#ifdef对于typedef有什么区别？

10.16 如何使用预处理器...#if表达式来判断机器的字节顺序是大端还是小端？

10.17 我在...行内出现了一些奇怪的语法错误#ifdef过的行里遇到了奇怪的语法错误。

10.18 我继承了一些代码，其中包含太多的...#ifdef's。如何在不运行预处理器并展开所有#include's 和#define's 的情况下，将代码预处理以仅留下一个条件编译集？

10.19 如何列出所有预定义的标识符？

10.20 我有一些旧代码尝试用像...这样的宏来构造标识符

#define Paste(a, b) a/**/b

10.21 我有一个旧宏

#define CTRL(c) ('c' & 037)

10.22 为什么宏...

	#define TRACE(n) printf("TRACE: %d\n", n)

	TRACE(count);

	printf("TRACE: %d\count", count);

10.23 如何在宏扩展中的字符串字面量中使用宏参数？

10.24 我正在尝试使用 ANSI 的“字符串化”预处理运算符`#' 来将符号常量的值插入到消息中，但它总是字符串化宏的名称而不是它的值。

10.25 我有一些棘手的预处理要做，而且我找不到方法来做。

10.26 如何编写一个接受可变数量参数的宏，或者使用预处理器来“关闭”一个带有可变数量参数的函数调用？

10.27 如何包含...的扩展？__FILE__和__LINE__宏的展开？

11. ANSI/ISO 标准 C

11.1 “ANSI C 标准”是什么？

11.2 如何获取标准副本？

11.2b 从哪里可以获得有关标准更新的信息？

11.3 我的 ANSI 编译器在看到...时抱怨不匹配

	extern int func(float);

	int func(x)
	float x;
	{ ...

11.4 可以混合旧式和新式函数语法吗？

11.5 为什么声明...

extern int f(struct x *p);

11.6 我遇到了一个令人沮丧的问题，最终是由...行引起的

	printf("%d", n);

11.7 我听说你必须...#include 在调用printf。这是为什么？

11.8 我不明白为什么我不能使用const值，例如

	const int n = 5;
	int a[n];

	typedef char *charp;
	const charp p;

	const MAXSIZE = 100;

and

	#define MAXSIZE 100

	main(int argc, char **argv)
	{
		return 0;
	}

char c;
while((c = getchar()) != EOF) ...

long int n = 123456;
printf("%d\n", n);

char s[30];
scanf("%s", s);

double d;
scanf("%f", &d);

short int s;
scanf("%d", &s);

	int n;
	scanf("%d\n", &n);
	printf("you typed %d\n", n);

	int n;
	char str[80];

	printf("enter a number: ");
	scanf("%d", &n);
	printf("enter a string: ");
	gets(str);
	printf("you typed %d and \"%s\"\n", n, str);

	int n;

	while(1) {
		printf("enter a number: ");
		if(scanf("%d", &n) == 1)
			break;
		printf("try again: ");
	}

	printf("you typed %d\n", n);

	errno = 0;
	printf("This\n");
	printf("is\n");
	printf("a\n");
	printf("test.\n");
	if(errno != 0)
		fprintf(stderr, "printf failed: %s\n", strerror(errno));

	myfopen(char *filename, FILE *fp)
	{
		fp = fopen(filename, "r");
	}

		FILE *infp;
		myfopen("filename.dat", infp);

	FILE *fp = fopen(filename, 'r');

	main()
	{
		printf("%f\n", sqrt(144.));
	}

	printf("%d", n);

	int f(...)
	{
	}

va_arg(argp, float)

	for(i = start; i < end; i++);
		{
		printf("%d\n", i);
		}

char *p = "hello, world!";
p[0] = 'H';

struct mystruct {
	char c;
	long int i32;
	int i16;
} s;

char buf[7], *p;
fread(buf, 7, 1, fp);
p = buf;
s.c = *p++;
s.i32 = *(long int *)p;
p += 4;
s.i16 = *(int *)p;

if(!strcmp(s1, s2))

extern int func __((int, int));

char *p

char* p

fopen("c:\newdir\file.dat", "r")

	extern int func(int, int);
	char *funcname = "func";
	int r = (*funcname)(1, 2);

	r = (*(int (*)(int, int))funcname)(1, 2);