C语言语法总结

1.C语言的数据类型
基本类型
   a.整型:
      整型 int   Visual c++6.0 中占4 个字节; Turbo c 2.0占 2个字节 取值:-2147483648 -2147483647
      短整型 short int 2个字节 取值:-32768 - 32767
      长整型 long int   4个字节取值:-2147483648 - 2147483647
       无符号整型 unsigned int 4个字节 取值:0-4294967295
       无符号短整型 unsigned short int 2个字节
       无符号长整型 unsigned long int   4个字节
       注:对于不同的编译环境,整型在内存中所占的字节数也不一样。
   b.字符型:
      char (\n 回车 \t 下一制表位置 \r 回车 \'单引号 \\ :反斜杠字符"\")
      注:对于c语言的任何一个字符都可用转义字符来表示
      如:\101表示字符"A",\134表示反斜杠,\XOA表示换行
      对于字符串常量内存字节数要加1,用来存放字符结束标志符"\0"
   c.实型:
      单精度 float 占4个字节,32位。取值为:3.4E-38 ~ 3.4E+38 ,可提供6到7位有效数字
      双精度 double 占8位字节,64位。取值:1.7E-308 ~1.7E+38
    d.枚举:
       enum
构造类型
    a.数组 array
    b.结构体 struct
    c.共用体 union
指针类型 *
空类型 void

2.输入输出函数
printf(格式控制字符串,输出列表) //格式控制字符串可由格式字符串(以%开头)和非格式字符串(原样输出)组成.
scanf(格式控制字符串,地址表列)
putchar() //字符数据的输出 等同与 printf(%c,.) 位于<stdio.h>中
getchar() //从键盘输入中读取一个字符。scanf(%c,&mchar)

3.逻辑运算
   !(非) ,&&(与), ||(或)

4.二维数组
定义: 类型说明符 数组名[常量表达式1][常量表达式2]
注:a.存储器单元是一维线性排列的。是按行存放的。
       b.对于全部元素赋初值,则数组第一维的长度可以省略,但是第二维不能省。如:int a[][3]= {1,2,3,4,5,6}
       c.可以只对部分元素赋初值,没赋初值的元素自动取0值。
       d.一个二维数组可以分解为一个多个一维数组。例:a[3][4]可分解为三个一维数组,其数组名分别为a[0],a[1],a[2],而这个
        一维数组都有4个元素。如一维数组a[0]有元素为:a[0][0],a[0][1],a[0][2],a[0][3]

5.字符数组
c中没有字符串数据类型,是用字符数组来表示字符串变量的。字符串总是以'\0'作为串结束符,所以,字符串就是一种以‘\0’结束的字符数组。
注:在求字符串长度时,不包含结束符'\0'。但是sizeof却要包含。如:
char c[]="string";
char c1[]={'s','t','r','i','n','g','\0','\0'};
printf("%d\n",sizeof(c)); // 7 ,默认在string后加'\0'
printf("%d\n",sizeof(c1)); //8,对于字符数组只能自己加结束符
printf("%d\n",strlen(c)); //6 求字符串长度时,不包含结束符'\0'
printf("%d\n",strlen(c1)); //6 求字符串长度时,不包含结束符'\0'
常用的字符串处理函数(在stdio.h中与string.h中):
puts(字符数组名)---把字符数组中的字符串输出到显示器。
gets(字符串数组名)--从输入设备得到字符串。
strcat(字符数组名1,字符数组名2)--把字符数组中2中的字符串连接到字符数组1中字符串的后面,并删除字符串1后的串标志"\0";
strcpy(字符数组名1,字符数组名2)--把字符数组2中的字符串复制到字符数组1中,串结束标识'\0'也一同复制。
strcmp(字符数组名1,字符数组名2)--按照ASCII码顺序比较两个数组中的字符串,并由函数返回比较结果。
strlen(字符数组名)---返回字符实际长度(不含字符'\0')

6.函数

对于被调用函数的声明和函数一般形式:类型说明符 被调函数名(类型,类型,..);
注:如果被调用函数的返回值是整型或字符型时,可以不对被调用函数作说明而直接调用。
       如果被调用函数定义出现在主调用函数之前,在主函数可以不对被调用函数作说明而直接调用。
     
7.变量的作用域及存储特性
a.局部变量:又称内部变量。在函数内作定义说明,其作用域仅限于函数内。
     注:允许在不同的函数中使用变量名,它们代表不同的对象,分配不同的单元,互不干扰。
b.全局变量:又称外部变量,它是在函数外部定义的变量。它不属于哪一个函数,而属于一个源程序文件。其作用域是整个源程序。在函数中使用全局变量,一般应作全局变量说明。只有在函数中经过说明的全局变量才能使用,说明符为:extern.但是在一个函数之前定义的全局变量,在该函数内可以再加以说明。
     另注:外部变量在定义时就已分配了内存单元,外部变量定义可作为始赋值,外部变量说明不能再初始值,只是表明在函数内要使用某外部变量。
     在同一源文件内,允许全局变量和局部变量同名,在局部变量的作用域内,全局变量不起作用。
变量的存储特性:
a.auto(自动变量)默认。为动态存储,既只有在使用它才分配存储单元,开始它的生命周期。
b.extern(外部变量)   为静态存储,外部变量等同与全局变量。当一个源程序由若干个源文件组成时,在一个源文件中定义的外部变量在其它的源文件中也有效。
c.static(静态变量) 为静态存储方式,可分为静态局变量和静态全局变量。
   静态局变量:在局部变量的说明前再加上static说明。
如:在一个函数 f() { static int a,b;
                                  static float a[5]; ...}
    特点:(1).静态局部变量在函数内定义,当调用时已存在。当函数f()退出时仍然存在,生存周期为整个源程序。
              (2).静态局部变量虽然生存周期为整个源程序,但是退出其函数后存在但是不能使用。
              (3).允许对构造类静态局部量赋初值。若未赋值,则系统自动赋值为0值。
              (4).对基本类型的静态局部变量若没赋值,则系统自动赋值为0.而对于自动变量不赋初值,则其值是不固定的。
   静态全局变量:全局变量再加以static就成了静态全局变量。对于静态全局变量其则只在定义该变量的源文件有效,在同一源文件的其他源文件中是不能使用的。
              (5).把局部变量改变为静态变量后就是改变它的存储方式,即生存周期。把全局变量改变为静态变量后改变它的作用域,限制了它的使用范围。
d.寄存器变量(register).当一个变量反复访问时,就可将此变量声明为register。放在cpu的寄存器中。别注:只有局部自变量和形式参数才能定义为寄存器变量。使用个数很有限。对于Truboc 、MS C等使用是按自动变量处理的。

8.内部函数和外部函数
   内部函数--一个只能被本文件中的其他函数所调用的函数。形式:static 类型 函数名(形参表)
   外部函数---如果在函数标识符前面加上extern,形式:extern int fun(int a,int b) 其中,extern为默认。

9.指针变量声明
    [存储类型] 类型标识符 *指针变量名;  
    [存储类型] 类型标识符 *指针变量名=变量地址;(注:int *p; 表示:变量p表示指针变量;另外P可用来存放整数变量的地址。指针变量本身存储的都是地址,每个指针(地址)占4个字节(在VC中),例:char *p, size(p)为==4 );

10.指针运算
a.指针赋值: 如:int x; int *p=&x;   也可在程序中对其初始化:int x,*p; .. p=&x
注意:在没赋初值时,指针变量的内容是不确定的。如果此时引用指针指向的变量,将会产生不可预料的后果。 如:int *p; *p=100; //错误,p没有初始化。
b.指针的加减:指针变量加1不能是简单的地址加1,加上一sizof(指针变量所指类型)。
两个指针变量在指向同一存储区域(数组)的元素时,可以进行相减。其差绝对值表示两指针元素之间相差的元素个数。

11.指针与一维数组
注:c语言中规定,数组名代表第一个元素的地址,是指针常量。数组a的首地址可用&a[0]表示,或a表示。
   对于如:int a[10],*p;
           p=a;或 p =&a[0];
   或定义为:int a[10];
               int *p = a;
   小结:指针与一维数组的关系
   &a[i],&p[i],a+i,p+i            表示数组元素a[i]的地址
   a[i],*(a+i),*(p+i),p[i]        表示元素a[i]的内容。
   p++,p--                            表示使p后移或前移一个元素的存储空间
   *p++,*p--                        表示先取p所指对象*p,然后使p后移或前移一个元素的存储空间。
   (*p)++,(*p)--                   使p所指对象的值加1或减1.相当于:*p = *p + 1;
   *++p;*--p;                       取指针变量p加1或减1后的内容。相当于:*(++p),*(--p);
   ++*p,--*p;                       使p所指向的变量的内容加1或减1

12.动态申请存储空间
   内存申请库函数: void *malloc(size); 例: int *p = (int *) malloc(10 * sizeof(int));
   内存释放库函数: void free(p);             free(p);

13.预处理
指在进行编译的第一遍扫描(词法扫描、语法分析、代码生成、代码优化)之前所做的工作。C中是由预处理程序负责完成。
当对一源文件进行编译时,系统将自动引用预处理程序对源程序中的预处理部分进行处理,处理完毕后自动对源程序进行编译,将预处理的结果和源程序一起再进行通常的编译处理,以得到目标代码。(在C中如宏定义、文件包含、条件编译等为预处理)。
宏定义:不带参数的宏定义 #define 标识符字符串   例:#define PI 3.1415926
                带参数的宏定义    #define 宏名(形参表) 字符串
                带参数的宏调用:宏名(实参表)    例:#define M(y) (y*y+3)      调用:k=M(5)*10;
   注:a.带参数的宏定义中,宏名和形参之间不能有空格出现。
          b.在宏定义中的形参是标识符,而宏调用中的实参可以是表达式。
          c.在宏定义中,字符串内的形参通常要用括号括起来以避免出错。
          d.带参的宏和带参函数很相似,但有本质上的不同。在带参宏定义中,形式参数不分配内存单元,因此不用定义类型。
          而宏调用中的实参有具体的值,要用它们去代换形参,因此进行类型说明。
          在函数中,形参和实参是两个不同的量,各有自己的作用域,调用时把实参值赋予形参,进行值传递。
       如:#include "stdio.h"
              #define SQ(y) ((y)*(y))
              main()
             {
              int i=1;
              while(i<=5)
              {
                //printf("%d\n",SQ(i++)); //输出为:1,9,25
                printf("%d\n",SQ(++i));     //输出为:9,25,49   注:对SQ(++i) 首先用((++i)*((++i))来替换
              }                                     
             }

14.文件包含
   一个源程序通过#include命令把另外一个源文件的全部内容嵌入到源程序中来。在编译时并不是作为两个文件连接,而是作为一个源程序编译,得到一个目标文件。
   格式:#include "文件名"
   注:#include "file.h" 首先在使用包含文件的源文件所的目录查找file.h文件,若没有找到指定的文件,再到系统指定的标准目录查找。
          #include <file.h> 仅在编译系统指定的标准目录查找文件file.h.
  
15.条件编译
希望部分行在满足一定条件才进行编译,即按不同的条件去编译不同的程序部分,因而产生不同的目标代码条件。使用条件编译功能,为程序的调试和移植提供了有力的机制,使程序可以适应不同系统和硬件设置的通用性和灵活性。
#ifdef 标识符
          程序段1
#else
        程序段2
#endif
例:
   #define R 1
   #include <stdio.h>
   main()
   {
       double c,r,s;
       printf("请输入圆的半径或矩形的边长:\n");
       scanf("%d",&c);
       #ifdef R
           r = 3.14 *c *c;
           printf("圆的面积=%f\n",r);
       #else
           s=c*c;
           printf("矩形面积=%f\n",s);
       #endif                          ..
   }

16.指针型函数
指函数返回指针值的函数。格式: 类型说明符 *函数名([参数列表]){}   多用于构造类型数据结构(创建一个链表、返回指向头结点的指针)。
   例:
   #include <stdio.h>
   int *max(int *a,int *b)
   {
      return (*a>*b)?a:b;
   }
   void main()
   {
       int a,b,*p;
       scanf("%d,%d",&a,&b);
       p = max(&a,&b);
       printf("max=%d",*p);
   }

17.指向函数的指针
   C语言规定,函数名就表示该函数所点内存区域的首地址,将函数首地址赋给某一指针变量,则通过该指针变量就可以调用这个函数。这种指向函数的指针变量就称为函数指针变量。
   定义:
      类型标识符 (*指针变量名)([参数列表]);
      类型标识符:表示指针所指函数的返回值的类型。(*指针变量名)表示"*"后面定义的变量为指针变量,括号表示指针变量所指的是一个函数,而参数列表则列出函数的类型。
   用函数指针变量调用函数格式:(*指针变量名)(实参表) 或指针变量名(实参表)
例:
   #include<stdio.h>
   #include<math.h>
   float area(int a,int b)
   {
       return (float)a*b/2;
   }
   float length(int a,int b)
   {
       return (float)sqrt(a*a + b*b);
   }
   void main()
   {
          int m,n;
          float s,l;
          float (*f)(int,int); //定义一个指向函数的指针变量
          scanf("%d,%d",&m,&n);
          f = area;
          s = (*f)(m,n);
          f = length;
          l =(*f)(m,n);
          printf("area=%.2f,length=%.2f\n",s,l);
   }
要注意区分定义语句int(*p)()和int *p()。这类组合说明符遵循“从里到外,先右后左”的规则。
对于int(*p)() 的阅读顺序是:从标识符*p开始,说明*p是一个指针变量,它指向一个函数(先读右边),它返回int类型(再读左边)。

对于int *p(),从标识符p开始,p是一个函数(先读右边),返回值为类型为int *(再读左边),即它是一个指针型函数。

18.二维数组和指针
    二维数组中的行、圾元素的地址
   a、&a[0]           二维数组首行(第0行)的首地址。
   a[0]、*(a+0)、*a   0行0列元素地址
   a+1                   1行首地址
   a[1],*(a+1)        1行0列元素地址。
   a[i]+j、*(a+i)+j 、&a[i][j] 第i行第j列的首地址
   *(a[i]+j)、*(*(a+i)+j)、a[i][j] 第i行第j列元素值
  
19.指向二维数组中一行元素的指针
数据类型(*指针名)[N]
例:int a[3][4], int (*p)[4]; 这里p是一个指针变量,它指向包含4个整型元素的一维数组。可以进行p=a初始化。但是不能p=&a[0][0],因为数组名a是指针常量,它的基类型是包含4个整型元素的一维数组,与行指针变量p的基类是一样的。但是a[0][0]是数组中的一个元素,它的基类是整型。所以不能将引地址赋给p.
   例如:
        int a[3][4] ={{1,3,4,9},{7,12,24,17},{11,31,25,30}   };


转载:blog.sina.com.cn/s/blog_5632ed9f0100dq5b.html~type=v5_one&label=rela_nextarticle
        int i;
        int (*p)[4] =a;
        for(p=a;p<a+3;p++){
          for(i=0;i<4;i++)
             printf("%3d", *(*p +i));
             printf("\n");
     
20.指针数组
可以使若干个行指针分别指向二维数组中的每一行,把这些指指针存放在一个数组中,称为指针数组。
指针数组的定义形式为: 类型说明符 *数组名[常量] 例:char *p[10]; 按照右结合的原则,p先与[10]结合,说明了是数组的形式,它有10个元素,p[10]再与前面的*结合,表示数组p[10]是一个指针变量,即每一个数组元素都是一个指针变量,现由左面的类型char,可知指针数组中的每一个指针变量都指向一个字符串。
例如:将"china","india","japan","america","canada"按字母顺序(由小到大)输出。
#include <stdio.h>
#include<string.h>
void sort(char *a[],int n)
{
char *temp;
int i,j,p;
for(i=0;i<n;i++)
{
       p =i;
       for(j=i+1;j<n;j++)
       {
          if(strcmp(a[p],a[j])>0) p=j;
        }
           if(p!=i)
           {
         temp = a[i];
           a[i] = a[p];
           a[p] = temp;
           }
}
}
main()
{
    char *name[]={"china","india","japan","america","canada"};
    int i,n=5;
    sort(name,n);
    for(i=0;i<n-1;i++)
       printf("%s\n",name[i]);
}

21.二级指针
是指向一级指针的指针。即二级指针中存放的是一级指针的地址。
定义: [存储形式] 数据类型 **指针名;   
例:int a,*p,**q;    p=&a; q=&p;
例:char *name[]={"china","india","japan","american","canada"};
      char **p;
      int i;
      for(i=0;i<5;i++)
     {
        p = name +i;
        printf("%s\n",*p);
     }
    
22.指针数组作main函数的形参
定义:main(int argc,*argv[]) 或 main(int argc,**argv); 其中argc是命令行中的参数个数(可执行文件名本身也算一个)argv是一个指向字符串的指针数组,用来存放命令行中各个参数的首地址。

23.结构体
         例:struct student{      
                            long int num;
                            char *name;
                            float scorce[3];
                            }stud1,stud2;  
            struct student stud3,stud4;
结构体的引用:结构体变量名.成员名 如:stud1.num = 101;   stud1.name ="dick";

24.typedef的使用方法
利用某个已有的数据类型定义一个新的数据类型。格式:typedef 数据类型或数据类型名新数据类型名
例如: typedef float REAL;
           typedef struct student STU; //定义STU结构体struct student的别名
有了上定义后就可以用如下的定义方式如:REAL f1,f2;   STU s;
注意:a.typedef没有创造新的数据类型,它是用来定义类型,不能定义变量。
          b.typedef并不是作简单的字符串替换,与#define的作用不同。
          c.用typedef定义类型名时往往用大写字母表示,并单独存于一个文件中。
          d.用typedef定义类型名有利于程序的移植,并增加程序的可读性。
         
25.结构体数组
数组元素是结构体类型的数组。
例:struct person{
                 char *name;
                int count;
                }leader[3] ={"li",0,"zhang",0,"wang",0};
        void main()
        {
        int i,j;
        char leader_name[20];
        for(i=1;i<=10;i++)
        {
            printf("请输入第%d个用户的名字",i);
            scanf("%s",leader_name);
                 for(j=0;j<3;j++)
               if(strcmp(leader_name,leader[j].name)==0)
                leader[j].count++;
        }
        printf("\n");
        for(i=0;i<3;i++)
        printf("%5s:%d\n",leader[i].name,leader[i].count);
        }
       
26.指向结构体的指针
说明一个结构类型的变量后,它就在内存获得了存储区,该存储区的起始地址,就是这个变量的地址(指针)。如果说明一个这种结构类型的指针变量,把结构类型变量的地址赋给它,这个指针就指向这个变量了。
结构体指针变量定义的一般形式:struct 结构体名 *指针变量名; 例:struct student *p;
用指针变量访问结构变量成员的方法:1).直接利用结构变量: 结构变量名.成员名
          2).利用指向结构变量的指针和指针运算符"*",形式: (*指针变量名).成员名
          3).利用指向结构变量的指针和指向成员运算符"->",一般形式:指针变量名-->成员名
