字符与串与字符串

复习：

指针数组与数组指针：

​ 指针数组：成员是指针的数组

​ int* arr[10];

​ 数组指针：专门用于指向数组的指针

​ int (*arr)[10];

指针与数组名的区别：

​ ​ 数组名是数组的首地址，数组名与数组的内存之间是映射关系，相当于一个特殊的指

针，是常量，是不能修改的

​ ​ 数组作为函数参数时，会蜕变成指针，所以长度才会丢失，因此需要额外传递长度参数

​ ​ 所以数组名是可以解引用的，如果指针指向数组，指针可以使用中括号来使用，也就

是指针可以当作数组使用

​ ​ 数组名与内存是映射关系，指针与内存是指向关系

二级指针：

二级指针就是指向指针的指针，用来存储一级指针变量的地址

定义： 类型** pp

赋值： pp = &指针变量；

解引用：*pp = 指针变量 == &普通变量

​ ​ ​ ​ **pp = *指针变量 == 普通变量

注意：当需要共享指针变量时，才需要使用二级指针

函数指针：

函数指针就是专门指向函数的指针

函数名就是函数在代码段中的内存首地址

调用函数本质就是跳转到函数所在代码段中的位置，执行二进制指令

函数指针存储的也是函数的首地址，因此对函数指针解引用，相当于调用函数

把函数指针当函数一样使用

但是回调函数就需要传递函数指针

​
​ ​ 定义函数指针：

​ ​ ​ ​ 返回值(*函数指针名)(类型1，类型2，。。。)

​ ​ 赋值：

​ ​ ​ ​ 函数指针名 = 函数名；

​ ​ 调用：

​ ​ ​ ​ 函数指针名（实参）；

堆内存管理：

C语言没有管理堆内存的语句，只能使用标准C库中的函数

malloc free

​

注意：void 在C++编译器中不饿能自动转换成其它类型的指针，因此必须要强制类型转换

​ ​ free

​ ​ ​ ​ 功能：释放一块堆内存

​ ​ ​ ​ 注意：可以释放空指针，不能重复释放，也不能释放非法地址

​

常见的面试题：

​ ​ 1、堆内存与栈内存的区别？

​ ​ ​ ​ 本质、由谁管理、大小、使用情况、安全性、优缺点

​ ​ 2、堆内存越界的后果

​ ​ ​ ​ 超过33页产生段错误

​ ​ ​ ​ 破坏了malloc的维护信息，再次使用malloc或free会报错

​ ​ ​ ​ 脏数据
​
 ​ 3、什么是内存泄漏？如何定位内存泄漏？

​ ​ 由于业务逻辑出错、粗心大意，导致使用完毕后的堆内存没有被释放，当再次使用时

又重新申请同样的内存，又没有释放,长时间积累导致可用的内存越来越少，系统会越来

越慢，甚至崩溃，这叫做内存泄漏

​ ​ ​ ​ 1、windows查看任务管理器，Linux通过ps -aux命令，定位泄漏的程序

​ ​ ​ ​ 2、使用mtrace内存分析工具，检查是否存在没有释放的堆内存

​ ​ ​ ​ 3、封装malloc、free，记录malloc、free使用情况到日志

​ ​ ​ ​ 4、什么是内存碎片？如何减少内存碎片？

​ ​ ​ ​ ​ ​ 已经释放但是也无法使用的内存叫做内存碎片，由于申请和释放的时间、大小的差异与不协调导致

内存清理函数：

		bzero
#include <strings.h>

void bzero(void *s, size_t n);

		功能：把一块内存清理为0

		s：要清理的内存块的首地址

		n：内存块的字节数



		memset
#include <string.h>

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

		功能：对内存块按字节设置为c

		s：内存块的首地址

		c：想要设置成的ASCII码值

		n：内存块的字节数

		返回值：设置成功后的内存首地址

堆内存定义二维数组：

指针数组：定义 n*m的二维数组

类型* arr[n];

for(int i =0;i<n;i++)
{
	arr[i] = malloc(sizeof(类型)*m);
    //容易产生内存碎片
}
//注意：每行的m值可以不同，能实现不规则的二位数组

​ 数组指针：

类型 （*arrp）[m] = malloc(sizeof(类型)*m*n);
//对内存要求高

注意：所谓的多维数组都是用一维数组模拟的

练习1：计算出100~10000之间的素数，把结果存到堆内存中，要求不能浪费堆内存

​ ​ 1、算出个数，申请内存，再次计算存入数据 malloc

​ ​ 2、一边算，一边扩容 realloc

