C语言关键字详细描述

目录

一    volatile

二    typedef

1    基本解释

2    typedef & 结构的问题

三    extern

四    #define

4.1 对带参宏定义的说明

五    memset

六    static

七    strcat

八    const

九 sizeof

十 memcpy

十一    enum(枚举)

十二 关于malloc和realloc的用法使用区别

十三 fflush函数

1、fflush(stdin)

2、fflush(stdout)


一    volatile

       volatile是一个类型修饰符(type specifier),就像大家更熟悉的const一样,它是被设计用来修饰被不同线程访问和修改的变量。volatile的作用是作为指令关键字,确保本条指令不会因编译器的优化而省略,且要求每次直接读值。

volatile的变量是说这变量可能会被意想不到地改变,这样,编译器就不会去假设这个变量的值了。

作用

简单地说就是防止编译器对代码进行优化。比如如下程序:

XBYTE[2]=0x55;

XBYTE[2]=0x56;

XBYTE[2]=0x57;

XBYTE[2]=0x58;

      对外部硬件而言,上述四条语句分别表示不同的操作,会产生四种不同的动作,但是编译器却会对上述四条语句进行优化,认为只有XBYTE[2]=0x58(即忽略前三条语句,只产生一条机器代码)。如果键入volatile,则编译器会逐一地进行编译并产生相应的机器代码(产生四条代码)。

typedef volatile int8_t vint8_t;

typedef volatile uint8_t vuint8_t;

typedef volatile int16_t vint16_t;

typedef volatile uint16_t vuint16_t;

typedef volatile int32_t vint32_t;

typedef volatile uint32_t vuint32_t;  

 

volatile是一个类型修饰符(type specifier),就像大家更熟悉的const一样,它是被设计用来修饰被不同线程访问和修改的变量。volatile的作用是作为指令关键字,确保本条指令不会因编译器的优化而省略,且要求每次直接读值。

volatile的变量是说这变量可能会被意想不到地改变,这样,编译器就不会去假设这个变量的值了。

二    typedef

        typedef是在计算机编程语言中用来为复杂的声明定义简单的别名,它与宏定义有些差异。它本身是一种存储类的关键字,与auto、extern、mutable、static、register等关键字不能出现在同一个表达式中。

用法总结:

        如何创建平台无关的数据类型,隐藏笨拙且难以理解的语法:使用typedef为现有类型创建别名,定义易于记忆的类型名

typedef int size;

void measure(size*psz);

size array[4];

size len=file.getlength();

std::vectorvs;

typedef 还可以掩饰复合类型,如指针和数组。

例如,你不用像下面这样重复定义有 81 个字符元素的数组:

char line[81];

char text[81];

只需这样定义,Line类型即代表了具有81个元素的字符数组,使用方法如下:

typedef char line[81];

Line text,line;

getline(text);

同样,可以像下面这样隐藏指针语法:

typedef char* pstr;

int mystrcmp(const pstr p1,const pstr p3);

用GNU的gcc和g++编译器,是会出现警告的,按照顺序,‘const pstr'被解释为‘char* const‘(一个指向char的指针常量),而事实上,const char*和char* const表达的并非同一意思(详见C++ Primer 第四版 P112)。

char * const p;//定义一个指向字符的指针常数,即const指针,常量指针。

const char* p;//定义一个指向字符型常量的指针。

char const* p;//等同于const char* p。

语言用法

1    基本解释

typedef为C语言的关键字,作用是为一种数据类型定义一个新名字。这里的数据类型包括内部数据类型(int,char等)和自定义的数据类型(struct等)。

在编程中使用typedef目的一般有两个,一个是给变量一个易记且意义明确的新名字,另一个是简化一些比较复杂的类型声明。

至于typedef有什么微妙之处,请你接着看下面对几个问题的具体阐述。

2    typedef & 结构的问题

当用下面的代码定义一个结构时,编译器报了一个错误,为什么呢?莫非C语言不允许在结构中包含指向它自己的指针吗?请你先猜想一下,然后看下文说明:

typedef struct tagNode
{
    char* pItem;
    pNode* pNext;
}pNode;


typedef long byte_4;            //给已知数据类型long起个新名字,叫byte_4。
typedef struct tagMyStruct        //typedef与结构结合使用
{
    int iNum;
    long lLength;
}MyStruct;

 

