C语言 13.

最新推荐文章于 2023-08-11 11:57:50 发布
最新推荐文章于 2023-08-11 11:57:50 发布
阅读量213 收藏
点赞数
分类专栏： C语言 文章标签： c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44684289/article/details/123929527
版权

1.calloc 和 realloc

1.1calloc 和malloc 都是在堆区分配内存

1.2与malloc不同的是，calloc会将空间初始化为0

1.3calloc（个数，大小）

1.4realloc 重新分配内存

1.4.1如果重新分配的内存比原来大，那么不会初始化新空间为0

1.4.2先看后续空间，如果足够，那么直接扩展

1.4.3如果后续空闲空间不足，那么申请足够大的空间，将原有数据拷贝到新空间下，释放掉原有空间，将新空间的首地址返回

1.4.4如果重新分配的内存比原来小，那么释放后序空间，只有权限操作申请空间


//calloc
void test01()
{
    //int * p = malloc(sizeof(int)* 10);   //  没有初始化操作，打印出来会是乱码
    int * p = calloc(10, sizeof(int)); //calloc 分配在堆区，与malloc不同的是 calloc会初始化数据为0
    for (int i = 0; i < 10;i++)
    {
        printf("%d\n", p[i]);
    }
    if ( p != NULL)
    {
        free(p);
        p = NULL;
    }
}
//realloc  重新分配内存
void test02()
{
    int * p = malloc(sizeof(int)* 10);    // 先分配一个小内存
    for (int i = 0; i < 10;i++)
    {
        p[i] = i + 100;
    }
    for (int i = 0; i < 10; i++)
    {
        printf("%d\n", p[i]);
    }
    printf("%d\n", p);
    //如果重新分配的内存比原来大，那么不会初始化新空间为0
    p = realloc(p, sizeof(int)* 20)    // P代表首地址，第二个参数代表大小，返回一个新的地址
    printf("%d\n", p);
    for (int i = 0; i < 20; i++)
    {
        printf("%d\n", p[i]);
    }
    //如果重新分配的内存比原来小，那么释放后序空间，只有权限操作申请空间
    p = realloc(p, sizeof(int)* 5);
    printf("%d\n", p);
    printf("%d\n", p[0]);
    printf("%d\n", p[5]);      // 这里是乱码
}

在这里插入图片描述

2.sscanf的使用

符号作用
%*s或%*d跳过数据
%[width]s读指定宽度的数据
%[a-z]匹配a到z中任意字符(尽可能多的匹配)
%[aBc]匹配a、B、c中一员，贪婪性
%[^a]匹配非a的任意字符，贪婪性
%[^a-z]表示读取除a-z以外的所有字符

2.1练习

2.1.1将 ip 分别截取到 num1 到 num4中

2.1.2将 123456#zhangtao@abcde 中截取中间的zhangtao有效数据


