c语言笔记

1. 编译和链接

将程序转化为机器可执行的代码，C语言分为三个步骤：

A. 预编译。程序首先会交给预处理器，预处理器执行以#开头的指令，然后给程序添加指令，或者修改指令。

B. 编译。修改后的程序进入编译器，编译器会把程序翻译成机器指令（也就是目标代码），但是这样的程序还是不能执行的。

C. 链接。链接器把由编译器产生的目标代码和其他所需的代码整合到一起，这些附加代码包括程序中用到的库函数。这样就产生了完全可执行的程序。

2. main函数中的exit和return

在main函数中，以两者结尾是一样的。都是终止程序执行，并且向操作系统返回0。

不过exit需要引入stdlib.h库函数。

#include

#include

int main (void)

{

printf("Hello world");

exit(0);

//return 0;

}

3. %i和%d

在printf中使用时，两者没有区别，但是在scanf中，%d只能接受10进制的整数。

但是%i还可以接受八进制和十六进制的整数。

#include

#include

int main (void)

{

int i ;

scanf_s("%i",&i);

printf("%d",i);

}

4. scanf函数

scanf本质上是一种“模式匹配”函数。

但是在Visual Studio中调用scanf函数时会给出这样的提示：The function may be unsafe.Please using scanf_s instead.

当用户从键盘输入时，程序并没有读取输入，而是把用户的输入放在一个隐藏的缓冲区中，由scanf来读取。因此如果用户输入了多余的字符，scanf无法彻底完成模式匹配，scanf 就会把字符放回缓冲区供后续scanf函数的读取。

1. 编译和链接

将程序转化为机器可执行的代码，C语言分为三个步骤：

A. 预编译。程序首先会交给预处理器，预处理器执行以#开头的指令，然后给程序添加指令，或者修改指令。

B. 编译。修改后的程序进入编译器，编译器会把程序翻译成机器指令（也就是目标代码），但是这样的程序还是不能执行的。

C. 链接。链接器把由编译器产生的目标代码和其他所需的代码整合到一起，这些附加代码包括程序中用到的库函数。这样就产生了完全可执行的程序。

2. main函数中的exit和return

在main函数中，以两者结尾是一样的。都是终止程序执行，并且向操作系统返回0。

不过exit需要引入stdlib.h库函数。

#include

#include

int main (void)

{

printf("Hello world");

exit(0);

//return 0;

}

3. %i和%d

在printf中使用时，两者没有区别，但是在scanf中，%d只能接受10进制的整数。但是%i还可以接受八进制和十六进制的整数。

#include

#include

int main (void)

{

int i ;

scanf_s("%i",&i);

printf("%d",i);

}

4. scanf函数

scanf本质上是一种“模式匹配”函数。

但是在Visual Studio中调用scanf函数时会给出这样的提示：The function may be unsafe.Please using scanf_s instead.

当用户从键盘输入时，程序并没有读取输入，而是把用户的输入放在一个隐藏的缓冲区中，由scanf来读取。因此如果用户输入了多余的字符，scanf无法彻底完成模式匹配，scanf 就会把字符放回缓冲区供后续scanf函数的读取。

1. C语言中的布尔类型

在C语言中，是没有布尔类型的，0就是false,非0就是true。

于是，写习惯了Java/C#的我们自然会很不习惯，这个时候，我们不妨用宏定义来使我们的代码看起来更舒服一些。

1.#define BOOL int

2.#define TRUE 1

3.#define FALSE 0

4.

5.int main (void)

6.{

7.BOOL flag=TRUE;

8.if(flag)

9. {

10. printf("true");

11. }

12.else

13. {

14. printf("false");

15. }

16.}

在C99中，长期缺乏布尔类型的问题得到的解决，但是在目前，C99标准还没有得到很好的推广。暂且不提。

2. limits.h

习惯了平台无关的我们，在学习C语言时，必须需要注意他的平台相关性。其中很典型的例子就是在不同的平台下，不同的编译器下，int的取值范围是不同的。

在C#中，我们可以用Int32.MaxValue来获得，那么在C语言中，我们该怎么获得呢？

在C中，提供了一个头文件limits.h，里面有很多宏定义。

那么我们就很容易得到int类型的取值范围。

1.#include

2.#include

3.#include

4.

5.int main (void)

6.{

7. printf("int的最小值是:%d;最大值是:%d",INT_MIN,INT_MAX);

8.return 0;

9.}

3. 浮点类型

在C语言中，提供了三种浮点类型：分别为

float：单精度浮点数，

double：双精度浮点数，

long double：扩展精度浮点数。

在一般要求不严格的情况下，float就足够了，其次是double，long double几乎不会用到。

