C_函数与字符串函数

函数与字符串函数

  • 1、字符
    • 字符标准输入getchar/输出putchar
    • 字符串标准输入 gets/输出 puts
  • 2、字符串函数
    • strlen和sizeof
    • 连接两个字符串strcat/strncat
    • 字符串比较
    • 字符串拷贝
    • 字符串格式化输出snprintf
    • 字符串匹配子串/某个字符
    • 字符串切割
    • 字符串字符串格式化输入 sscanf
    • 初始化一篇内存的值
    • 内存拷贝
    • 内存剪切
    • 内存比较
  • 3、文件输入和文件输出
    • fopen
    • getc/putc
    • fscanf/fprintf
    • fgets/fputs
      • fgets
      • fputs
    • fread/fwrite
    • fseek
    • ftell
    • fflush
    • setvbut

1、字符

字符标准输入getchar/输出putchar

  • int getchar(void);
  • int putchar(int c);
    代码实现:
#include 

int main()
{
        int c;

        c = getchar();  //从标准输入(键盘输入)获取一个字符
        putchar(c);  //标准输出获取的字符

        return 0;
}

字符串标准输入 gets/输出 puts

  • char *gets(char *s); //不安全
  • char *fgets(char *s, int size, FILE *stream);
  • int puts(const char *s);
#include 

int main()
{
        char buf[128];

        fgets(buf, sizeof(buf), stdin);  //stdin标准输入
        //printf("%s", buf);
        puts(buf);
}

执行结果:
C_函数与字符串函数_第1张图片

2、字符串函数

strlen和sizeof

  • strlen:遇到’\0’就停止,并且不包括’\0’
  • sizeof:占用的存储空间

代码演示:

#include 
#include 

int main()
{
        char *buf = "hello\0haha";

        printf("strlen: %ld\n", strlen("hello\0haha"));
        printf("strlen: %ld\n", strlen(buf));
        printf("sizeof: %ld\n", sizeof(buf));
        printf("sizeof: %ld\n", sizeof("hello\0haha"));
        return 0;
}

执行结果:

strlen: 5
strlen: 5
sizeof: 8
sizeof: 11

连接两个字符串strcat/strncat

  • char *strcat(char *dest, const char *src);
  • char *strncat(char *dest, const char *src, size_t n);
    dest – 指向目标数组,该数组包含了一个 C 字符串,且足够容纳追加后的字符串,包括额外的空字符。
    src – 要追加的字符串。
    n – 要追加的最大字符数。
    代码演示:
#include 
#include 

int main()
{
        char dest[32] = "hello ";
        char *src = "world";

        printf("%s\n",strncat(dest, src, sizeof(src)));

        return 0;
}

执行结果:

hello world

字符串比较

  • 区分大小写 strcmp/strncmp
  • 不区分大小写 strcasecmp/strncasecmp
    代码演示:
#include 
#include 

int main()

{
        char *dest = "hello a world";
        char src[32] = "hello b lyt";

        printf("%d\n", strncmp(dest, src, 5));
        printf("%d\n", strncmp(dest, src, 7));
        printf("%d\n", strncmp(dest, src, 10));

        return 0;
}

执行结果:

0
-1
-1

字符串拷贝

  • char *strcpy(char *dest, const char *src);
  • char *strncpy(char *dest, const char *src, size_t n);
    代码演示:
#include 
#include 

int main()

{
        char *src = "hello";
        char dest[32];

        strncpy(dest, src, sizeof(dest));

        printf("%s\n", dest);

        return 0;
}

执行结果:

hello

字符串格式化输出snprintf

  • int sprintf(char *str, const char *format, …);
  • int snprintf(char *str, size_t size, const char *format, …);

代码示例:

system("ping -c 4 -I eth0 4.2.2.2");
//如果这里的 eth0、4.2.2.2 等是一个变量参数,我们可以使用snprintf()格式化生成该命令:
char cmd_buf[256];
int count = 4;
char *interface="eth0";
char *dst_ip = "4.2.2.2";
snprintf(cmd_buf, sizeof(buf), "ping -c %d -I %s %s", count, interface, dst_ip);
system(cmd_buf);

