str/文件操作/动态内存分配函数

============================

一、内置的输入输出函数(头文件:stdio.h)

1.读取

getchar—从键盘中获取字符

int getchar ( void );

①参数

• 无

②返回值

• 如果成功,显示出要输入的第一个字符的ASCII码值,并指向下一个字符
• 如果失败,返回EOF

#include <stdio.h>
int main()
{
    int c;
        c = getchar();
        printf("%d",c);
    return 0;
}

getc—从流中获取字符

int getc ( FILE * stream );

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
int main()
{
    FILE* pFile;
    pFile = fopen("myfile.txt", "r");
    if (pFile == NULL) perror("Error opening file");
    else
    {
        printf("%d\n", getc(pFile));
        printf("%d\n", getc(pFile));
        fclose(pFile);
    }
    return 0;
}

这里的70是F的ASCII码值
105是i的ASCII码值

①参数

• 文件输入流

②返回值

• 如果成功,取流中一个字符的ASCII码值,并指向下一个字符
• 如果失败,返回EOF

gets—从键盘获取字符串

char * gets ( char * str );

①参数

• str—指向内存块的指针

②返回值

• 如果成功,返回字符串的指针
• 如果失败,返回EOF

2.写入

putchar—将字符写入标准输出

int putchar ( int character );

①参数

• character—int类型要写入的字符

②返回值

• 如果成功,返回写入的字符的 ASCII码值
• 如果失败,返回EOF

③运行结果

• 返回输入的字符

putc—将字符写入流

int putc ( int character, FILE * stream );

①参数

• int类型要写的字符
• stream—标准输出流

②返回值

• 如果成功,返回写入的字符的ASCII码值
• 如果失败,返回EOF

puts—将字符串写入标准输出流

int puts ( const char * str );

①参数

• 要打印的字符串

②返回值

• 如果成功,返回一个非负值
• 如果失败,返回EOF

③运行结果

• 将写入的字符串输出

3.fflush----- 清除读写缓冲区，在需要立即把输出缓冲区的数据进行物理写入

int fflush(FILE *stream)

返回值：
如果成功刷新,fflush返回0。指定的流没有缓冲区或者只读打开时也返回0值。返回EOF指出一个错误。

============================

二、str函数(头文件:string.h)

1.strlen-------------求字符串长度

int strlen(const char* string)

①参数

• string---------字符串

②返回值

• 字符串长度

③注意事项

• 返回值类型为unsigned int
• 遇到\0结束
• 不包含\0

strlen的模拟实现 - my_strlen

int my_strlen(const char* string) {
assert(string != NULL);
int count = 0;
while (*string) {
string++;
count++;
}
return count;
}

2.strcpy-------------字符串拷贝

将src拷贝在des中

char* my_strcpy(char* des, const char* src)

①参数

• des---------指向要复制内容的目标数组的指针。
• src----------要复制的C字符串。

②返回值

• des的起始地址

③注意事项

• 返回值类型为char*
• 遇到\0结束
• 不包含\0

strcpy的模拟实现 - my_strcpy

char* my_strcpy(char* des, const char* src) {
	assert(des != NULL);
	assert(src != NULL);
	char* ret = des;
	while (*des = *src) {
		des++;
		src++;
	}
	return ret;
}

strncpy-------字符串拷贝

将size大小的src拷贝到des中

char* my_strcpy(char* des, const char* src,size_t size)

①参数

• des---------指向要复制内容的目标数组的指针。
• src----------要复制的C字符串。
• size---------要复制的字符串的大小。

②返回值

• des的起始地址

3.strcat--------------字符串追加

将src追加到des后面

char* my_strcat(char* des, const char* src)

①参数

• des---------指向目标数组的指针
• src----------要追加的字符串

②返回值

• des的起始地址

③注意事项

• 返回值类型为char*
• 遇到\0结束
• des字符串数组需要足够大,大到可以包含des和src数组的追加结果字符串
• 不包含\0

strcat的模拟实现 - my_strcat

char* my_strcat(char* des, const char* src) {
	assert(des != NULL);
	assert(src != NULL);
	char* ret = des;
	while (*des) {
		des++;
	}
	while (*des++ = *src++) {
	}
	return ret;
}

strncat-----------------字符串追加

将固定大小的src追加在des后面

char* my_strncat(char* des, const char* src,size_t size)