在C99中，浮点类型包括两种，分别为实浮点类型，就是我们上面提到的。还有复数类型，分别对应为float_Complex等等。

4. 字符类型

在C语言中，一般采用的ASCII编码，而字符类型又分为有符号型和无符号型。在C语言标准中，对此并无规定，因此是由不同的编译器自己决定。

因此考虑到可移植性，如果涉及到符号相关，我们不要假设char是有符号还是无符号，而用signed和unsigned来显式标识。

由于在C语言中，字符实际上是被作为整数来处理的，因此在C89中，将字符类型和整数类型统称为整值类型。

C语言读入字符不会跳过空白字符。我们可以看一个简单的例子：

1.int main (void)

2.{

3.char ch;

4. scanf("%c",&ch);

5. printf("%c",ch);

6.return 0;

7.}

我现在键入一个换行：

他也把换行符读入，然后打印出来。

那么我们如何读入一串字符串呢？

1.int main (void)

2.{

3.char ch='a';

4.int count=0;

5.do

6. {

7. scanf("%c",&ch);

8. count++;

9. }while(ch!='\n');

10. printf("%d",count-1);

11.}

当然，我们也可以这样来写：

1.int main (void)

2.{

3.char ch='a';

4.int count=0;

5. scanf("%c",&ch);

6.while(ch!='\n')

7. {

8. count++;

9. scanf("%c",&ch);

10. }

11. printf("%d",count);

12.}

5. getchar和putchar

在C语言中，为我们提供了专门输入和输出字符的函数，也就是getchar()和putchar().让我们看下getchar()和putchar()的定义。

_Check_return_ _CRTIMP int __cdecl getchar(void);

_Check_return_opt_ _CRTIMP int __cdecl putchar(_In_ int _Ch);

我们可以看到，其实他们返回的都是int类型的值。OK，让我们看看他们都返回什么。

1.int main (void)

2.{

3.char c;

4.int result;

5. c=getchar();

6. result = putchar(c);

7. printf("\nc:%c;result:%d",c,result);

8.}

我们可以看到，他们都是返回其字符的ASCII码。

那么，既然C语言为我们提供了这样专门的函数，一定说明他在读取和输出字符方法比scanf 和printf有着特殊的优势。

A. 由于getchar和putchar函数实现比较简单，因此较之效率更高。

B. 为了额外的效率提升，通常getchar和putchar都是作为宏来实现的。

总之，他们相较之略显重量的scanf和printf效率更高。

另外，我们还可以用getchar来实现读取字符的C语言惯用法。

1.int main (void)

2.{

3.while(getchar()!='\n');

4.return 0;

5.}

这样的函数一直读到换行终止。

另外：

1.int main (void)

2.{

3.char c;

4.while((c=getchar())==' ');

5.switch(c)

6. {

7.case'a':

8. printf("a");

9.break;

10.case'q':

11. printf("q");

12.break;

13.default:

14. printf("others");

15.break;

16. }

17.}

我们也可以这样来实现忽略一切空白，当然也可以修改程序使之忽略其他字符。

另外，我们在前文说过，scanf在无法完成彻底模式匹配时，会把剩余的字符放到缓冲区，供下次读取。那么我们来看这样一段代码：

1.int main (void)

2.{

3.int i ;

4.char c;

5. scanf("%d",&i);

6. c=getchar();

7. printf("%c",c);

8.}

由此可知，getchar()也会首先打缓冲区里去读取字符。

1. typedef

在前文中，我们用宏定义来定义了一个BOOL类型，那么现在就用更专业的方式来定义类型。

typedef int Bool;

int main (void)

{

Bool flag=1;

if(flag)

{

printf("True");

}

else

{

printf("false");

}

}

typedef 的作用就是类型定义(Type Definition)。

类型定义有以下三个优点：

1. 易于阅读。比如我们可以把定义一个Dollar，然后Dollar money=1000；这样比用int 来得更容易阅读。

2. 容易修改，如果有一天Dollar要改成double类型，那么我只需要修改类型定义就可以了。

3. 便于移植。在上文中，我们说过C语言是平台相关的，那么我们不妨定义一些Int32,Int64，这样当我们移植时，我们只需要修改这些类型定义就可以了。

那么类型定义较之宏定义有两个优点：

A. 类型定义更为强大，特别是，数组和指针类型是不能定义为宏的。

B. 在作用上，宏定义只是简单的字符串替换，而类型定义却带有一定的封装性。

2. sizeof运算符

这个运算符很简单，就不赘述了，只强调一点。由于sizeof运算符返回的类型时size_t，这是一种自定义的类型，因此，为了防止不同的平台造成的不兼容问题。我们最好在显示前将其进行一次类型转换。

int main (void)

{

printf("%d",(int)sizeof(int));

}