三    extern

        extern是计算机语言中的一个关键字,可置于变量或者函数前,以表示变量或者函数的定义在别的文件中。提示编译器遇到此变量或函数时,在其它模块中寻找其定义,另外,extern也可用来进行链接指定。

变量

在一个源文件里定义了一个数组:char a[6];

在另外一个文件里用下列语句进行了声明:extern char *a;

请问,这样可以吗?

答案与分析:

  • 不可以,程序运行时会告诉你非法访问。原因在于,指向类型T的指针并不等价于类型T的数组。extern char *a声明的是一个指针变量而不是字符数组,因此与实际的定义不同,从而造成运行时非法访问。应该将声明改为extern char a[ ]。

  • 例子分析如下,如果a[] = "abcd",则外部变量a=0x12345678 (数组的起始地址),而*a是重新定义了一个指针变量,a指向的地址可能是0x87654321,直接使用*a是错误的.

  • 这提示我们,在使用extern时候要严格对应声明时的格式,在实际编程中,这样的错误屡见不鲜。

  • extern用在变量声明中常常有这样一个作用:你要在*.c文件中引用另一个文件中的一个全局的变量,那就应该放在*.h中用extern来声明这个全局变量。

extern用于变量的用法:

extern int a;//声明一个全局变量a

int a; //定义一个全局变量a

extern int a =0 ;//定义一个全局变量a 并给初值。一旦给予赋值,一定是定义,定义才会分配存储空间。

int a =0;//定义一个全局变量a,并给初值,

声明之后你不能直接使用这个变量,需要定义之后才能使用。

第四个等于第三个,都是定义一个可以被外部使用的全局变量,并给初值。

糊涂了吧,他们看上去可真像。但是定义只能出现在一处。也就是说,不管是int a;还是int a=0;都只能出现一次,而那个extern int a可以出现很多次。

当你要引用一个全局变量的时候,你就要声明extern int a;这时候extern不能省略,因为省略了,就变成int a;这是一个定义,不是声明。

函数

实际上函数的声明和定义都不需要添加extern关键字,在实际使用的时候也最好不要添加关键字。

如果一个函数是不会被其它文件调用的,那么这个函数应该被声明成static的。

如:

extern int func(void)
{
    return 0;
}

int func(void)
{
    return 0;
}

是等价的,另外

extern int func(void);

int func(void);

是等价的。

 

 

四    #define

定义:#define 叫做宏定义命令,它也是C语言预处理命令的一种。所谓宏定义,就是用一个标识符来表示一个字符串,如果在后面的代码中出现了该标识符,那么就全部替换成指定的字符串。

宏定义的一般形式为:

#define  宏名  字符串          //这里所说的字符串是一般意义上的字符序列,不要和C语言中的字符串等同,它不需要双引号。

#表示这是一条预处理命令,所有的预处理命令都以 # 开头。宏名是标识符的一种,命名规则和变量相同。字符串可以是数字、表达式、if 语句、函数等。

 

C语言允许宏带有参数。在宏定义中的参数称为“形式参数”,在宏调用中的参数称为“实际参数”,这点和函数有些类似。

对带参数的宏,在展开过程中不仅要进行字符串替换,还要用实参去替换形参。

带参宏定义的一般形式为:

#define 宏名(形参列表) 字符串

在字符串中可以含有各个形参。

带参宏调用的一般形式为:

宏名(实参列表);

example:

#define M(y)     ( y*y+3*y)  //宏定义

// TODO:

k=M(5);  //宏调用

 

4.1 对带参宏定义的说明

1) 带参宏定义中,形参之间可以出现空格,但是宏名和形参列表之间不能有空格出现。例如把:

#define MAX(a,b) (a>b)?a:b

写为:

#define MAX  (a,b)  (a>b)?a:b

将被认为是无参宏定义,宏名 MAX 代表字符串(a,b) (a>b)?a:b。宏展开时,宏调用语句:

max = MAX(x,y);

将变为:

max = (a,b)(a>b)?a:b(x,y);

这显然是错误的。

2) 在带参宏定义中,不会为形式参数分配内存,因此不必指明数据类型。而在宏调用中,实参包含了具体的数据,要用它们去替换形参,因此实参必须要指明数据类型。

这一点和函数是不同的:在函数中,形参和实参是两个不同的变量,都有自己的作用域,调用时要把实参的值传递给形参;而在带参数的宏中,只是符号的替换,不存在值传递的问题。

 