①参数

• des--------指向目标数组的指针
• src---------要追加的字符串
• size--------要追加的最大字符数

②返回值

• des的起始地址

③注意事项

• 不将src中\0追加,但追加结束后 + 一个\0

4.strcmp-------------字符串的比较

比较2字符串的ASCII值（一个字符一个字符比较,若相同,找下一个)

int my_strcmp(const char* str1, const char* str2)

①参数

• str1---------要比较的字符串
• str2---------要比较的字符串

②返回值

strcmp的模拟实现 - my_strcmp

int my_strcmp(const char* str1, const char* str2) {
while (*str1 == *str2) {	
if (*str1 = '\0') {
return 0;
}
str1++;
str2++;
}
return *str1 - *str2;
}

strncmp—字符串的比较

比较2字符串size长度的ASCII值

int my_strcmp(const char* str1, const char* str2,size_t size)

①参数

• str1---------要比较的字符串
• str2---------要比较的字符串
• size---------要比较的最大字符数

②返回值

5.strstr----------------查找字符串

将str2在str1中查找,并输出str2及之后的字符串

char* my_strstr(const charstr1, const charstr2)

①参数

• str1---------要扫描的字符串
• str2---------待查找字符串

②返回值

• str1中str2出现时的指针

③注意事项

• 若找不到,返回NULL指针

strstr的模拟实现 - my_strstr

char* my_strstr(const char*str1, const char*str2) {
const char* cp = str1;
const char* c = str2;
const char* s1 = str1;
const char* s2 = str2;
while (*cp) {
s1 = cp;
s2 = c;
while (*s1 == *s2 && *s1 && *s2) {
s1++;
s2++;
}
if (*s2 == '\0') {
return (char*)cp;
}
cp++;
}
return NULL;
}

6.strtok(str,sym)----查找特殊符号

在str1里查找stm(str2为各种字符,例:@),并记录初始地址

char * strtok ( char * str, const char * sym )

①参数

• str1---------要扫描的字符串
• str2---------待查找特殊符号

②返回值

• str1中str2出现时的指针

③注意事项

• 若找不到,返回NULL指针
• 可以指定一个空指针，在这种情况下，该函数将继续扫描以前对该函数的成功调用结束的位置

strtok的应用举例:

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <string.h>
int main()
{
    char str[] = "- This, a sample string.";
    char* pch;
    printf("Splitting string \"%s\" into tokens:\n", str);
    pch = strtok(str, ",.-");
    while (pch != NULL)
    {
        printf("%s\n", pch);
        pch = strtok(NULL, " ,.-");
    }
    return 0;
}

7.strerror(a)---------把错误码翻译成错误信息

char * strerror ( int errnum );

①参数

• errnum----------------错误号

②返回值
指向描述错误errnum的错误字符串的指针。

③注意事项

• errno----------------C语言自带的全局变量,0就是没错,默认在其中放0
• perror(“函数名::realloc”)–输出错误信息(函数名::realloc + “:” + 空格 + 错误信息)

8.strchr--------------字符串中搜索一个字符

const charstrchr(const char str,int character)

①参数

• str----------------要搜索的字符串
• character-----------------要搜索的字符

②返回值

• 这个字符出现在字符串中的位置指针

============================

三、内存操作函数(头文件:string.h)—mem

1.memcpy------------内存块的复制

void * memcpy ( void * destination, const void * source, size_t num );

memcpy的模拟实现:

void * memcpy ( void * dst, const void * src, size_t count)
{
  void * ret = dst;
  assert(dst);
  assert(src);
  /*
   * copy from lower addresses to higher addresses
   */
  while (count--) {
    *(char *)dst = *(char *)src;
    dst = (char *)dst + 1;
    src = (char *)src + 1;
  }
 
  return(ret);
}

①参数

• destination----------指向要复制内容的目标数组的指针
• source---------------指向要复制的数据源的指针
• num------------------要复制的字节数

②返回值

• destination的指针

2.memmove----------移动内存块

void * memmove ( void * destination, const void * source, size_t num );

memmove的模拟实现:

