一、strncpy、strncmp、strncat函数

strncpy函数用于将一个字符串的一部分拷贝到另一个字符串中。

  char* strncpy(char *dest, const char *src, size_t n)
           {
               size_t i;

               for (i = 0; i < n && src[i] != '\0'; i++)
                   dest[i] = src[i];
               for ( ; i < n; i++)
                   dest[i] = '\0';

               return dest;
           }

char *strncpy(char *dest, const char *src, size_t n)
{  
   正常拷贝 
   多了 一个n 
   n < strlen(src)  
     只拷贝前n个字符，最终dest中不会有'\0'
   n == strlen(src)
     正常拷贝 
   n > strlen(src)
   if (n) 拷贝够了次数 
   剩余拷贝 统统补0
   
   思路:
   
   // 结束条件 *src == '\0'
   // n次 拷贝完成没有
} 

 

strncmp函数用于比较两个字符串的前n个字符。

int strncmp(const char *str1, const char *str2, size_t n)
{
    while (n > 0 && (*str1 || *str2)) {
        if (*str1 != *str2) {
            return (*str1 - *str2);
        }
        str1++;
        str2++;
        n--;
    }
    return 0;
}

strncat函数用于将一个字符串的一部分追加到另一个字符串的末尾。

char *strncat(char *dest, const char *src, size_t n)
{
    char *dest_end = dest;
    
    // 查找目标字符串的结尾位置
    while (*dest_end != '\0') {
        dest_end++;
    }
    
    // 拷贝源字符串的前n个字符到目标字符串的结尾
    while (*src != '\0' && n > 0) {
        *dest_end = *src;
        dest_end++;
        src++;
        n--;
    }
    
    // 在目标字符串末尾添加结束符'\0'
    *dest_end = '\0';
    
    return dest;
}

二、回调函数 与 函数指针

回调函数: 通过函数指针调用的函数 叫回调函数  （将一个函数作为参数传递给另一个函数）
 
 技术上: 通过函数指针的实现 
 
 函数指针(指向基类型-为函数类型) 函数类型的指针  

返回类型 (*指针变量名称)(参数列表)

int sum(int a, int b);   //定义的一个两数求和的函数

int (*sum_p)(int, int);   //  定义的一个类型为 int () (int,int)型的函数指针sum_p

sum_ptr = sum;  // 可以将函数名作为地址赋给 函数指针

int result = sum_p(3, 4);   //  然后就可以用函数指针调用 sum（）函数

 函数指针的类型必须与指向的函数的类型匹配，包括返回类型和参数列表的类型

linux内快速排序算法的一个官方函数

  void qsort(void *base, size_t nmemb, size_t size,

                               int (*compar)(const void *, const void *));

• base：指向待排序数组的起始地址的指针。
• nmemb：数组中元素的数量。
• size：每个元素的大小（以字节为单位）。
• compar：指向比较函数的指针。

compar 函数是一个用户定义的比较函数，用于决定数组中两个元素的顺序。它接受两个指向待比较元素的 const void* 类型的指针，并返回一个 整数值。根据返回值的不同，qsort 函数会对数组进行排序。

• 如果返回值小于零，则表示第一个元素应该在第二个元素之前。
• 如果返回值大于零，则表示第一个元素应该在第二个元素之后。
• 如果返回值等于零，则表示第一个元素与第二个元素相等，它们的顺序将不确定。

int compare(const void *a, const void *b) {
    // 将指针转换为要比较的类型
    int *num1 = (int *)a;
    int *num2 = (int *)b;
    
    // 进行比较并返回结果
    return *num1 - *num2;
}


int main(void)
{
        int arr[] = {5, 2, 8, 1, 9};
        size_t len = sizeof(arr) / sizeof(arr[0]);

        qsort(arr, len, sizeof(int), compare);
}

把+ - *   /  做成回调函数 

 

函数指针的数组 

 三、指针+二维数组

int a[3][4]; //本质还是一维数组 
int[4] a[3]; //理解角度 
             //a --数组名 --代表类型 int [3][4]
             //a --代表的值 -- 首元素的地址 -- a[0] 
             //a[0] 的数据类型 int[4]
             //&a[0]--对应的数据类型 int(*)[4] //数组类型 (一维整型数组类型)
             //数组类型的指针 --- 数组指针       

int (*p)[4] = a

p：指向指针的指针，也可以看作是一个二维数组的名称

*(*(p+i) + j)  <=>    a[ i ][ j ]

*(*(p + i) + j) 是获取二维数组中第 i 行、第 j 列的元素的值。

通过将 *(p + i) 得到的指针再加上 j，得到二维数组中 (i, j) 元素的内容。最外层的 * 表示解引用，表示获取指针指向的值。

定义一个二维整型数组，找出数组最大值  

四、区分  字符指针数组 和 二维字符数组 

字符指针数组 char *s[] = {"hello", "world", "china"};

字符指针数组，每个元素都是一个指向字符的指针。

• 在这种情况下，可以通过 s[0]、s[1]、s[2] 等来访问每个字符串。

 二维字符数组 char s[][10] = {"hello", "world", "china"}； 

对字符指针数组的元素进行 排序和查找

 

 

 

int a =10;

int *p =&a;

&p  ——》  int*    // p的类型

int**q = &p;

&q   ——》 q的类型为  int**

int   ***r = &q；

int a = 10;
int *p = &a;
int **q = &p;
int ***r = &q;

printf("%d", *p);   // 输出 10
printf("%d", **q);  // 输出 10
printf("%d", ***r); // 输出 10