【C语言】刷题知识点总结

目录

• 1. char * 与 char **
• 2.strcmp（）字符串比较函数
• 3.strcat_s（）连接两个字符串的函数
• 4.strtok() 分解字符串为一组字符串
• 5.qsort中cmp的各种写法
• • 5.1 数组排序
  • 5.2 结构体排序
• fabs( ) 求浮点数的绝对值
• *str 和 **str
• isalpha()
• tolower()
• 再看一下qsort和cmp的用法
• 申请数组的3种方式
• • int a[10];
  • malloc
  • calloc
  • malloc 和 calloc 的区别
  • 例子
• 数组初始化的几种方式
• • memset_s
  • int a[10] = {0}
• 浮点数转化为整数
• • 1.直接强转
  • 2.通过强制类型转换四舍五入

1. char * 与 char **

char * :是一个保存字符串首地址的指针变量
char**：为二级指针，是一个指向指针的指针，但是具体的意义还需要再探讨

如

void EnCnt(int len, int *cnt1, char **tmp)//char **tmp是什么意思，int *cnt1又是什么意思
{
    for(int j = 0; j < len; j++)
    {
        for(int i = 0; i < NUM_11; i++)
        {
            if(strcmp(tmp[j], EnglishNum[i]) == 0)
            {
                (*cnt1)++;    //数英语数字个数
            }
        }
    }
}

2.strcmp（）字符串比较函数

用于比较两个字符串并根据比较结果返回整数。基本形式为strcmp(str1,str2)，若str1=str2，则返回零；若str1str2，则返回正数

3.strcat_s（）连接两个字符串的函数

errno_t strcat_s(char *Destination, size_t SizeInBytes ,const char *Source);
Destnation 被添加字符串
SizeInBytes 字节(注:内容大小不能超过这个数)
Sourse添加的字符串

strcat_s(str1 , 1024 ,str2);
运行后str1→str1str2；

4.strtok() 分解字符串为一组字符串

char *strtok(char s[], const char *delim);

实例：

#include 
#include 
 
int main () {
   char str[80] = "This is - www.runoob.com - website";
   const char s[2] = "-";
   char *token;
   
   /* 获取第一个子字符串 */
   token = strtok(str, s);
   
   /* 继续获取其他的子字符串 */
   while( token != NULL ) {
      printf( "%s\n", token );
    
      token = strtok(NULL, s);
   }
   
   return(0);
}

让我们编译上述程序，将获得以下结果：

s为要分解的字符串，delim为分隔符字符（如果传入字符串，则传入的字符串中每个字符均为分割符）。首次调用时，s指向要分解的字符串，之后再次调用要把s设成NULL。

例如：strtok(“abc,def,ghi”,“,”)，最后可以分割成为abc def ghi.尤其在点分十进制的IP中提取应用较多。

5.qsort中cmp的各种写法

注意 cmp函数一定要写成下列形式，否则会报错

int cmp(const void *a, const void *b)

如果返回负数，说明a排在b前面

如果返回正数，说明a排在b后面

如果返回0，说明a和b无先后关系

所以如果要从小到大排则返回 ((int)a) - ((int)b)

如果从大到小则返回 ((int)b) - ((int)a)

5.1 数组排序

例子1，给出一个数组，从小到大升序排列

arr[5] = {1, 3, 2, 5, 4};

int cmp(const void *a, const void *b) {
    return *(int *)a - *(int *)b;// 升序
}
 
qsort(arr, arrLen, sizeof(int), cmp);

5.2 结构体排序

例子2，给出一个结构体，里面有长度和优先级，以优先级为主按升序排列，优先级相同时按长度升序排列

typedef struct o {
    int length;
    int pri;
}Tel;

int cmp(const  void *a, const void *b)//cmp的参数一定要写成const void *a 否则会报错
	{
    Tel A =*(Tel *)a;//这么处理的意义是啥  强转
    Tel B =*(Tel *)b;//这么处理的意义是啥
    if(A.pri > B.pri){
        return 1;
    }
    else if (A.pri < B.pri) {
        return -1;
    }
    else {
        return A.length >= B.length ? 1 : -1;
    }
}

num[5] = {50, 20, 30, 10, 50};
pri[5] = {2, 2, 1, 3, 1};

 Tel *buf = (Tel *)malloc(sizeof(Tel) * num);//为什么要用Tel *buf,还要注意C语言每次使用XX前都要malloc申请内存  也许是结构体数组
 for (int i = 0; i < num; i++) {
        buf[i].length = bill[i];
        buf[i].pri = pri[i];
    }

