【函数】内联函数、库函数

函数

内联函数

声明：inline void fun（参数）{函数体}
为什么使用？

1）一般函数的代码段只有一份，放在内存中的某个位置上，当程序调用它是，指令就跳转过来；当下一次程序调用它时，指令又跳转过来；而内联函数是程序中调用几次内联函数，内联函数的代码就会复制几份放在对应的位置上
2）如果调用的函数代码量很少，也许转移到调用函数的时间比函数执行的时间更长。而如果使用内联函数，内联函数会在调用处将代码展开，从而节省了调用函数的开销。
3）弊：代码被多次复制，增加了代码量，占用更多的内存空间

关于类与内联函数（c++）
1）类内定义的函数都是内联函数，不管是否有inline修饰符

2）函数声明在类内，但定义在类外的看是否有inline修饰符，如果有就是内联函数，否则不是

库函数

内存操作函数

1）memcpy
void memcpy (void s1, const void* s2, size_t n);
将s2中n个__字节__的内容复制到s1中

#include<string.h>//memcpy
#include<stdio.h>

int main()
{
        int arr[5]={1,2,3,4,5};
        int arr1[5]={0};

        memcpy(arr1,arr,5*sizeof(int));
        int i;
        for(i=0;i<5;i++)
                printf("arr1[%d]=%d\n",i,arr1[i]);

        return 0;
}

模拟实现

void m_memcpy(void* obj,void src,size_t n)
{
	while(n--)
	{
		*(char*)obj=*(char*)src;
		obj=(char*)obj+1;
		src=(char*)src+1;
	}
}

2）memmove

和memcpy差不多，但比memcpy强，可以在同一个空间内操作而不会重叠

3）int memcmp(const void *s1, const void *s2, size_t n);
-------将前n个字节进行比较
4）void *memset(void *s, int c, size_t n);//一般用来初始化，将s中的前n个字节逐个赋为c
对于初始非字符类，只能赋0或-1
原因：按单个字节赋值，如int四个字节，每个字节都为0000 0001，所以得不到准确的值
故只能存全0或全1，而机器又是以补码形式存储，全0对应0，全1对应-1

字符数组初始化
char ch[4];
ch[3]=0;//赋予结束符
memset(ch,'a',3*sizeof(char));//对每个字节赋予'a'
数组初始化
Stu stu2[10]; //数组
memset(stu2, 0, sizeof(Stu)*10);

排序函数

-----qsort（快速排序，stdlib.h）
void qsort(void* obj,size_t num,size_t width,int(p)(void s1,void* s1));
obj指向要排序的空间，num为元素个数，width为每个元素的字节大小
p为函数指针，指向一个返回整型的比较函数（大于返回正整数，小于返回负整数，等于返回0）

例子：创建一个结构体，成员为int id和float goal，分别对其进行排序

#include<stdio.h> 
#include<stdlib.h> 
typedef struct 
{ 
        int id; 
        float goal; 
}St;//St为别名 
//比较id，传入qSort的函数指针的形式为int(*p)(void* s1,void* s) 
int cm_id(const St* s1,const St* s2) 
{ 
        int a=s1->id; 
        int b=s2->id; 
        return a-b; 
} 
//比较goal 
int cm_goal(St* s1,St* s2) 
{ 
        float a=s1->goal; 
        float b=s2->goal;//float加减运算时精度会丢失 
        if(a<b) 
                return -1; 
        else if(a>b) 
                return 1; 
        else 
                return 0; 
} 
//打印结构体数组 
void print_St(St* s,size_t n) 
{ 
        int i=n; 
        while(i) 
        { 
                printf("id:%d,goal:%f\n",s[n-i].id,s[n-i].goal); 
                i--; 
        } 
} 
 
 
int main() 
{ 
        St st[]={{1001,80},{1003,85},{1002,90},{1007,87},{1004,83}}; 
        //调用qsort，qsort(目标指针,元素个数,单个元素的字节大小,函数指针) 
        //函数指针指向一个返回整型返回值的比较函数（大于则返回正整数，小于返回负整数，等于返回0） 
        //比较goal 
        printf("sort goal:\n");  
        qsort(st,sizeof(st)/sizeof(St),sizeof(St),cm_goal);      
        print_St(st,5); 
        //比较id 
        printf("sort id:\n");    
        qsort(st,sizeof(st)/sizeof(St),sizeof(St),cm_id);        
        print_St(st,5); 
         
        printf("sizeof(st)=%ld\n",sizeof(st)); 
        printf("sizeof(St)=%ld\n",sizeof(St)); 
        printf("num=%ld\n",sizeof(st)/sizeof(St)); 
             
        return 0; 
}

字符函数

1、字符数字转为数字

#include <stdlib.h>
       int atoi(const char *nptr);
       long atol(const char *nptr);
       double atof(const char *nptr);

2、字符操作

#include <string.h>

       char *strcpy(char *dest, const char *src);//将src复制到dest

       char *strncpy(char *dest, const char *src, size_t n);//将src的前n个字符赋予dest
	   
	   char *strcat(char *dest, const char *src);//将src追加到dest后面

       char *strncat(char *dest, const char *src, size_t n);//将src的前n个字符追加到dest后

       size_t strlen(const char *s);//获取s的长度
以下函数返回void指针，可以用强制转换赋给其他	   
       void *memchr(const void *s, int c, size_t n);//在参数 str 所指向的字符串的前 n 个字节中搜索第一次出现字符 c，并返回其地址

linux查找库函数

man 3 xxx(3：系统第三本手册，xxx:库函数名)