3) 在宏定义中,字符串内的形参通常要用括号括起来以避免出错。例如上面的宏定义中 (y)*(y) 表达式的 y 都用括号括起来,因此结果是正确的。参数两边的括号是不能少的。即使在参数两边加括号还是不够的,应该在宏定义中的整个字符串外加括号。由此可见,对于带参宏定义不仅要在参数两侧加括号,还应该在整个字符串外加括号。

 

对 #define 用法的几点说明

 

  • 宏定义是用宏名来表示一个字符串,在宏展开时又以该字符串取代宏名,这只是一种简单粗暴的替换。字符串中可以含任何字符,它可以是常数、表达式、if 语句、函数等,预处理程序对它不作任何检查,如有错误,只能在编译已被宏展开后的源程序时发现。

  • 宏定义不是说明或语句,在行末不必加分号,如加上分号则连分号也一起替换。

  • 宏定义必须写在函数之外,其作用域为宏定义命令起到源程序结束。如要终止其作用域可使用#undef命令。

 

example:

#define PI 3.14159
int main(){
    // Code
    return 0;
}

#undef PI
void func(){
    // Code
}

表示 PI 只在 main() 函数中有效,在 func() 中无效。

 

  • 代码中的宏名如果被引号包围,那么预处理程序不对其作宏代替

    example:

#include 
#define OK 100
int main(){
    printf("OK\n");
    return 0;
}

运行结果:

OK

 

五    memset

memset是计算机中C/C++语言函数。将s所指向的某一块内存中的后n个 字节的内容全部设置为ch指定的ASCII值, 第一个值为指定的内存地址,块的大小由第三个参数指定,这个函数通常为新申请的内存做初始化工作, 其返回值为s。

void *memset(void *s, int ch, size_t n);

函数解释:将s中当前位置后面的n个字节 (typedef unsigned int size_t )用 ch 替换并返回 s 。

memset:作用是在一段内存块中填充某个给定的值,它是对较大的结构体或数组进行清零操作的一种最快方法

NOTE:

  • memset函数按字节对内存块进行初始化,所以不能用它将int数组初始化为0和-1之外的其他值(除非该值高字节和低字节相同)。

  • memset(void *s, int ch,size_tn);中key实际范围应该在0~~255,因为该函数只能取ch的后八位赋值给你所输入的范围的每个字节,比如int a[5]赋值memset(a,-1,sizeof(int )*5)与memset(a,511,sizeof(int )*5) 所赋值的结果是一样的都为-1;因为-1的二进制码为(11111111 11111111 11111111 11111111)而511的二进制码为(00000000 00000000 00000001 11111111)后八位都为(11111111),所以数组中每个字节,如a[0]含四个字节都被赋值为(11111111),其结果为a[0](11111111 11111111 11111111 11111111),及a[0]=-1,因此无论ch多大只有后八位二进制有效,而八位二进制 的范围(0~255)YKQ改。而对字符数组操作时则取后八位赋值给字符数组,其八位值作为ASCII  码

  • 搞反了 ch 和 n 的位置.一定要记住如果要把一个char a[20]清零,一定是 memset(a,0,20*sizeof(char));而不是 memset(a,20*sizeof(char),0);

  • 过度使用memset.

char buffer[4];
memset(buffer,0,sizeof(char)*4);
strcpy(buffer,"123"); //"123"中最后隐藏的'\0'占一位,总长4位。

这里的memset是多余的. 因为这块内存马上就被全部覆盖,清零没有意义.

另:以下情况并不多余,因某些编译器分配空间时,内存中默认值并不为0:

char buffer[20];

memset(buffer,0,sizeof(char)*20);

memcpy(buffer,"123",3);

//这一条的memset并不多余,memcpy并没把buffer全部覆盖,如果没有memset,

//用printf打印buffer会有乱码甚至会出现段错误。

//如果此处是strcpy(buffer,"123");便不用memset,

//strcpy虽然不会覆盖buffer但是会拷贝字符串结束符
  • 其实这个错误严格来讲不能算用错memset,但是它经常在使用memset的场合出现

int some_func(struct something *a)
{
    …
    …
    memset(a,0,sizeof(a));
    …
}

 

这里错误的原因是VC函数传参过程中的指针降级,导致sizeof(a),返回的是一个something*指针类型大小的的字节数,如果是32位,就是4字节。

 