#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
//1、%*s或%*d    跳过数据
void test01()
{
    char * str = "12345abcde";
    char buf[1024] = { 0 };
    sscanf(str, "%*d%s", buf);    // 这一步做操作，不输出数据
    printf("%s\n", buf);      //  abcde 
}
void test02()
{
    char * str = "abcde12345"; //忽略遇到空格或者 \t 代表忽略结束
    char buf[1024] = { 0 };
    sscanf(str, "%*[a-z]%s", buf);     // 把a-z之间的数字忽略掉，然后匹配输出
    //sscanf(str, "%*s%s", buf);        // 什么都没有
    printf("%s\n", buf);
}
//%[width]s    读指定宽度的数据
void test03()
{
    char * str = "12345abcde";
    char buf[1024] = { 0 };
    sscanf(str, "%6s", buf);   // 12345a
    printf("%s\n", buf);
}
//%[a-z]    匹配a到z中任意字符(尽可能多的匹配)
void test04()
{
    char * str = "12345abcdeaaa";
    char buf[1024] = { 0 };
    sscanf(str,"%*d%[a-c]", buf); //只要匹配失败，那么就不继续匹配了
    printf("%s\n", buf);    // abc
}
void test05()
{
    char * str = "12345abcdeaaa";
    char buf[1024] = { 0 };
    sscanf(str, "%[0-9]", buf); //只要匹配失败，那么就不继续匹配了
    printf("%s\n", buf);    // 12345
}
//%[aBc]    匹配a、B、c中一员，贪婪性(只匹配这几个，不是这几个都不需要匹配)
void test06()
{
    char * str = "abcCdef";
    char buf[1024] = { 0 };
    sscanf(str, "%[abC]", buf); //只要匹配失败，那么就不继续匹配了
    printf("%s\n", buf);  // ab
}
//%[^a]     匹配非a的任意字符，贪婪性
void test07()
{
    char * str = "abcCdef";
    char buf[1024] = { 0 };
    sscanf(str, "%[^C]", buf); 
    printf("%s\n", buf);         // abc
}
//%[^a-z]    表示读取除a-z以外的所有字符
void test08()
{
    char * str = "abcCdef123456";
    char buf[1024] = { 0 };
    sscanf(str, "%[^0-9]", buf);   // abcCdef
    printf("%s\n", buf);
}
//练习1  把ip地址里的数字都单独拿出来
void test09()
{
    char * ip = "127.0.0.1";
    int num1 = 0;
    int num2 = 0;
    int num3 = 0;
    int num4 = 0;
    sscanf(ip, "%d.%d.%d.%d", &num1, &num2, &num3, &num4);
    printf("%d\n", num1);
    printf("%d\n", num2);
    printf("%d\n", num3);
    printf("%d\n", num4);
}
//练习2   输出#和@之间的有效字符
void test10()
{
    char * str = "abcdef#zhangtao@123456";
    char buf[1024] = { 0 };
    sscanf(str, "%*[^#]#%[^@]", buf);   // * 表示忽略  [^#]忽略#之外的符号（到#时这个忽略停止工作）  #：忽略#    %[^@]匹配@符号之外的符号（到@时停止工作，后面的也不再匹配）
           //   %*[^#]%*#  忽略     %[^@]匹配
    printf("%s\n", buf);    //    zhangtao
}
//1.    已给定字符串为: helloworld@itcast.cn,请编码实现helloworld输出和itcast.cn输出。
void test11()
{
    char * str = "helloworld@itcast.cn";
    char buf1[1024] = { 0 };
    char buf2[1024] = { 0 };
    sscanf(str, "%[a-z]%*[@]%s", buf1, buf2);   // 两个匹配之间夹了一个忽略
    printf("%s\n", buf1);
    printf("%s\n", buf2);
}

3.查找子串

3.1实现mystrstr 自己查找子串功能
在这里插入图片描述

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
/*
    算法优化
    memcmp(str , subStr ,3 ) == 0;    //内存的对比机制
*/
int myStrstr(char * str , char * subStr)
{
    int num = 0;
    while (*str != '\0')
    {
        if (*str != *subStr)
        {
            num++;
            str++;
            continue;
        }
        //创建两个临时指针 做二次对比
        char * tmpStr = str;
        char * tmpSubstr = subStr;
        while (*tmpSubstr != '\0')
        {
            if (*tmpStr != *tmpSubstr)
            {
                //匹配失败
                num++;
                str++;
                break;
            }
            tmpStr++;
            tmpSubstr++;
        }
        if (*tmpSubstr == '\0')
        {
            //匹配成功
            return num;
        }
    }
    return -1;
}
void test01()
{
    char * str = "abdnfcdefgdfasdfaf";
    int ret = myStrstr(str, "dnf");
    if ( ret != -1)
    {
        printf("找到了子串，位置为：%d\n", ret);
    }
    else
    {
        printf("未找到子串\n");
    }
}
int main(){
    test01();
    system("pause");
    return EXIT_SUCCESS;
}

4指针的易错点

4.1越界

4.2指针叠加会不断改变指针指向

4.3返回局部变量地址

4.4同一块内存释放多次（不可以释放野指针）


void test01()
{
    char * p = malloc(sizeof(char)* 64);
    char * pp = p; //通过创建临时指针操作内存，防止出错
    for (int i = 0; i < 10;i++)
    {
        *pp = i + 97;  // 原本是*p = i+97
        printf("%c\n", *pp);
        pp++; //更改指针位置，释放出错
    }
    if (p!= NULL)
    {
        free(p);
    }
}

5const使用场景

5.1const使用 修饰形参 防止误操作



struct Person
{
    char name[64]; // 0 ~ 63
    int age; // 64 ~ 67
    int Id;  // 68 ~ 71
    double score; // 72 ~79
};
//将struct Person p 改为 struct Person * p  节省资源，但是指针容易误操作
//const使用  修饰形参 防止误操作
void showPerson(const struct Person *p)   // 这个函数目的只是为了打印，不能有数字的更改
{
    // 如果使用 struct Person p  值传递，不会更改本体，但是每次都要占用很大的内存
    //p.age = 100;      
    //p->age = 100;   // 指针访问指针用->
    //printf("姓名： %s  年龄： %d  学号 %d  分数 %f\n", p.name, p.age, p.Id, p.score);
    printf("姓名： %s  年龄： %d  学号 %d  分数 %f\n", p->name, p->age, p->Id, p->score);
}