qsort(buf, num, sizeof(buf[0]), cmp);//记录一下qsort是如何使用的

fabs( ) 求浮点数的绝对值

double fabs(double x)；

int StrCheck(char *strs, char *out)//函数参数里 *strs是什么意思
{
/*handle*/
}

while (*strs == ' ') { // 语句里*str是什么意思
        strs++; // str++又是什么意思
    }

 *out++ = (char)tolower(*strs++); // *和++的优先级

*str 和 **str isalpha()

if (!isalpha(*strs)) { //判断strs的首字母是否为英文字母
        return -1;
    }

判断字符ch是否为英文字母，若为英文字母，返回非0（小写字母为2，大写字母为1）。若不是字母，返回0

tolower()

功能是把字母字符转换成小写，非字母字符不做出处理

 *out++ = (char)tolower(*strs++); // 记录一下tolower

再看一下qsort和cmp的用法

int cmp(const void *a, const void *b) {
    int ret;
    ret = strncmp((char *)a, (char *)b, BUF_LEN); // 为啥是 BUF_LEN，另外 需要看一下(char *)转换对不对 strncmp是啥意思
    if (ret == 0) {
        *(char *)b = ';'// 转换看一看 }
    return
    ; ret}
qsort

 (,s, nsizeof (char)* , BUF_LEN) cmp;int

申请数组的3种方式 int a[10];

[ tmp10]= 0 {};int

malloc

* = tmp ( int* )malloc(*a1Len * a2Len sizeof (int));int

calloc

* =result ( int* )calloc(1,(  *a1Len ) a2Len* sizeof (int));int

malloc 和 calloc 的区别

函数malloc()和calloc()都可以用来动态分配内存空间,但两者稍有区别。

malloc()函数有一个参数,即要分配的内存空间的大小:
void *malloc(size_t size);
calloc()函数有两个参数,分别为元素的数目和每个元素的大小,这两个参数的乘积就是要分配的内存空间的大小。
void *calloc(size_t numElements,size_t sizeOfElement);

如果调用成功,函数malloc()和函数calloc()都将返回所分配的内存空间的首地址。
函数malloc()和函数calloc()的主要区别是前者不能初始化所分配的内存空间,而后者能。
如果由malloc()函数分配的内存空间原来没有被使用过，则其中的每一位可能都是0;反之,如果这部分内存曾经被分配过,则其中可能遗留有各种各样的数据。也就是说，使用malloc()函数的程序开始时(内存空间还没有被重新分配)能正常进行,但经过一段时间(内存空间还已经被重新分配)可能会出现问题。
函数calloc()会将所分配的内存空间中的每一位都初始化为零,也就是说,如果你是为字符类型或整数类型的元素分配内存,那麽这些元素将保证会被初始化为0;如果你是为指针类型的元素分配内存,那麽这些元素通常会被初始化为空指针;如果你为实型数据分配内存,则这些元素会被初始化为浮点型的零。

例子

以1812.矩阵列的最大值中的最小值为例

cmp (constvoid * ,aconst void * )breturn 
{
    * (int* )<a * (int* );b}
int

GetTheMinWithColMaxs (int* *,matrixint , nint ) m// 在此添加你的代码
{
    int
    = lie_Max ; INT_MIN// 申请一个大小为m的数组A
    int
    * =tmp ( int*)malloc(*m sizeof (int));// 遍历矩阵，把每列的最大值保存到数组A中
    for
    ( int= j 0 ;< j ; m++ j)for {
        ( int= i 0 ;< i ; n++ i)if {
            ([matrix]i[j]) > lie_Max= {
                lie_Max [ matrix]i[j];}
            }
        [
        tmp]j= ; lie_Max=
        lie_Max ; INT_MIN}
    // 把数组A排序
    qsort
    (,tmp, msizeof (int)* , m) cmp;// 输出最小值
    return
    [ tmp0];}
    
int

这里申请数组有问题，数组的初始化不清楚，导致排序后的结果错误，体现为某些数组成员被随机初始化了

直接

[ tmp10]= 0 {};memset_s

即可申请长度为10，内容为0的数组。

数组初始化的几种方式 memset_s

(,output, outputSize0 ,) outputSize;int

int a[10] = {0}

[ a10]= 0 {};float

浮点数转化为整数 1.直接强转

= f 1.5 ;int
; a=
a ( int);fNSLog
("a = %d",)a;float

输出结果是1。（int）是强制类型转化，丢弃浮点数的小数部分。

2.通过强制类型转换四舍五入

= f 1.5 ;int
; a=
a ( int)(+f0.5);NSLog
("a = %d",)a;

输出结果是2。