六    static

        C++与C#的static有两种用法:面向过程程序设计中的static和面向对象程序设计中的static。前者应用于普通变量和函数,不涉及类;后者主要说明static在类中的作用

面向过程

    静态全局变量

    在全局变量前,加上关键字static,该变量就被定义成为一个静态全局变量。我们先举一个静态全局变量的例子,如下:

//Example1

#include 
using namespace std;
void fn();  //声明函数
static int n;  //声明静态全局变量

int main()
{
    n = 20;  //为n赋初值
    printf("%d", n);//输出n的值
    fn();  //调用fn函数
}

void fn()
{
    n++;  //n的值自加一(n=n+1)
    printf("%d", n);  //输出n的值
}

 

注意:全局变量和全局静态变量的区别

  • 全局变量是不显式用static修饰的全局变量,全局变量默认是有外部链接性的,作用域是整个工程,在一个文件内定义的全局变量,在另一个文件中,通过extern 全局变量名的声明,就可以使用全局变量。

  • 全局静态变量是显式用static修饰的全局变量,作用域是声明此变量所在的文件,其他的文件即使用extern声明也不能使用。

静态局部变量

在局部变量前,加上关键字static,该变量就被定义成为一个静态局部变量。

//Example3

#include 
#include 
void fn();

int main()
{
    fn();
    fn();
    fn();
}

void fn()
{
    static int n = 10;
    printf("%d", n);
    n++;
}

静态函数

在函数的返回类型前加上static关键字,函数即被定义为静态函数。静态函数与普通函数不同,它只能在声明它的文件当中可见,不能被其它文件使用。其它文件中可以定义相同名字的函数,不会发生冲突;

 

七    strcat

将两个char类型连接。

char d[20]="GoldenGlobal"; char *s="View"; strcat(d,s);

结果放在d中

printf("%s",d);

输出 d 为 GoldenGlobalView (中间无空格)

d和s所指内存区域不可以重叠且d必须有足够的空间来容纳s的字符串。

返回指向d的指针。

 

八    const

  • 限定符声明变量只能被读

 const int i=5;

  int j=0;

  ...

  i=j;  //非法,导致编译错误

  j=i;  //合法
  •  必须初始化  

const int i=5;    //合法

const int j;      //非法,导致编译错误
  • 在另一连接文件中引用const常量

  extern const int i;    //合法

  extern const int j=10;  //非法,常量不可以被再次赋值
  • 便于进行类型检查

  用const方法可以使编译器对处理内容有更多了解。

  #define I=10

  const long &i=10;

注意:由于编译器的优化,使得在const long i=10; 时i不被分配内存,而是已10直接代入以后的引用中,以致在以后的代码中没有错误,为达到说教效果,特别地用&i明确地给出了i的内存分配。不过一旦你关闭所有优化措施,即使const long i=10;也会引起后面的编译错误。

  char h=I;      //没有错

  char h=i;      //编译警告,可能由于数的截短带来错误赋值。
  • 可以避免不必要的内存分配

  #define STRING "abcdefghijklmn\n"

  const char string[]="abcdefghijklm\n";

  ...

  printf(STRING);  //为STRING分配了第一次内存

  printf(string);  //为string一次分配了内存,以后不再分配

  ...

  printf(STRING);  //为STRING分配了第二次内存

  printf(string);

  ...

由于const定义常量从汇编的角度来看,只是给出了对应的内存地址,而不是象#define一样给出的是立即数,所以,const定义的常量在程序运行过程中只有一份拷贝,而#define定义的常量在内存中有若干个拷贝。

  • 可以通过函数对常量进行初始化

  int value();

  const int i=value();

  假定对ROM编写程序时,由于目标代码的不可改写,本语句将会无效,不过可以变通一下:

 const int &i=value();

  只要令i的地址处于ROM之外,即可实现:i通过函数初始化,而其值有不会被修改。

  • 是不是const的常量值一定不可以被修改呢?观察以下一段代码:

  const int i=0;

  int *p=(int*)&i;

  p=100;

  通过强制类型转换,将地址赋给变量,再作修改即可以改变const常量值。

  • 请分清数值常量和指针常量,以下声明颇为玩味:

  int ii=0;

  const int i=0;            //i是常量,i的值不会被修改

  const int *p1i=&i;        //指针p1i所指内容是常量,可以不初始化

  int  * const p2i=ⅈ    //指针p2i是常量,所指内容可修改

  const int * const p3i=&i; //指针p3i是常量,所指内容也是常量

  p1i=ⅈ                  //合法

  *p2i=100;                //合法
  • const定义常量从汇编的角度来看,只是给出了对应的内存地址,而不是像#define一样给出的是立即数,所以,const定义的常量在程序运行过程中只有一份拷贝,而#define定义的常量在内存中有若干份拷贝。

  • 编译器通常不为普通const常量分配存储空间,而是将它们保存在符号表中,这使得它成为一个编译期间的常量,没有了存储与读内存的操作,使得它的效率也很高。

 