void * memmove ( void * dst, const void * src, size_t count)
{
  void * ret = dst;
​
  if (dst <= src || (char *)dst >= ((char *)src + count)) {
    /*
    * Non-Overlapping Buffers
    * copy from lower addresses to higher addresses
    */
    while (count--) {
        *(char *)dst = *(char *)src;
        dst = (char *)dst + 1;
        src = (char *)src + 1;
   }
 }
  else {
    /*
    * Overlapping Buffers
    * copy from higher addresses to lower addresses
    */
    dst = (char *)dst + count - 1;
    src = (char *)src + count - 1;
​
    while (count--) {
        *(char *)dst = *(char *)src;
        dst = (char *)dst - 1;
        src = (char *)src - 1;
   }
 }
​
  return(ret);
}

①参数

• destination----------------指向要复制内容的目标数组的指针
• source---------------------指向要复制的数据源的指针
• num------------------------要复制的字节数

②返回值

• destination的指针

3.memset-------------内存替换

void * memset ( void * ptr, int value, size_t num );

①参数

• ptr----------------要替换的内存块的指针
• value------------要设置的值
• num-------------要设置几个字节的值

②返回值

• ptr指针

4.memcmp----------内存块的比较

int memcmp ( const void * ptr1, const void * ptr2, size_t num );

①参数

• ptr1----------------要比较内存块的指针
• ptr2----------------要比较内存块的指针
• num---------------要比较的字节数

②返回值

============================

四、文件操作函数(头文件:stdio.h)

1.fopen----------打开文件

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

①参数

• filename---------要打开的文件的名称的字符串

②返回值

• 指向流的指针

③注意事项

• 如果打开失败,返回NULL

2.fclose----------关闭文件

int fclose(FILE* stream)

①参数

• 指向即将关闭的流

②返回值

• 如果已关闭,返回0
• 如果未关闭,返回EOF

③注意事项

• 关闭之后需要将fclose中的指针置为空

stream = NULL

	//文件的打开和关闭
	FILE*ret = fopen("文件的打开和关闭.txt", "r");	
	if (ret == NULL) {
		perror("open file for reading");
		return 1;
	}
	fclose(ret);
	ret = NULL;

3.fputc—把c字符放到stream流中

int fputc(int c,FILE* stream)

①参数

• 要写入的字符
• 输出流

②返回值

• 如果成功,返回被写入的字符
• 如果失败,返回EOF

fputc("h", ret2);

fputs—把str字符串放到stream流中

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

①参数

• 要写入的字符串
• 输出流

②返回值

• 如果成功,返回一个非0的值
• 如果失败,返回EOF

③注意事项

• 遇到\0为止,且\0不被放入

4.fgetc—把字符从stream流中取出

int fgetc ( FILE * stream );

①参数

• 要取出字符的stream流

②返回值

• 如果成功,返回c字符
• 如果失败,返回EOF

fgets—把字符串从stream流中取出

char * fgets ( char * str, int num, FILE * stream );

①参数

• 字符串数组指针
• 要拿到的最大字节数
• 输入流

②返回值

• 如果成功,返回str
• 如果遇到feof,

5.fscanf—把c字符放到stream流中

6.fprintf—把c字符放到stream流中

7.fread—把c字符放到stream流中

8.fwrite—把c字符放到stream流中

============================

五、动态内存分配函数(头文件:stdlib.h)

1.malloc—动态开辟内存空间

void* malloc (size_t size);

①参数

• size---------内存块的大小

②返回值

• 成功时，指向由函数分配的内存块的指针。
• 如果函数未能分配请求的内存块，则空指针会被归还。

2.realloc—重新开辟内存空间

void* realloc (void* ptr, size_t size);

①参数

• ptr---------以前内存块的指针(如果是空指针,相当于malloc,重新分配一个新块)
• size---------内存块的新大小

②返回值

• 指向重新分配的内存块的指针

3.free—释放自己开辟的空间

free(*ptr);

①参数

• ptr---------要释放空间的开始地址

②free函数的解释
free函数就是将指针指定的内存空间释放，如果发现指定的内存空间不是在与malloc匹配的内存空间，free操作就会失败。所以free做的是释放指针指向的用malloc申请的特定的内存空间，而不是指针本身。

4.rand-----生成随机数

使用rand()函数产生1-100以内的随机整数：
int number1 = rand() % 100;

5.srand-----用来设置rand()产生随机数时的随机数种子

srand(time(0));

============================

六、字符分类函数(头文件:ctype.h)

1.iscntrl---------检查c是否是控制字符

int iscntrl ( int c );