1. 数组大小

我相信，在C#/Java中，更多的人愿意用List来取代数组，一方面是List提供了较多的方法，另一方面也无需我们去指定数组的大小。

那么在C语言中，我们既然需要必须指定数组的大小，而一般来讲，很多数组大小事我们无法确定并且经常会发生变化的，那么我们最好的方式就是用宏定义来限定数组的大小。#define SIZE 10

int main (void)

{

int a[SIZE];

}

如果包含多个数组的话，用宏就很难记忆，那么我们就可以利用sizeof运算符。

int main (void)

{

int a[]={1,3,4,55,6,7,89,9,0};

int i ;

printf("%d",(int)sizeof(a)/(int)sizeof(a[0]));

for(i=0;i<(int)sizeof(a)/(int)sizeof(a[0]);i++)

{

a[i]=0;

}

for(i=0;i<(int)sizeof(a)/(int)sizeof(a[0]);i++)

{

printf("%d\n",a[i]);

}

}

注意，我们之前说过，sizeof返回的值是size_t，因此，我们在计算时，最好将其先强制类型转换为我们可以控制的类型。

2. 数组初始化

一般情况下，我们初始化数组都是把整数数组初始化为0，那么我们一般会怎么做呢？

#define SIZE 5

int main (void)

{

int a[SIZE]={0,0,0,0,0};

}

那么如过SIZE=100怎么办，那么很多人都会这样去做。

#define SIZE 100

int main (void)