代码演示:

#include 

int main()
{
        char    buf[32];
        int     i;

        for(i=0; i<5; i++)
        {
                snprintf(buf, sizeof(buf), "aaa[%04d]", i);
                printf("%s\n", buf);
        }

        return 0;
}

执行结果:

aaa[0000]
aaa[0001]
aaa[0002]
aaa[0003]
aaa[0004]

字符串匹配子串/某个字符

  • 匹配字符串:
    char *strstr(const char *haystack, const char *needle);
  • 某个字符:
    char *strchr(const char *s, int c);
    char *strrchr(const char *s, int c);

代码演示:

#include 
#include 

int main()
{
        char    *p;
        char    arr[32] = "hello oo world";
        char    *p1;
        char    *p2;
        char    *p3;

        p = strstr(arr, "world");
        p1 = strchr(arr, 'o');
        p2 = strrchr(arr, 'o');
        p3 = strchr(p1+1, 'o');

        printf(" p: %p\n p1: %p\n p2: %p\n p3: %p\n ", p, p1, p2, p3);

        return 0;
}

输出结果:

p: 0x7fff0b011919
p1: 0x7fff0b011914
p2: 0x7fff0b01191a
p3: 0x7fff0b011916

字符串切割

  • char *strtok(char *str, const char *delim);

代码演示:

#include 
#include 

int main()
{
        char    arr[32]  = "hello:lyt,wq";
        char    s[2] = ",";
        char    *p;

        p = strtok(arr, s);

        printf("%s\n", p);

        return 0;

}

字符串字符串格式化输入 sscanf

  • int sscanf(const char *str, const char *format, …);

代码演示:

#include 
#include 
#include 

int main()
{
   int    day, year, mouth;
   char   today[20], dtm[100];

   strcpy( dtm, "today 2022 3 22" );
   sscanf( dtm, "%s %d %d %d", today, &year, &mouth, &day );

   printf("%d %d %d = %s\n", year, mouth, day, today);

   return(0);
}

执行结果:

2022 3 22 = today

初始化一篇内存的值

  • void *memset(void *s, int c, size_t n);
#include 
#include 


int main()
{
        struct student
        {
                int a;
                int b;
                int c;
        };

        struct student student1;

        printf("%d %d %d\n", student1.a, student1.b, student1.c);

        memset(&student1, 0, sizeof(student1));

        printf("%d %d %d\n", student1.a, student1.b, student1.c);

        return 0;
}

执行结果:

22017 -1487814576 32766
0 0 0

内存拷贝

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


int main()

{
        char arr1[32] = "hello";
        char arr2[32];

        memcpy(arr2, arr1, 32*sizeof(char));

        printf("%s\n", arr2);

        return 0;
}

执行结果:

hello

内存剪切

  • void *memmove(void *dest, const void *src, size_t n);

代码演示:

#include 
#include 

int main ()
{
   char    dest[32] = "old";
   char    src[32] = "new";

   printf("Before dest = %s, src = %s\n", dest, src);
   memmove(dest, src, 32*sizeof(char));
   printf("After dest = %s, src = %s\n", dest, src);

   return(0);
}

执行结果:

Before dest = old, src = new
After dest = new, src = new

内存比较

  • int memcmp(const void *s1, const void *s2, size_t n);

代码演示:

#include 
#include 

int main ()
{
   char str1[15] = "abcaa";
   char str2[15] = "abcda";
   int ret;
   int ret2;

   ret = memcmp(str1, str2, 3);
   ret2 = memcmp(str1, str2, 4);

   printf("%d\n", ret);
   printf("%d\n", ret2);

   return(0);
}

执行结果:

0
-768

3、文件输入和文件输出

fopen

函数定义:

FILE *fopen(const char *filename, const char *mode)

函数功能:

使用给定的模式 mode 打开 filename 所指向的文件。

参数解析:

  • filename:这是 C 字符串,包含了要打开的文件名称。
  • mode:这是 C 字符串,包含了文件访问模式。