①参数

• c:要检查的字符

②返回值

• 如果是控制字符,返回与0不同的值
• 如果不是控制字符,返回0

2.isspace------检查c是否是空白字符

int isspace ( int c );

①参数

• c:要检查的字符

②返回值

• 如果是空白字符,返回与0不同的值
• 如果不是空白字符,返回0

3.isdigit--------检查c是否是十进制数字字符

int isdigit ( int c );

①参数

• c:要检查的字符

②返回值

• 如果是十进制数字字符,返回与0不同的值
• 如果不是十进制数字字符,返回0

4.islower------检查c是否是小写字母

int islower ( int c );

①参数

• c:要检查的字符

②返回值

• 如果是小写字母,返回与0不同的值
• 如果不是小写字母,返回0

5.isupper-----检查c是否是大写字母

int isupper(int c);

①参数

• c:要检查的字符

②返回值

• 如果是大写字母,返回与0不同的值
• 如果不是大写字母,返回0

6.isalpha-----检查c是否是字母

int isalpha(int c);

①参数

②返回值

• 如果是字母,返回与0不同的值
• 如果不是字母,返回0

7.isalnum----检查c是否是字母/数字

int isalnum(int c);

①参数

• c:要检查的字符

②返回值

• 如果是字母/数字,返回与0不同的值
• 如果不是字母/数字,返回0

8.ispunct-----检查c是否是标点符号

int ispunct(int c);

①参数

• c:要检查的字符

②返回值

• 如果是字母/数字以外的图形字符,返回与0不同的值
• 如果不是字母/数字以外的图形字符,返回0

9.isgraph-----检查c是否是图形字符

int isgraph(int c);

①参数

• c:要检查的字符

②返回值

• 如果是图形字符,返回与0不同的值
• 如果不是图形字符,返回0

10.isprint-----检查c是否是可打印字符

int isprint(int c);

①参数

• c:要检查的字符

②返回值

• 如果是可打印字符,返回与0不同的值
• 如果不是可打印字符,返回0

============================

七.数学计算的函数(头文件:math,h)

1.fmax(x,y)

①参数

• x,y要比较大小的两个数

②返回值

• x,y中的较大值

2.fmin(x,y)

①参数

• x,y要比较大小的两个数

②返回值

• x,y中的较小值

3.abs(x)

int abs(int x)

①参数

• x要取绝对值的数

②返回值

• x的绝对值

============================

八.编译器自带的函数

1.qsort------base数组排序

void qsort(void *base, size_t nitems, size_t size, int (*compar)(const void *, const void*))

①参数

• base----- 指向要排序的数组的第一个元素的指针。
• nitems— 由 base 指向的数组中元素的个数。
• size------ 数组中每个元素的大小，以字节为单位。
• compar-- 用来比较两个元素的函数，即函数指针（回调函数）

2.reverse-----旋转

reverse(int* nums,int start,int end)

①参数

• nums-----要旋转的数组的第一个元素的指针
• start-------要旋转的数组的起始地址
• end---------要旋转的数组的结束地址

============================

九.时钟(time.h)

1.clock-----当前的时间(ms)__1000ms = 1s

clock_t clock(void)

//排序所用的时间
time_t begin = clock();
insetSort(copy1,n);
time_t end = clock();
printf("insertSort: %d\n",end - begin);

============================

十.windows头文件(windows.h)

1.Sleep-----睡眠多少s

该函数返回自程序启动起，处理器时钟所使用的时间。

============================

十一.查看进程<sys/types.h>

1.gitpid()-----查看进程id(每次打开id都改变)

2.gitppid()-----查看父进程id(父进程id不变)

============================

十二.系统函数

1.open-----打开文件

mode：创建属性

打开文件的方式

2.read-----读取文件

3.write-----写文件

文件是由数组来管理的

   struct file*fd_array[]

数组fd_array中包含着文件的描述符fd（整数）_0-n
其中，0号文件描述符叫做标准输入
1号描述符叫做标准输出
2号描述符叫做标准错误

fd：文件的描述符
每个文件有个文件的struct
struct file{
//文件的属性信息
//文件的缓冲与存储位置
}

============================

十三.系统函数<unistd.h>

1.dup2-----将oldfd拷贝给newfd，只进行内容的拷贝

int dup2(int oldfd, int newfd);

============================