#include <stdio.h>
#include <stdlib.h>
int main(int argc,const char* argv[])
{
    int cnt =0,i=0,j=0;
    int* arr = NULL;
    for(i=100;i<=1000;i++)
    {   
        for(j =2;j<=i-1;j++)
        {
            if(i%j == 0)
            {
                break;
            }
        }
        if(i == j)
        {
            arr = realloc(arr,sizeof(int)*(cnt+1));
            arr[cnt++] = i;  
        }
    }   
    for(i = 0;i<cnt;i++)
    {   
        printf("%d ",arr[i]);   
    }   
    free(arr);
    arr = NULL;
    return 0;
}

字符：

​ ​ 在计算机中是以整型形式存储的，当需要显示时会根据ASCII表中的对应关系显示出相应的符号或图案

'\0' = 0	
'0'  = 48
'A'  = 65	
'a'  = 97
%c	   %d

​ ​ 字符的输入：

​ ​ ​ ​ scanf（”%c“，&ch）；

​ ​ ​ ​ ch = getchar（）；

​ ​ 字符的输出：

​ ​ ​ ​ printf（”%c“，ch）；

​ ​ ​ ​ putchar（ch）；

串：

​ ​ 是一种数据结构，是由一组类型相同的若干个数据组成，末尾由结束标志

​ ​ 对于这种数据结构的处理都是批量性的，从开头位置一直处理到结束标志

字符串：

​ ​ 由字符组成的串型结构，结束标志是 ‘\0’

​ ​ ​ ​ 字符串的输入：

scanf("%s",地址);	缺点：不能输入空格

char *gets(char *s);
//功能：输入字符串，并且可以接收空格
//返回值：链式调用（把一个函数的执行结果通过返回值作为另一个函数的参数）

char *fgets(char *s,int size,FILE *stream);
//功能：可以设置输入的字符串长度为size-1，超出部分不会接收，它会为'\0'预留位置
//s：内存首地址
//size：字节数
//stream：stdin
注意：如果输入的字符不足size-1，最后的\n会被一起接收

​ ​ ​ ​ 字符串的输出：

printf("%s\n",str)；

int puts(const char *s);
//功能：输出一个字符串，会在末尾自动添加一个\n
//返回值：成功输出的字符个数

​
字符串的存在形式：

​ ​ 字符数组：

​ ​ ​ ​ char str[10] = {‘a’,‘b’,‘c’,‘d’,…};

​ ​ ​ ​ 由char类型组成的数组，要为’\0’预留位置，初始化麻烦

​ ​ ​ ​ 使用的是栈内存，数据可以随意修改

​ ​ 字符串字面值：

​ ​ ​ ​ 由” “双引号包含的若干个字符

​ ​ ​ ​ 在末尾隐藏一个 ‘\0’

​ ​ ​ ​ 字符串字面值是以地址形式存在的，数据存储在代码段中，如果修改就会段错误

注意：它的结束标志是加在末尾的

printf("%d\n",sizeof("123123"));
//注意：字符个数+1
printf("%d\n",sizeof(p));
//注意：指针的字节数 4|8

多个一模一样的字符串字面值在代码段只有一份

常用方式：

​ ​ 字符数组[ ] = “字符串字面值”；

​ ​ 会自动给’\0’预留位置

​ ​ 赋值完成后，字符串会存在两份，一份在代码段，另一份在栈内存中（可以任意修改）

练习2：实现一个函数，判断字符串是否是回文串

#include <stdio.h>
#include <stdbool.h>

bool back(const char*str)
{
    int n =0; 
    while(str[n]) n++;
    for(int i=0;i<n/2;i++)
    {   
        if(str[i] != str[n-1-i])
        {
            return false;   
        }
    }   
    return true;
}
int main(int argc,const char* argv[])
{
    char str[256] = {}; 
    gets(str);
    printf("%d\n",back(str));
}

练习3：实现一个函数，把数字组成的字符串转换成整数

#include <stdio.h>

int change(const char* str)
{
    int num=0;
    while(*str && '0'<= *str && '9'>=*str)
    {   
        num = num*10+*str-'0';
        str++;
    }   
    return num;
}
int main(int argc,const char* argv[])
{
    char str[256] = {}; 
    gets(str);
    printf("%d\n",change(str));
}

练习4：实现一个函数，把一个字符串逆序

#include <stdio.h>

char* back_oder(char* str)
{
    size_t len =0; 
    while(str[len]) len++;
    for(int i=0;i<len/2;i++)
    {   
        char tmp = str[i];
        str[i] = str[len-1-i];
        str[len-1-i] = tmp;
    }   
    return str;
}
int main(int argc,const char* argv[])
{
    char str[256] = {}; 
    puts(back_oder(gets(str)));
}