const VS define

很多人在学习 const 的时候都会混淆它与 define 的区别。从功能上说它们确实很像,但它们又有明显的不同:

  • define是预编译指令,而const是普通变量的定义。define定义的宏是在预处理阶段展开的,而const定义的只读变量是在编译运行阶段使用的。

  • const定义的是变量,而define定义的是常量。define定义的宏在编译后就不存在了,它不占用内存,因为它不是变量,系统只会给变量分配内存。但const定义的常变量本质上仍然是一个变量,具有变量的基本属性,有类型、占用存储单元。可以说,常变量是有名字的不变量,而常量是没有名字的。有名字就便于在程序中被引用,所以从使用的角度看,除了不能作为数组的长度,用const定义的常变量具有宏的优点,而且使用更方便。所以编程时在使用const和define都可以的情况下尽量使用常变量来取代宏。

  • const定义的是变量,而宏定义的是常量,所以const定义的对象有数据类型,而宏定义的对象没有数据类型。所以编译器可以对前者进行类型安全检查,而对后者只是机械地进行字符替换,没有类型安全检查。这样就很容易出问题,即“边际问题”或者说是“括号问题”。

 

九 sizeof

可以获得数据类型占用内存空间的大小

  • 基本用法:

sizeof(type_name)
  • 结果以字节为单位

cout << setw(23) <<"sizeof(char) =" << sizeof(char) << '\n';

           结果:sizeof(char) = 1

 

十 memcpy

memcpy指的是c和c++使用的内存拷贝函数,memcpy函数的功能是从源内存地址的起始位置开始拷贝若干个字节到目标内存地址中。

功能:从源src所指的内存地址的起始位置开始拷贝n个字节到目标dest所指的内存地址的起始位置中,函数返回指向dest的指针。

函数原型

void *memcpy(void *dest, const void *src, size_t n);

所需头文件

C语言:

#include

C++:

#include

strcpy和memcpy主要有以下3方面的区别。

  • 复制的内容不同。strcpy只能复制字符串,而memcpy可以复制任意内容,例如字符数组、整型、结构体、类等。

  • 复制的方法不同。strcpy不需要指定长度,它遇到被复制字符的串结束符"\0"才结束,所以容易溢出。memcpy则是根据其第3个参数决定复制的长度。

  • 用途不同。通常在复制字符串时用strcpy,而需要复制其他类型数据时则一般用memcpy

注意:

  • source和destin所指的内存区域可能重叠,但是如果source和destin所指的内存区域重叠,那么这个函数并不能够确保source所在重叠区域在拷贝之前不被覆盖。而使用memmove可以用来处理重叠区域。函数返回指向destin的指针.

  • 如果目标数组destin本身已有数据,执行memcpy()后,将覆盖原有数据(最多覆盖n)。如果要追加数据,则每次执行memcpy后,要将目标数组地址增加到你要追加数据的地址。

注意:source和destin都不一定是数组,任意的可读写的空间均可。

example1:将s中第13个字符开始的4个连续字符复制到d中。(从0开始)

#include