mode 说明
r 以只读方式打开文件,该文件必须存在
r+ 以读/写方式打开文件,该文件必须存在
rb+ 以读/写方式打开一个二进制文件,只允许读/写数据,
rt+ 以读/写方式打开一个文本文件,允许读和写。
w 打开只写文件,若文件存在则长度清为0,即文件会消失。若文件不存在则创建文件。
w+ 打开可读/写文件,若文件存在则文件长度清为零,即该文件内容会消失。若文件不存在则创建文件。
a 以附加的方式打开只写文件,若文件不存在,则会创建该文件,如果文件存在,写入的数据会被加到文件尾,即文件应失的内容会被保留(EOF符保留)
a+ 以附加的方式打开可速/写的文件。,若文件不存在,则会创建该文件,如果文件存在,写入的数据会被加到文件尾,即文件应失的内容会被保留(EOF符保留)
wb 以只写方式打开或新建一个二进制文件,只允许写数据。
wb+ 以读/写方式打开或建立一个二进制文件,允许读和写。
wt+ 以读/写方式打开或建立一个文本文件,允许读写。
at+ 以读/写方式打开个文本文件,允许读或在文本末尾追加加数据。
ab+ 以读/写方式打开一个二进制文件,允许读或在文件末尾追加加数据。

getc/putc

#include

int main()
{
   char c;

   c = getc(stdin);
   putc(c, stdout);

   return(0);
}

fscanf/fprintf

  • fscanf
  • int fscanf(FILE *stream, const char *format, …);
#include 
#include 


int main()
{
   char str1[10], str2[10], str3[10];
   int year;
   FILE * fp;

   fp = fopen ("file.txt", "w+");
   fputs("We are in 2022", fp);
   rewind(fp);
   fscanf(fp, "%s %s %s %d", str1, str2, str3, &year);

   printf("String1 :%s\n", str1 );
   printf("String2 :%s\n", str2 );
   printf("String3 :%s\n", str3 );
   printf("Integer :%d\n", year );

   fclose(fp);

   return(0);
}

执行结果:

String1 :We
String2 :are
String3 :in
Integer :2022

  • fprintf
    int fprintf(FILE *stream, const char *format, …);