{

int a[SIZE];

int i ;

for(i=0;i

{

a[i]=0;

}

}

其实我们完全不用麻烦，这么一句代码就可以搞定了。

#define SIZE 100

int main (void)

{

int a[SIZE]={0};

}

在C99中，提供了一种初始化式，使得我们可以这样来写。

#define SIZE 100

int main (void)

{

int a[SIZE]={[5]=100,[50]=49};

}

而其他的数字就都默认为0。那么我们来考虑这样一段代码：

#define SIZE 10

int main (void)

{

int a[SIZE]={1,2,3,4,5,[0]=6,7,8};

}

那么在C99中，这段代码的结果究竟是什么呢？这个就需要我们来了解一下数组初始化式的原理。

其实，编译器在初始化式数组列表时，都会记录下一个待初始化的元素的位置，比如说在初始化index=0的元素时，会记录下1，这样以此类推，但是当初始化index=5的时候，首

先根据他的初始化式记录下一个待初始化的元素时index=1，然后初始化index=0的元素为6。那么也就是说：最后的结果应该是{6,7,8,4,5,0,0,0,0,0}。

3. 常量数组

当数组加上const就变成了常量数组，常量数组主要有两个好处。

1. 告诉使用者，这个数组是不应该被改变的。

2. 有助于编译器发现错误。

4. C99的变长数组

这是个很爽的东西，我们再也不必担心为数组指定大小而发愁了，指定大了会造成空间的浪费，指定小了又不够用。

在C99中，他的长度会由程序执行时进行计算。

方式如下：

int main (void)

{

int size;

int a[size];

scanf("%d",&size);

}

5. 数组的复制

很多时候，我们需要把一个数组的元素复制到另一个数组上，我们大多数人第一个想到的就是循环复制。

#define SIZE 10

int main (void)

{

int a[SIZE];

int b[SIZE];

int i ;

for(i=0;i

{

a[i]=i;

}

for(i=0;i

{

b[i]=a[i];

}

for(i=0;i

{

printf("%d",b[i]);

}

}

其实还有一种更好的方法是使用memcpy方法，这是一个底层函数，它把内存的字节从一个地方复制到另一个地方，效率更高。

#include

#include

#include

#define SIZE 10

int main (void)

{

int a[SIZE];

int b[SIZE];

int i ;

for(i=0;i

{

a[i]=i;

}

memcpy(b,a,sizeof(a));

for(i=0;i

{

printf("%d",b[i]);

1. 数组作为函数参数

函数是我们学习程序设计语言最基本的东西了，我在此不再赘述。只讨论一种特殊情况，就是数组作为函数的参数传递。

我们都知道，其实在传递数组的时候，实际上是传递了数组首元素的指针。明确了这一点之后，我们就可以思考下面的问题。

既然他只是传递了数组首元素的指针，那么他必然无法知道整个数组的大小，因此，我们如果希望在函数中用到数组的长度，必须要进行显式传递。

int Sum(int a[],int size)

{

int i ,sum=0;

for(i=0;i

{

sum+=a[i];

}

return sum;

}

那么既然，函数无法检测传入数组的长度，我们也可以利用这一个特性来计算数组前N个数的和，或者是利用这一特性来告诉函数，实际上，数组的有效长度要小于数组的真实长度。

2. C99中变长数组作为函数参数

首先在数组一节中，我们谈到了C99中的变长数组是个很好的东西。那么我们来看看变长数组作为函数参数的情况。

我们看之前的代码，size和a[]并没有直接的联系，那么当变长数组作为参数就会解决这样的情况。

int Sum(int size,int a[size])

{

int i ,sum=0;

for(i=0;i

{

sum+=a[i];

}

return sum;

}

这个代码，则明确地表示了数组a的长度是size，也就是说在size和a[]之间建立起了直接的联系。

但是在这里我们需要注意一点，就是参数的顺序，长度一定要写在数组之前，否则会出现a[size]找不到size的错误。

在进行函数声明时，我们可以有以下几种方式：

int Sum(int ,int a[*]);

int Sum(int n ,int a[n]);

int Sum(int n, int a[*]);

int Sum(int ,int a[]);

int Sum(int n ,int a[]);

个人比较推荐第一种，因为我觉得第一种最为简便，而且可以表明a是一个变长数组。像第四种和第五种，我个人认为是两种很不好的方式。

3. C99中数组参数声明使用static

C99中允许在数组参数声明中使用关键字static。例如：

int Sum(int a[static 10],int n)

{

}

从函数本身来讲，static并没有对函数的本身实现造成任何影响。static 10的含义是数组的长度至少是10。那么当函数调用时，编译器会事先从内存中取出10个数，而不是在函数调用的时候才一次次的去取，这样就可以使函数的效率更高。

4. main函数的返回值

在初学C语言的时候，谭老的书上大部分都是这样的代码：

void main ()

{

printf("Hello world");

}

但是实际上，这段函数有两个缺陷：

A. 从编程风格上来看，最好显式地声明main函数没有参数

B. main函数应该返回状态码，在某些操作系统中，程序终止时可以检测到状态码，来监视程序是否正常结束。即使你不需要这个状态码，其他人也可能需要。

因此，这个函数最好这样来实现：

int main (void)

{

printf("Hello world");

return 0;

}

还记得我们之前说过exit(0)么，我们之前说，在main函数中写return 0和exit(0)是没有区别的。那么我们就来看看return 和exit的区别。

exit属于头文件，我们之前说过，0是状态码中成功的意思，那么为了更直观，C标准库为我们提供了这样的两个宏定义。

int main (void)

{

printf("Hello world");

exit(EXIT_SUCCESS); //成é功|

exit(EXIT_FAILURE); //失§败ü

}

让我们转向定义可以发现：

/* Definition of the argument values for the exit() function */

#define EXIT_SUCCESS 0

#define EXIT_FAILURE 1

在中的这两个宏定义。但是这两个值并不是固定的，而是由实现定义的。

另外，return 和exit的一个最典型差异就是，在其他函数中调用return 不会引起程序的终止，但是无论在哪里调用exit都会引起程序终止，我们看一个程序。

int main (void)

{

printf("Begin\n");

BreakTest();

printf("End\n");

}

int BreakTest()

{

return 0;

}

这段代码不应该产生任何疑问：

接下来看下这段代码：

int main (void)

{

printf("Begin\n");

BreakTest();

printf("End\n");

}

int BreakTest()

{

exit(EXIT_SUCCESS);

}

由此可知，exit使整个的程序都被终止了。

1. 指针的来源

在当代，大多数的现代计算机都会把内存分割成字节，每个字节都有着其唯一的地址。可执行程序由代码和数据两部分构成，而程序中的每个变量都占有着一个或多个字节，也就是说，每个变量都有着自己的地址。而这个就是指针的来源。

其实每个地址就是一个数，但是我们却不能用数来表示地址，存储地址，我们需要用指针变量。例如int *p = i，我们就可以说p是指针变量，存储着变量i的地址。

那么我们说int *p中，p就是指向int 类型对象的指针变量。

2. 取址运算符和间接寻址运算符

&，取址运算符，如果x是变量，那么&x就是变量x所在的地址。

*，间接寻址运算符，如果p是指针变量，*p就代表p所指向的变量的值。

当我们在程序中声明int *p时，其实并没有让p指向任何地址，只是一个空指针，我们也称之为悬浮指针，在程序中，我们应该尽量避免这样的状况，应该尽量当声明的同时进行初始化。否则当今后不小心对*p进行赋值时，如果p恰好指向了某一块系统内存地址，就会造成系统的崩溃。

其实我们第一次接触取址运算符，应该是应用于scanf，现在我们来想想scanf(“%d”,&a)的含义，其实就是告诉scanf函数，要把读取的值放到哪个地址的下面。

3. const保护参数

我们之前说过const代表常量，不允许改变，那么我们也可以将const应用于指针参数上。例如：