int main(
{
    char* s="GoldenGlobalView";
    char d[20];
    memcpy(d,s+12,4);//从第13个字符(V)开始复制,连续复制4个字符(View)
    d[4]='\0';//memcpy(d,s+12*sizeof(char),4*sizeof(char));也可
    printf("%s",d);
    getchar();
    return 0;
}

输出结果: View

 

十一 enum(枚举)

枚举是 C 语言中的一种基本数据类型,它可以让数据更简洁,更易读。

枚举语法定义格式为:

enum 枚举名 {枚举元素1,枚举元素2,……};

接下来我们举个例子,比如:一星期有 7 天,如果不用枚举,我们需要使用 #define 来为每个整数定义一个别名:

#define MON  1
#define TUE  2
#define WED  3
#define THU  4
#define FRI  5
#define SAT  6
#define SUN  7

这个看起来代码量就比较多,接下来我们看看使用枚举的方式:

enum DAY
{
      MON=1, TUE, WED, THU, FRI, SAT, SUN
};

这样看起来是不是更简洁了。

注意:第一个枚举成员的默认值为整型的 0,后续枚举成员的值在前一个成员上加 1。我们在这个实例中把第一个枚举成员的值定义为 1,第二个就为 2,以此类推。

可以在定义枚举类型时改变枚举元素的值:

enum season {spring, summer=3, autumn, winter};

没有指定值的枚举元素,其值为前一元素加 1。也就说 spring 的值为 0,summer 的值为 3,autumn 的值为 4,winter 的值为 5

 

枚举变量的定义

前面我们只是声明了枚举类型,接下来我们看看如何定义枚举变量。

我们可以通过以下三种方式来定义枚举变量

1、先定义枚举类型,再定义枚举变量

enum DAY
{
      MON=1, TUE, WED, THU, FRI, SAT, SUN
};
enum DAY day;

2、定义枚举类型的同时定义枚举变量

enum DAY
{
      MON=1, TUE, WED, THU, FRI, SAT, SUN
} day;

3、省略枚举名称,直接定义枚举变量

enum
{
      MON=1, TUE, WED, THU, FRI, SAT, SUN
} day;

 

十二 关于malloc和realloc的用法使用区别

realloc(void *ptr,size_t size);
  • realloc是在已经分配好内存块的重新分配,如果开始指针分配为NULL,则和malloc用法一致,否则如果开始内存块小,保存原内存块,再次基础新增,如果是开始内存块大,则在此基础减去尾部内存块。返回值是分配好内存块的头指针。

malloc(zise_t size);
  • malloc是对没有分配过内存块的直接进行分配,返回值是分配好内存块的返回值是分配好内存块的头指针。通过malloc分配好的内存块一般要用free(size_t size)来释放内存块。

  • 通过realloc和malloc来申请的内存块是返回的指针是无符号类型的,所以在返回后程序员可以定义为任意类型的指针。

 

十三 fflush函数

1、fflush(stdin)

 fflush()的作用是用来刷新缓冲区,fflush(stdin)刷新标准输入缓冲区,把输入缓冲区里的东西丢弃;

#include 

int main()
{
      char c;
      scanf("%c", &c);
      printf("%d\n", c);

      scanf("%c", &c);
      printf("%d\n", c);

      return 0;
}

       运行这个程序,输入1, 并按enter键,结果为:

49

10

 不用吃惊,这个结果很正常的,字符1对应的ASCII值刚好为49, enter键对应的ASCII值为10, 所以就有这样的结果呢。可以看出,第二个scanf函数执行了,并从缓冲区中得到了值(其实,这个值不是我们想要的),那么我们如何把缓冲区这个“马桶”里面的值冲掉呢?用fflush函数就可以了。如下:

#include 

int main()
{
 char c;
 scanf("%c", &c);
 printf("%d\n", c);

 fflush(stdin); // 冲掉“马桶”中的无用值

 scanf("%c", &c);
 printf("%d\n", c);

 return 0;
}

 

2、fflush(stdout)

fflush(stdout)刷新标准输出缓冲区,把输出缓冲区里的东西强制打印到标准输出设备上。fflush(stdout)在单进程程序中作用不大,但在多进程程序中很有用。程序的输出内容一般不会立即输出,而是在程序结束后再输出。fflush(stdout)会强制每次printf()都立即显示在标准输出设备上。

int main() 
{  
    printf("hello");  
  // fflush(stdout);  
    fork();            //父子进程共享同样的文件位置和内容  
    return 0; 
}  

第一种没\n,在fork之前hello还在缓冲区,所以父子进程均要输出hello;

第二种有\n,即printf("hello\n");   由于printf打印到标准输出时,终端是行缓存, 遇到\n就将缓存输出,所以fork之前缓存无内容,只打印一次;

stdout默认是是行缓冲的,遇到 \n 就写内容清缓存。

 

 而加上fflush(stdout); 与 有 \n  作用一样,只是不换行。

 

 

 

你可能感兴趣的