man ```c
#include

int main()
{
FILE *fd;
fd = fopen(“test.txt”, “w+”);

    fprintf(fd,"%s %s %d", "hello", "world", 2022);

    fclose(fd);

    return 0;

}

fgets/fputs

fgets

函数定义:

char *fgets(char *s, int size, FILE *stream);

函数功能:

  • 从指定的流 stream 读取一行,并把它存储在 str 所指向的字符串内。

返回值:

  • 如果成功,该函数返回相同的 s 参数。如果到达文件末尾或者没有读取到任何字符,s 的内容保持不变,并返回一个空指针。

如果发生错误,返回一个空指针。

参数说明:

  • s:指向一个字符数组的指针,该数组存储读取到的字符串
  • size:这是要读取的最大字符数,通常是 s 的数组长度。
  • stream:这是指向 FILE 对象的指针,该 FILE 对象标识了要从中读取字符的流

代码演示:

#include 

int main()
{
   FILE    *fp;
   char     str[60];

   fp = fopen("file.txt" , "r");
   if (NULL == fp) 
   {
      perror("err");
      return(-1);
   }
   
   if(NULL != fgets (str, 60, fp) ) 
   {
      puts(str);
   }
   fclose(fp);

   return(0);
}

执行结果:

  • file.txt 的内容为 hello

hello

fputs

函数定义:

int fputs(const char *s, FILE *stream);

函数功能:

  • 把字符串写入到指定的流 stream 中,但不包括空字符。

返回值:

  • 该函数返回一个非负值,如果发生错误则返回 EOF。

参数解析:

  • s: 这是一个数组,包含了要写入的以空字符终止的字符序列。
  • stream – 这是指向 FILE 对象的指针,该 FILE 对象标识了要被写入字符串的流

代码演示:


#include 

int main ()
{
   FILE *fp;

   fp = fopen("file.txt", "w+");

   fputs("hello ", fp);
   fputs("world", fp);
   fputs("\n", fp);

   fclose(fp);
   
   return(0);
}

执行结果:

  • cat file.txt

hello world

fread/fwrite

#include 
#include 

int main()
{
   FILE *fp; 
   char c[32] = "hello";
   char buffer[32];

   fp = fopen("file.txt", "w+");

   fwrite(c, 32*sizeof(char), 1, fp);

   fseek(fp, 0, SEEK_SET);O

   fread(buffer, 32*sizeof(char), 1, fp);
   printf("%s\n", buffer);
   fclose(fp);

   printf("%s\n", buffer);

   return(0);
}

fseek

stream – 这是指向 FILE 对象的指针,该 FILE 对象标识了流。
offset – 这是相对 whence 的偏移量,以字节为单位。
whence – 这是表示开始添加偏移 offset 的位置。它一般指定为下列常量之一:
SEEK_SET 文件的开头
SEEK_CUR 文件指针的当前位置
SEEK_END 文件的末尾

#include 
#include 

int main()
{
   FILE *fp;
   char c[32] = "hello";
   char buffer[32];

   fp = fopen("file.txt", "w+");

   fwrite(c, 32*sizeof(char), 1, fp);

   fseek(fp, 0, SEEK_SET);

   fread(buffer, 32*sizeof(char), 1, fp);
   printf("%s\n", buffer);
   fclose(fp);

   printf("%s\n", buffer);

   return(0);
}

ftell

#include 

int main ()
{
   FILE *fp;
   int len;

   fp = fopen("file.txt", "r");
   if( fp == NULL ) 
   {
      perror ("打开文件错误");
      return(-1);
   }
   fseek(fp, 0, SEEK_END);

   len = ftell(fp);
   fclose(fp);

   printf("file.txt 的总大小 = %d 字节\n", len);
   
   return(0);
}

fflush

#include 
#include 
#include 
int main()
{
 
   char buff[1024];
 
   memset( buff, '\0', sizeof( buff ));
 
   fprintf(stdout, "启用全缓冲\n");
   setvbuf(stdout, buff, _IOFBF, 1024);
 
   fprintf(stdout, "这里是 runoob.com\n");
   fprintf(stdout, "该输出将保存到 buff\n");
   fflush( stdout );
 
   fprintf(stdout, "这将在编程时出现\n");
   fprintf(stdout, "最后休眠五秒钟\n");
 
   sleep(5);
 
   return(0);
}

setvbut

  • setvbut
    stream – 这是指向 FILE 对象的指针,该 FILE 对象标识了一个打开的流。
    buffer – 这是分配给用户的缓冲。如果设置为 NULL,该函数会自动分配一个指定大小的缓冲。
    mode – 这指定了文件缓冲的模式:
    模式 描述
    _IOFBF 全缓冲:对于输出,数据在缓冲填满时被一次性写入。对于输入,缓冲会在请求输入且缓冲为空时被填充。
    _IOLBF 行缓冲:对于输出,数据在遇到换行符或者在缓冲填满时被写入,具体视情况而定。对于输入,缓冲会在请求输入且缓冲为空时被填充,直到遇到下一个换行符。
    _IONBF 无缓冲:不使用缓冲。每个 I/O 操作都被即时写入。buffer 和 size 参数被忽略。
#include 
#include 
#include 
int main()
{
 
   char buff[1024];
 
   memset( buff, '\0', sizeof( buff ));
 
   fprintf(stdout, "启用全缓冲\n");
   setvbuf(stdout, buff, _IOFBF, 1024);
 
   fprintf(stdout, "这里是 runoob.com\n");
   fprintf(stdout, "该输出将保存到 buff\n");
   fflush( stdout );
 
   fprintf(stdout, "这将在编程时出现\n");
   fprintf(stdout, "最后休眠五秒钟\n");
 
   sleep(5);
 
   return(0);
}

你可能感兴趣的:(C语言,c语言)