#include<stdio.h>
#include<string.h>
void main()
{
struct student{
      long int num;
     char name[20];
     char sex;
     float score;
}stu_1,*p;
p = &stu_1;
stu_1.num = 89101;
strcpy(stu_1.name,"li li");
p->sex = 'M';
p->score= 89.5;
printf("\nNum:%ld\nname:%s\nsex:%c\nscore:%f\n",(*p).num,p->name,stu_1.sex,p->score);
}

27.共同体
由若干个不同类型的数据项组成,但共享同一存储空间的结构类型。(与结构体的区别是:结构体类型变量的每一个成员都占有各自的存储区,而共同体类型变量的所有成员共用一个存储区。常称它是一种可变身份的数据类型,可在不同的时候在同一存储单元中存储不同类型的变量。)
     例如:union data{
              int i;
              char ch;
              float f;
              double d;
           };
例:#include<stdio.h>
union u{
char u1;
int u2;
};
main()
{
union u a ={0x9843};
printf("1.%c %x\n",a.u1,a.u2);   //输出:1.C 43 由于第一个成员是字符型,用一个字节,所以对对于初值0x9843仅接受0x43,初值的高字节被截取。      
a.u1 = 'B';
printf("2.%c %x\n",a.u1,a.u2);   //输出:2.B 62

28.枚举类型
它的值有固定的范围(如一年只有12个月),这些值可以用服限个常量来描述。格式:
             enum 枚举类型名{
                   标识符1[=整型常量1],       //要注意最后结束符是","不是“,”
                   标识符2[=整型常量2],
                   .....
                   };
enum weekday{
Mon = 1,
Tue,
Wed,
Thu,
Fri,
Sat,
Sun
};
char *name[8] ={"error","Mon","Tue","Wed","Thu","Fri","Sat","Sun"};
void main()
{
enum weekday d;
printf("请输入今天的数字(1-7):\n");
scanf("%d",&d);
if(d>0&&d<7)
   d++;
else if(d==1)
   d=1;
else
   d=0;
if(d) printf("明天是%s\n",name[d]);
else
   printf("%s\n",name[d]);
}

29.文件类型指针
在c语言中有一个FILE类型,它是存放有关文件信息的结构体,FILE类型结构在stdio.h定义,如下:
    typedef struct{
        short level; //缓冲区满或空的程度
        unsigned flags; //文件状态标志
        char     fd;    //与文件相关的标示符,即文件句柄
        unsigned hold; //如无缓冲则不读字符
        short    bsize; //缓冲区大小,默认为512字节
        unsigned char *buffer; //数据缓冲区的指针
        unsigned char *curp;   //当前激活文件指针
        unsigned istemp;       //临时文件标示
        short    token;        //用于文件有效性检查
    }FILE;
定义文件类型指针: FILE *fp;

30.文件的打开和关闭
文件的打开:     文件指针名 = fopen(文件名,打开文件方式);    其中文件指针名必须是说明为FILE类型的指针变量。
文件名是打开文件的文件名,它可以是字符串常量或者字符数组。 打开方式:指文件的类型和操作要求。
    打开方式                               意义
   rt                               只读打开一个文本文件,只允许读数据。
   wt                             只写打开或建立一个文本文件,只允许写数据
   at                              追加打开一个文本文件,并在文件末尾写数据
   rb                             只读打开一个二进制文件,只能读数据
   rt+                            读写打开一个文本文件,允许读和写。
   wt+                           读写或建立一个文本文件,允许读写
   at+                            读写打开一个文本文件,允许读,或在文件未追加数据。
   rb+                           读写打开一个二进制文件,允许读和写。
注:a.r(read)、w(write)、a(append)、t(text)、b(binary)、+(读写).
       b.用"w"打开的文件只能向该文件写入。若打开的文件不存在,则以指定的文件名建立该文件,若打开的文件已存在,则将该文件删去。
       c.若要向一个已存在的文件追加新的信息,只能用"a"方式打开文件,但此时文件必须是存在的,否则将会出错。
例:FILE *fp;
    if(fp = fopen("c:\\cp\red.txt","rt")==NULL){ exit(1);}
     else{
     ...//从文件中读取数据
     }
文件的关闭:fclose(文件指针);   //正常返回0,否则返回EOF;

31.文件的读写

a.字符输入/输出函数
写字符函数fputc()---将一个字符写入指定的文件中,其调用格式为:fputc(字符量,文件指针);
读字符函数fgetc()---从指定的文件中读取一个字符,其调用格式:字符变量 = fgetc(文件指针);
   #include<stdio.h>
    void main()
    {
        FILE *fp;
        char c,fileName[30];
        printf("请输入文件名:");
        gets(fileName);
        if((fp=fopen(fileName,"w"))==NULL){
            printf("不能打开文件..");
        exit(0);
         }
        printf("请输入你字符串直到*为\n");
        c = getchar();
        while(c!='*')
        {
               fputc(c,fp);
               c = getchar();
        }
        fclose(fp);
        //读取文件
        fp = fopen(fileName,"r");
        while(c=getc(fp)!=EOF)
        {
            putchar(c);
        }
        fclose(fp);
        }
    }
