1#include <stdio.h>
2FILE *fopen(const char *path, const char *mode);

1#include <stdio.h>
2void rewind(FILE *fp);

1#include <stdio.h>
2int fseek(FILE *fp,long offset,int from);

1# include<stdio.h>
2long ftell(FILE *fp);

1long getfilelength(FILE *fp){
2    long curpos = 0L;
3    long length = 0L;
4    curpos = ftell(fp);
5    fseek(fp, 0L, SEEK_END);
6    length = ftell(fp);
7    fseek(fp, curpos, SEEK_SET);
8    return length;
9}

1#include <sys/types.h>
2#include <sys/stat.h>
3#include <fcntl.h>
4       
5int open(const char *pathname, int flags);
6int open(const char *pathname, int flags, mode_t mode);

 1#include <stdio.h>
 2#include <unistd.h>
 3#include <string.h>
 4#include <sys/types.h>
 5#include <sys/stat.h>
 6#include <fcntl.h>
 7
 8int main(){
 9  umask(0);
10  int fd = open("myfile", O_WRONLY|O_CREAT, 0664);
11  if(fd < 0){
12    perror("open");
13    return 1;
14  }
15
16  int count = 5;
17  const char *msg = "hello bit!\n";
18  int len = strlen(msg);
19
20  while(count--){
21   int ret =  write(fd, msg, len);
22   printf("实际写入数据%d字节\n", ret);
23  }
24
25  close(fd);
26  return 0;
27}

 1#include <stdio.h>
 2#include <unistd.h>
 3#include <string.h>
 4#include <sys/types.h>
 5#include <sys/stat.h>
 6#include <fcntl.h>
 7
 8int main(){
 9  int fd = open("myfile", O_RDONLY);
10  if(fd < 0){
11    perror("open");
12    return 1;
13  }
14
15  
16  const char *msg = "hello bit!\n";
17  char buf[1024];
18
19  while(1){
20   ssize_t s =  read(fd, buf, strlen(msg));//返回实际读到的字节数
21
22   if(s > 0){
23     printf("%s", buf);
24   }else{
25     break;
26   }
27  }
28
29  close(fd);
30  return 0;
31}

 1#include <stdio.h>
 2#include <sys/types.h>
 3#include <sys/stat.h>
 4#include <fcntl.h>
 5
 6int fun(){
 7  int fd = open("myfile", O_RDONLY);
 8  if(fd < 0){
 9    perror("open");
10    return 1;
11  }
12
13  printf("fd = %d\n", fd);
14  close(fd);
15  return 0;
16}
17
18int fun2(){
19  close(0);
20  int fd = open("myfile", O_RDONLY);
21  if(fd < 0){
22    perror("open");
23    return 1;
24  }
25
26  printf("fd = %d\n", fd);
27  close(fd);
28  return 0;
29}
30
31int main(){
32  //fun(); 
33  fun2();
34  return 0;
35}

 1int main(){
 2  close(1);
 3  int fd = open("myfile", O_WRONLY|O_CREAT, 00644);
 4  if(fd < 0){
 5    perror("open");
 6    return 1;
 7  }
 8
 9  printf("fd = %d\n", fd);
10  fflush(stdout);
11
12  close(fd);
13  return 0;
14}

 1int main(){
 2  close(0);
 3  int fd = open("myfile2", O_RDONLY);
 4  if(fd < 0){
 5    perror("open");
 6    return 1;
 7  }
 8  char buf[1024] = {0};
 9  scanf("%s", buf);
10  printf("buf = %s\n", buf);
11  return 0;
12}

 1struct _IO_FILE {
 2  int _flags;		/* High-order word is _IO_MAGIC; rest is flags. */
 3#define _IO_file_flags _flags
 4
 5  //缓冲区相关
 6  /* The following pointers correspond to the C++ streambuf protocol. */
 7  /* Note:  Tk uses the _IO_read_ptr and _IO_read_end fields directly. */
 8  char* _IO_read_ptr;	/* Current read pointer */
 9  char* _IO_read_end;	/* End of get area. */
10  char* _IO_read_base;	/* Start of putback+get area. */
11  char* _IO_write_base;	/* Start of put area. */
12  char* _IO_write_ptr;	/* Current put pointer. */
13  char* _IO_write_end;	/* End of put area. */
14  char* _IO_buf_base;	/* Start of reserve area. */
15  char* _IO_buf_end;	/* End of reserve area. */
16  /* The following fields are used to support backing up and undo. */
17  char *_IO_save_base; /* Pointer to start of non-current get area. */
18  char *_IO_backup_base;  /* Pointer to first valid character of backup area */
19  char *_IO_save_end; /* Pointer to end of non-current get area. */
20
21  struct _IO_marker *_markers;
22
23  struct _IO_FILE *_chain;
24
25  int _fileno; //文件描述符
26#if 0
27  int _blksize;
28#else
29  int _flags2;
30#endif
31  _IO_off_t _old_offset; /* This used to be _offset but it's too small.  */
32
33#define __HAVE_COLUMN /* temporary */
34  /* 1+column number of pbase(); 0 is unknown. */
35  unsigned short _cur_column;
36  signed char _vtable_offset;
37  char _shortbuf[1];
38
39  /*  char* _save_gptr;  char* _save_egptr; */
40
41  _IO_lock_t *_lock;
42#ifdef _IO_USE_OLD_IO_FILE
43};

 1#include <stdio.h>
 2#include <string.h>
 3#include <unistd.h>
 4
 5int main(){
 6  const char *msg0 = "hello printf\n"; 
 7  const char *msg1 = "hello fwrite\n";
 8  const char *msg2 = "hello write\n";
 9  
10  printf("%s", msg0);
11  fwrite(msg1, strlen(msg0), 1, stdout);
12  write(1, msg2, strlen(msg2));
13
14  fork();
15  return 0;
16}