6二级指针做函数参数的输入输出特性

6.1二级指针做函数参数的输入特性

6.1.1创建在堆区

6.1.2创建在栈区

6.2二级指针做函数参数的输出特性

6.2.1被调函数分配内存，主调函数使用
在这里插入图片描述
在这里插入图片描述

void printArray(int ** pArray , int len)
{
    for (int i = 0; i < len;i++)
    {
        printf("%d\n", *pArray[i]);
    }
}
void test01()
{
    //创建在堆区
    int ** pArray = malloc(sizeof(int *)* 5);
    //在栈上创建5个数据
    int a1 = 10;
    int a2 = 20;
    int a3 = 30;
    int a4 = 40;
    int a5 = 50;
    pArray[0] = &a1;
    pArray[1] = &a2;
    pArray[2] = &a3;
    pArray[3] = &a4;
    pArray[4] = &a5;
    //打印数组
    printArray(pArray, 5);
    //释放堆区数据
    if (pArray != NULL)
    {
        free(pArray);
        pArray = NULL;
    }
}
void freeSpace(int **pArray , int len)
{
    for (int i = 0; i < len;i++)
    {
        free(pArray[i]);
        pArray[i] = NULL;
    }
}
void test02()
{
    //创建在栈区
    int * pArray[5];
    for (int i = 0; i < 5;i++)
    {
        pArray[i] = malloc(4);
        *(pArray[i]) = 10 + i;
    }
    printArray(pArray, 5);
    //释放堆区
    freeSpace(pArray,5);
}
```c
void allocateSpace(int ** p)
{
    int *  temp = malloc(sizeof(int)* 10);
    for (int i = 0; i < 10;i++)
    {
        temp[i] = 100 + i;
    }
    *p = temp;
}
void printArray(int ** pArray, int len)
{
    for (int i = 0; i < len;i++)
    {
        printf("%d\n", (*pArray)[i]);
    }
}
void freeSpace(int ** pArray)
{
    if (*pArray != NULL)
    {
        free(*pArray);
        *pArray = NULL;
    }
}
void test01()
{
    int * p = NULL;
    allocateSpace(&p);
    printArray(&p, 5);
    freeSpace(&p, 5);
    
    if (p == NULL)
    {
        printf("空指针\n");
    }
    else
    {
        printf("野指针\n");
    }
}

7二级指针练习-文件操作

7.1读取配置文件信息，并且将信息存放到 数组中

7.2注意： 释放堆区，关闭文件



//获取有效行数
int getFileLines(FILE * pFile)
{
    if (pFile == NULL)
    {
        return -1;
    }
    char buf[1024] = { 0 };
    int lines = 0;
    while (fgets(buf,1024,pFile) != NULL)
    {
        //printf("%s", buf);
        lines++;
    }
    //将文件光标置首
    fseek(pFile, 0, SEEK_SET);
    return lines;
}
//读取数据放入到pArray中
void readFileData(FILE * pFile, int len, char ** pArray)
{
    if (pFile == NULL)
    {
        return;
    }
    if (len <= 0 )
    {
        return;
    }
    if ( pArray ==NULL)
    {
        return;
    }
    char buf[1024] = { 0 };
    int index = 0;
    while (fgets(buf, 1024, pFile) != NULL)
    {
        /*
        aaaaaaaaaa
        bbbb
        cccccc
        */
        int currentLen = strlen(buf) +1 ;
        char * currentStrP = malloc(sizeof(char)* currentLen);
        strcpy(currentStrP, buf);
        pArray[index++] = currentStrP;
        memset(buf, 0, 1024);
    }
}
void showFileData(char ** pArray, int len)
{
    for (int i = 0; i < len;i++)
    {
        printf("%d行的数据为 %s", i + 1, pArray[i]);
    }
    
}
void test01()
{
    //打开文件
    FILE * pFile =    fopen("./test.txt", "r");
    if (pFile == NULL)
    {
        printf("文件打开失败\n");
        return;
    }
    //统计有效行数
    int len =  getFileLines(pFile);
    //printf("文件的有效行数为：%d\n", len);
    char ** pArray =  malloc(sizeof(char *)* len);
    //读取文件中的数据并且放入到 pArray中
    readFileData(pFile, len, pArray);
    //读取数据
    showFileData(pArray , len);
    //释放堆区内容
    for (int i = 0; i < len; i++)
    {
        if (pArray[i] != NULL)
        {
            free(pArray[i]);
            pArray[i] = NULL;
        }
    }
    free(pArray);
    pArray = NULL;
    //关闭文件
    fclose(pFile);
}

8位运算

8.1按位取反 ~ 0变1 1 变0

8.2按位与 & 全1为1 一0为0

8.3按位或 | 全0为0 一1为1

8.4按位异或 ^ 相同为0不同为1



/按位取反 ~
void test01()
{
    int num = 2;
    // 010 取反
    // 101 源码
    //计算机用补码方式存数据  110 + 1      =  111
    printf("~num = %d\n", ~num); // -3
}
//按位与 &
void test02()
{
    int num = 123;
    if (  (num & 1 ) == 1 )
    {
        printf("num为奇数\n");
    }
    else
    {
        printf("num为偶数\n");
    }
}
//按位或 |
void test03()
{
    int num1 = 5;
    int num2 = 3;
    printf("num1 | num2 =  %d\n", num1 | num2); // 7
}
//按位异或  ^
void test04()
{
    int num1 = 5;
    int num2 = 9;
    /*int tmp = num1;
    num1 = num2;
    num2 = tmp;*/
    num1 = num1 ^ num2;
    num2 = num1 ^ num2;
    num1 = num1 ^ num2;
    //num1 = num1 + num2;
    //num2 = num1 - num2;
    //num1 = num1 - num2;
    printf("num1 = %d\n", num1);
    printf("num2 = %d\n", num2);
}
//左移运算 << 
void test05()
{
    int num = 20;  // 20 * 2 ^ 2;
    printf("%d\n", num <<= 2);
}
//右移运算 >>
void test06()
{
    int num = 20;  // 20 / 2
    printf("%d\n", num >>= 1);
}

9位移运算

9.1左移运算 << X 乘以2 ^ X

9.2右移运算 >> X 除以 2 ^X

9.2.1有些机器用0填充高位

9.2.2有些机器用1填充高位

9.2.3如果是无符号，都是用0填充

在这里插入图片描述

微尘hyt
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C_指针
weixin_45283410的博客
03-27 311
指针就是地址 操作符： ：解引用符（定义指针变量时的不是这个），也叫取值符 &：取地址符 变量地址： &a 一维数组地址：常量名 二位数组地址：行地址a、a+1，列地址a[1]、a[0]+1 访问：读取或者修改内存单元 直接访问：如a=5，直接通过变量访问 间接访问：scanf（"%d",&a）通过地址访问 指向：p指向a,指针变量p存放的值是a的地址 定义指针变量（siz...
char* buf和char buf[64]，定义两种字符串作为参数传递给函数的区别
qq_42230338的博客
06-23 4974
问题描述： 最近在项目中遇到了一个让人疑惑的问题，有一个发送函数需要传递void*类型的参数，我定义了char *buf = “abcdefg”； 然后将buf作为参数传递给了这个发送函数，但是函数返回值显示发送成功，但是另一端没有接收到数据。查找了好久， 最终我将char *buf = “abcdefg”，改为char buf[64] = “abcdefg”；然后再次传输，结果传输成功。 总结： 以后遇到这种情况可以直接分配具体的数组空间。 ...
c语言字符指针分配内存,内存分配函数及使用注意事项，C语言内存分配函数完全攻略...
weixin_33308577的博客
05-17 727
C 语言主要提供 malloc、realloc、calloc、alloca 与 aligned_alloc 等内存分配函数来实现对内存的分配功能。1)malloc 函数原型如下：void * malloc (size_t size);该函数用于从堆中分配内存空间，内存分配大小为 size。如果内存分配成功，则返回首地址；如果内存分配失败，则返回 NULL。2)calloc 函数原型如下：void ...
c语言内存管理
最新发布
笔记
08-11 390
a、作用域：在定义变量的{}之内有效b、声明周期：程序运行至变量定义处开辟内存空间，所在函数运行结束之后释放空间c、未初始化的变量值：随机。
C语言 内存操作函数
lin的博客
08-01 149
内存操作函数
13-C语言文件.ppt
07-24
13-C语言文件.ppt
C语言讲义.doc
01-27
8.7.13 Sscanf函数 44 8.7.14 strchr查找字符 44 8.7.15 strstr查找子串 44 8.7.16 strtok分割字符串 44 8.7.17 atoi转化为int 45 8.7.18 atof转化为float 45 8.7.19 atol转化为long 45 9 函数 45 9.1 函数的原型和...
新概念51单片机C语言教程.入门、提高、开发
07-02
《新概念51单片机C语言教程》配套光盘提供13讲近30学时的教学视频和《新概念51单片机C语言教程》实例代码，可使读者更快更好地掌握单片机知识和应用技能。《新概念51单片机C语言教程》作者还可提供与《新概念51...
13双灯左移右移闪烁单片机C语言源码.zip项目程序C语言源码下载
03-19
13双灯左移右移闪烁单片机C语言源码.zip项目程序C语言源码下载13双灯左移右移闪烁单片机C语言源码.zip项目程序C语言源码下载 1.合个人学习技术做项目参考 2.适合学生做毕业设计参考 3.适合单片机公司开发项目参考
C语言答案13.pdf
10-06
C语言答案13.pdf
4 数组
weixin_40569915的博客
11-28 480
1.1 数组 数组方便一次定义大量变量空间，而且也方便访问，访问时利用地址累加，访问每个数组空间即可。 1.1.1 一维数据中的关键符号 以int buf[100] = {0} 为例 buf：一是数组名，sizeof(buf)时，buf就是数组名的含义；二是等价于&amp;amp;amp;amp;amp;buf[0]，表示数组第一个元素的首字节地址，是一个常量值。 buf[0]：第一个元素的空间，可以对其进行读写操作。 &amp;amp;amp;amp;amp...
C程序设计语言——指针
巧克力布丁的博客
07-20 2898
一. 指针概述 指针热身举例1 #include <stdio.h> int main(void) { int * p; //p是变量的名字，int * 表示p变量存放的是int类型变量的地址 int i = 3; p = &i; //OK // p = i; //error;因为类型不一致，p只能存放int类型变量的地址，不能存放int类型变量的值 // p = 55; //error;原因同上 return 0; } 指针热身举例2 图示： 二.
5.字符指针和指针数组
wangfan110的博客
06-29 553
1.定义 字符指针：指向字符的指针；这是最简单的运用！ void main() { char *ptr = NULL; char ch = 'a'; ptr = &ch; *ptr = 'b'; printf("%c\n", ch); system("pause"); } 在C语言中，没有字符串类型，字符串类型一般使用字符数组来描述；但是大家需要将字符数组与字符串区分开来！ 在C语言中，一般使用字符指针来指向字符串！利用数组和字符指针表示的字符串有着本质的区别！ ch
BUF在c语言中的作用,C语言如何执行buf中的代码
weixin_42523104的博客
05-16 3874
缓冲区溢出攻击已经存在了很长时间了。它仍然存在于今天，部分原因是程序员在编写代码时不小心。我所说的“部分”原因是因为有时编写好的代码可以利用缓冲区溢出攻击，因为这也取决于攻击者的奉献精神和智能级别。方法/步骤我们至少可以做的是避免编写不好的代码，从而有机会甚至脚本小孩攻击你的程序并利用它在这个缓冲区溢出教程中，我们将讨论以下的基础知识：什么是缓冲区溢出？如何发生缓冲区溢出？如何发生缓冲区溢出攻击？...
C/C++变量大小、动态分配内存、内存填充
qq_20386411的博客
04-07 2898
变量大小 数字最终是以二进制存储和表示，八个位（Bit）构成一个字节（Byte） 1 KB = 1024B字节 ，(Kilo Bytes) 1 MB = 1024KB，(Mega Bytes)，经常看到的文件大小 变量的大小：变量在内存里所占的字节数。用操作符sizeof 来测量一个变量或类型的大小。 1、变量在内存中所占的字节称为变量的大小 char型变量表示的范围很小，对应1个字节...
C内存申请释放
u012554768的专栏
11-02 992
C语音有个原则，手动申请的内存一定要手动释放！ 我们先看一个简单的实例 #include void main(void) { char* buf = NULL; char hello[]= "hello,world"; int len = 0; len = sizeof(hello); //手动申请一块内存 buf = (char*)malloc(si
C语言内存相关操作函数
qq_43813969的博客
10-28 385
C语言内存相关操作函数
C++ 字符串处理
gyros
05-13 465
整数转换为字符串 错误示范 #include<iostream> using namespace std; char *int2str(int tem) { char per; int i = 0; int tem_copy = tem; if (tem_copy < 0)//如果tem<0，则需要在最前面加多一个'-'，则占用多一个内存。 i++; ...
c语言math.h库函数
05-11
13. ceil(x)：返回不小于x的最小整数。 14. floor(x)：返回不大于x的最大整数。 15. fmod(x, y)：返回x除以y的余数。 16. hypot(x, y)：返回x和y的平方和的平方根。 17. rand()：返回一个伪随机数。 注意，在...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值