b.文件字符串输入/输出函数
从指定的文件中读出一个字符串到字符数组中,格式:fgets(字符数组名,n,文件指针); //表示从文件中读出的字符串不超过n-1个字符。字符最后一个字符前加上串标志'\0'.读取过程中若遇到换行符或者文件结束符(EOF),则读取结束。
写字符串函数:fputs(字符串,文件指针); //字符串可以是字符常量,也可以是字符数组。
c.数据块输入/输出函数
数据块读函数fread(p,size,n,fp); p指向要要输入/输出数据块的首地址的指针;size:某类型数据存储空间的字节数;n:此次从文件中读取的数据项数。fp:文件指针变量
数据块写函数fwrite(p,size,n,fp);
例:    #include<stdio.h>
            #define N 5
            struct worker{
                char name[10];
                int id;
                float salary;
                char addr[15];
            }worker[N];
            void save()
            {
                FILE *fp;
                int i;
                if((fp=fopen("worker.txt","wt"))==NULL){
                       printf("打开文件失败..\n");
                       return;
                }
                for(i=0;i<N;i++){
                       if(fwrite(&worker[i],sizeof(worker[i]),1,fp)!=1)
                        printf("写文件失败\n");
                }
                   fclose(fp);
            }
            void dispaly()
            {
                FILE *fp;
                int i;
                if(( fp=fopen("worker.txt","rt"))==NULL){
                    printf("不能打开文件\n");
                    return;
                }
                for(i=0;i<N;i++){
                    fread(&worker[i],sizeof(worker[i]),1,fp);
                   printf("%s%d%f%s\n",worker[i].name,worker[i].id,worker[i].salary,worker[i].addr);
                }
                fclose(fp);
            }
            void main()
            {
                FILE *fp;
                int i;
                if( (fp=fopen("worker.txt","rt"))==NULL){
                       printf("不能打开文件");
                       return;
                }
                for(i=0;i<N;i++)
                {
                       printf("name:");
                       scanf("%s",worker[i].name);
                       printf("id:");
                       scanf("%d",&worker[i].id);
                       printf("salary:");
                       scanf("%f",&worker[i].salary);
                       printf("address:");
                       scanf("%s",worker[i].addr);
                }
                save();
                dispaly();
                fclose(fp);
            }
d.字输入/字输出
putw(w,fp)---将整型数w写入fp所指的文件(以写方式打开的二进制文件).w是要输出的整型数据,可以是常量或变量
getw(fp) ---从fp所指向的文件中读取一个整型数。

32.文件的定位
rewind(文件指针)---重置文件位置指针到文件开头。
fseek(文件指针,位移量,起始位置); 位移量:指被移动的字节数,大于0表示新的位置在初始值的后面。小于0表示在新的位置在初始值的前面。起始位置:0(文件开始处)、1(当前位置)、2(文件末尾处)
ftell(文件指针)---返回当前指针位置。
   

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值