动态开辟内存的这些知识你知道了吗？了解柔性数组吗？超详细画图以及文字讲解，干货满满

最新推荐文章于 2024-05-29 00:34:25 发布
最新推荐文章于 2024-05-29 00:34:25 发布
阅读量512 收藏 2
点赞数 1
分类专栏： C语言 文章标签： 动态开辟内存 柔性数组 C语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/attemptendeavor/article/details/119044604
版权

动态内存分配

文章目录

前言

数组的元素存储内存中在连续的位置上，它所需要的内存在编译时就被分配，但是我们也可以使用动态内存分配在运行时为它分配内存，下面博主将以以下内容介绍动态内存分配。

为什么存在动态内存分配

之前我们了解的有两种内存分配方式：

  • 创建变量

  • 创建数组

int main()
{
    int a=10;//创建变量
    char c = 'w';
    
    char arr[200]={0};//创建数组
    int arr2[5]={0};
    return 0;
}

这种分配的方法优点是简单，但是它有好几个缺点，这种内存分配是不灵活的，分配好，内存大小就不会改变。如果程序需要使用的元素数量超过了声明的长度，它就无法处理这种情况，这时需要将数组声明大一些，但是我们在使用数组元素数量较少时，内存空间就大大浪费了。所以就出现了动态内存分配，这种内存分配是比较灵活的。

动态内存函数的介绍

首先动态内存开辟的空间是位于哪里的呢？

image-20210719100207532

如图解释，局部变量以及函数形参是位于栈区，动态内存开辟是在堆区，而全局变量以及静态变量是位于静态区。

接下来我们首先介绍malloc函数：

malloc

  • 函数原型以及参数解释

image-20210719100852019

我们再来看一看malloc函数关于返回值void*的解释：

image-20210719100931906

这段话的大致意思是，malloc函数会返回一个void*的指针，如果开辟成功，则该void*指针指向开辟好的空间的起始地址，若开辟失败，将返回一个NULL指针。

接下来我们来看一看malloc函数的使用

int *p = (int*)malloc(100);

我们想要用malloc函数在堆区开辟100个字节的空间，并且这100字节的空间是连续的，用什么类型的指针取决于你想要怎么使用这块空间，你想要以整形使用，那就用int*类型指针来接收，malloc函数返回的为void*的指针，当我们以整形的方式使用空间时，我们需要将它强制类型转换为int*。

image-20210719103200319

image-20210719103328017

下面代码是malloc函数开辟空间以及使用空间

int main()
{
    //动态内存开辟
    int *p = (int*)malloc(100);
    if(p==NULL)
    {
        perror("malloc");
    }
    else
    {
        int i=0;
        for(i=0;i<25;i++)
        {
            *(p+i)=i;
        }
        for(i=0;i<25;i++)
        {
           printf("%d ",*(p+i));
        }
    }
    return 0;
}

我们想要使用malloc函数在堆区开辟100个字节的空间，用整形的方式使用它，再使用这块空间时，我们需要判断空间是否开辟成功，所以我们判断指针p是否为NULL，若为NULL，则开辟失败，打印错误信息，若不为NULL，我们则利用指针p指向起始空间地址使用该块空间。

开辟成功的情况：

image-20210719102540453

开辟失败的情况：

image-20210719102807361

注意：

int *p = malloc(0);

这样不是错误的，但是没有什么意义，也不能使用空间。

当我们确定内存不再使用时，我们需要回收释放内存，这时我们就用到了free函数

free

  • 函数原型以及参数解释

image-20210719103754592

int main()
{
    //动态内存开辟
    int *p = (int*)malloc(100);
    if(p==NULL)
    {
        perror("malloc");
    }
    else
    {
        int i=0;
        for(i=0;i<25;i++)
        {
            *(p+i)=i;
        }
        for(i=0;i<25;i++)
        {
           printf("%d ",*(p+i));
        }
        //回收-释放内存
        free(p);//free不能将p置为NULL指针
        p=NULL;
    }
    return 0;
}

在使用完空间后，我们需要将此块空间还给操作系统，在使用free释放内存后，free函数只是将这块空间还给操作系统了，而p指针所指向的地址是不会变的，所以我们需要将p置为空，以防有人想通过p访问刚刚开辟的100个字节空间时，这时就非法访问空间了。

需要注意的是！！！

int main()
{
    int a=10;
    int *p = &a;
    free(p);//error
    return 0;
}

这种做法是错误的，free的参数必须要么是NULL，要么是一个先前从malloc、calloc、realloc（稍后讲解）返回值，向free传递一个NULL参数不会参数任何效果

calloc

  • 函数原型以及参数解释

image-20210719105419420

calloc和malloc的一个区别是calloc会初始化分配好的内存为0，calloc和malloc之间的另一个区别就是它们请求内存数量的方式不同，calloc的参数包括所需元素的数量和每个元素的字节数，根据这些值，它能够计算处总共分配的内存。

返回值

image-20210719105722139

malloc不会初始化分配好的内存：

int main()
{
    int *p = (int*)malloc(40);
    if(p==NULL)
    {
        return 1;
    }
    int i=0;
    for(i=0;i<10;i++)
    {
        printf("%d\n",p[i]);//打印出随机值
    }
    free(p);
    p=NULL;
    return 0;
}

image-20210719110453659

malloc函数分配好的内存不会初始化，值为随机值

calloc会初始化分配好的内存：

int main()
{
    int *p = (int*)calloc(10,4);
    if(p==NULL)
    {
        return 1;
    }
    int i=0;
    for(i=0;i<10;i++)
    {
        printf("%d\n",p[i]);//打印出都是0
    }
    free(p);
    p=NULL;
    return 0;
}

image-20210719110620772

而calloc会将每个元素初始化为0

接下来我们介绍最核心的函数realloc：

realloc

realloc是这几个函数中最核心的函数

  • 函数原型以及参数解释

image-20210719111501959

realloc函数让动态内存管理更加灵活，你可以使一块内存扩大或缩小。realloc的返回值不确定，可能会返回原先内存块的地址，可能会返回新内存块的地址，原因后面解释。

接下来我们看realloc函数的使用

int main()
{
    int *p=(int*)malloc(10*sizeof(int));
    if(p==NULL)
    {
        perror("malloc");
        return 0;
    }
    int i=0;
    for(i=0;i<10;i++)
    {
        p[i]=i+1;//p[i]等价于*(p+i)
    }
    //调整空间的大小
    p = (int*)realloc(p,20*sizeof(int));//error 
    //如果找不到合适的空间来调整大小，realloc会返回空指针，这里就将NULL赋给p，将原空间也毁掉了

    int *ptr = (int*)realloc(p,20*sizeof(int));
    if(ptr==NULL)
    {
        perror("realloc");
    }
    else
    {
        p=ptr;
        ptr=NULL;
    }
    for(i=10;i<20;i++)
    {
        p[i]=i+1;
    }
    for(i=0;i<20;i++)
    {
        printf("%d ",p[i]);
    }
    //释放
    free(p);
    p=NULL;
    return 0;
}

realloc调整空间存在两种情况

  • 当要调整的原有空间后面空间够需要调整的大小时，就直接在后面增加空间，返回起始空间的地址

  • 当要调整的原有空间后面空间不够需要调整的大小时，它会新开辟要调整的大小的空间，然后将旧空间的内容拷贝到新空间，最后将旧空间释放掉，然后返回新空间的起始地址

返回地址可能返回旧地址，也可能返回新地址

image-20210720121035425

image-20210720121119697

如果realloc函数的第一个参数是NULL，那么它的行为就和malloc一模一样：

int main()
{
    int *p = (int*)realloc(NULL,40);//可以传NULL指针，和malloc功能类似，会开辟40个字节的空间
    return 0;
}

常见的动态内存错误

  • 对NULL指针进行解引用
int main()
{
    int *p=(int*)malloc(100);
    *p=0;
    return 0;
}

若开辟成功，没什么问题，但是开辟失败，此时p为NULL，对NULL指针解引用非法操作了

image-20210720122913143

  • 对动态开辟内存的越界访问
int main()
{
    int *p=malloc(10*sizeof(int));
    if(p==NULL)
    {
        perror("malloc");
        return 0;
    }
    int i=0;
    //对动态开辟内存的越界访问
    for(i=0;i<=10;i++)
    {
        p[i]=i;
    }
    for(i=0;i<=10;i++)
    {
        printf("%d",p[i]);
    }
    free(p);
    p=NULL;
}

image-20210720123126682

在我们开辟好10个整形的内存后，在使用内存时，当i=10时，p[10]等价于(p+10)，到达p+10时，我们*(p+10)访问到了我们申请的空间后面的一块空间，此时越界访问了。*

image-20210720122649838

  • 对非动态开辟内存使用free释放
void test()
{
    int a=0;
    int *p=&a;
    free(p);//不ok
}

变量a是在栈区上开辟的空间，free函数只能释放在堆区上的空间

  • 使用free释放一块动态开辟内存的一部分
int main()
{
    int *p=(int*)malloc(10*sizeof(int));
    if(p==NULL)
    {
        perror("malloc");
        return 0;
    }
    int i=0;
    //释放动态开辟内存空间的一部分
    for(i=0;i<5;i++)
    {
        *p=1;
        p++;
    }
    free(p);//此时p不是指向空间的起始地址
    p=NULL;
    return 0;
}

在使用空间时，我们使得p++了，我们的指向分配空间起始地址的指针发生了改变,所以在free§时，就会出问题，我们不能释放动态开辟内存的一部分，并且我们开辟的这块空间起始地址不知道了，这块空间就找不到了，会造成内存泄漏

image-20210720124154685

  • 对同一块动态开辟的内存多次释放
int main()
{
    int *p=(int*)malloc(10*sizeof(int));
    if(p==NULL)
    {
        perror("malloc");
        return 0;
    }
    //使用空间
    //对同一块动态开辟的内存多次释放
    free(p);//忘记将p置为NULL
    //...
    free(p);//再次释放，此时会错误
    p=NULL;
    return 0;
}

image-20210720124647097

在free§时，忘记将p置为NULL，当我们写代码的过程中忘记前面free过了，要是再次free就会出错的。

保险起见我们可以这样写free时，必须将指针置为NULL，就不会出现上面的问题了，再次释放，free传NULL指针什么事都不会发生，这种不会出错误：

free(p);
p=NULL;//将p置为NULL
//...
free(p);//再次释放，free传NULL指针什么事都不会发生，这种不会出错误
  • 动态开辟内存忘记释放(内存泄漏)
int main()
{
    int *p=(int*)malloc(10*sizeof(int));
    if(p==NULL)
    {
        perror("malloc");
        return 0;
    }
    else
    {
        *p=10;
    }
    return 0;
}

开辟了内存没有进行释放，防止错误，我们的malloc、calloc、realloc需要与free成对出现，但是成对出现不一定不发生错误

例如：

void test()
{
    int *p=(int*)malloc(12);
    if(p==NULL)
        return;
    //使用空间
    if(1)
        return;//此时已经返回，开辟的空间并没有释放
    free(p);
    p=NULL;
}
int main()
{
    test();
    return 0;
}

test函数中还没有释放就返回，虽然free出现了，但是根本没有到达free后面的代码，函数就返回了，所以也是错误的。

函数内部动态开辟空间忘记free释放

void test()
{
    int *p=(int*)malloc(100);
    if(p==NULL)
    {
        return;
    }
}
int main()
{
    test();
    return 0;
}

p是局部变量，出函数会销毁，函数内部没有释放p所指向的空间，那么出了函数之后没人能找到那块空间，就造成了内存泄漏。

动态开辟的空间，两种回收方式:

  • 主动free
  • 程序结束

接下来我们看几个经典的笔试题，满满的干货哦：

几个经典的笔试题

  • 笔试题1
#include<string.h>
#include<stdlib.h>
void GetMemory(char *p)
{
	p = (char *)malloc(100);
}
void Test(void)
{
    char *str = NULL;
    GetMemory(str);
    strcpy(str, "hello world");
    printf(str);
}
int main()
{
    Test();
    return 0;
}

Test函数和GetMemory函数的精彩对决：

image-20210723093941373

代码会挂，首先调用test函数，首先创建了一个str指针，里面放了NULL指针，之后调用GetMemory，将str传过去(值传递)，GetMemory函数中，形参p是str的一份临时拷贝，此时是NULL指针，动态内存开辟了一块空间用p指针维护，不会影响外面的str，函数调用结束后，str依然是NULL，会拷贝失败，又因为GetMemory函数调用结束后，p会销毁，并且会发生内存泄漏

笔试题1的第一种改错方法：传地址过去

//改错
#include<string.h>
#include<stdlib.h>
void GetMemory(char **p)
{
	*p = (char *)malloc(100);
}
void Test(void)
{
    char *str = NULL;
    GetMemory(&str);
    strcpy(str, "hello world");
    printf(str);
    free(str);
    str = NULL;
}
int main()
{
    Test();
    return 0;
}

将str的地址传过去，这样就可以用str来维护堆区的这段内存，最后释放即可

笔试题1的第二种改错方法：

返回动态开辟内存的起始地址，用str来接收

#include<string.h>
#include<stdlib.h>
char* GetMemory(char *p)
{
	p = (char *)malloc(100);//堆区创建的空间
    return p;
}
void Test(void)
{
    char *str = NULL;
    str = GetMemory(str);
    strcpy(str, "hello world");
    printf(str);
    free(str);
    str = NULL;
}
int main()
{
    Test();
    return 0;
}

这里将动态开辟的内存用p来维护，将p返回，用str来接受，这样str就维护了这段空间，最后释放这段空间就好了

  • 笔试题2
char *GetMemory(void)
{
    char p[] = "hello world";
    return p;
}
void Test(void)
{
    char *str = NULL;
    str = GetMemory();
    printf(str);
}
int main()
{
    Test();
    return 0;
}

Test函数和GetMemory函数的精彩对决：

image-20210723094535085

Test函数首先创建一个字符指针str，然后调用GetMemory函数，将调用的结果放入str，GerMemory调用时，里面创建了p字符数组，返回p，将数组首元素的地址返回，但是出函数时，p这块空间在函数调用结束后，就还给操作系统了，销毁了，而str中现在是p数组中的首元素地址，但是这块空间已经销毁了，所以是不能打印的，根本原因是GetMemory函数内部创建的数组是在栈区上创建的，出了函数，p数组的空间就还给了操作系统，返回的地址是没有实际的意义，如果通过返回的地址去访问内存，就是非法访问了。

  • 笔试题3
void GetMemory(char **p, int num)
{
	*p = (char *)malloc(num);
}
void Test(void)
{
    char *str = NULL;
    GetMemory(&str, 100);
    strcpy(str, "hello");
    printf(str);
}

这道题比较简单，很显然它在堆区开辟了空间，最后让str维护，但是没有free，会造成内存泄漏

  • 笔试题4
void Test(void)
{
    char *str = (char *) malloc(100);
    strcpy(str, "hello");
    free(str);
	if(str != NULL)
	{
        strcpy(str, "world");
        printf(str);
	}
}

free函数并不会将str置为NULL，进去if语句，这里拷贝时，str指向的空间已经释放了，就非法访问空间了，所以free(str)时，一定要将str置空，平时写代码也一定free完要将指针置为NULL

柔性数组

柔性数组(flexible array member)也叫伸缩性数组成员，这种结构产生与对动态结构体的去求。在日常编程中，有时需要在结构体中存放一个长度是动态的字符串(也可能是其他数据类型)，一般的做法，实在结构体中定义一个指针成员，这个指针成员指向该字符串所在的动态内存空间。在通常情况下，如果想要高效的利用内存，那么在结构体内部定义静态的数组是非常浪费的行为。其实柔性数组的想法和动态数组的想法是一样的。柔性数组用来在结构体中存放一个长度动态的字符串。也许你从来没有听说过柔性数组（flexible array）这个概念，但是它确实是存在的。 C99 中，结构中的最后一个元素允许是未知大小的数组，这就叫做『柔性数组』成员。

下面我们来看看柔性数组到底是什么样子的：

struct S
{
    int n;
    int arr[];//大小是未知的--柔性数组
};
//也可以这样写
struct S
{
    int n;
    int arr[0];//大小是未知的
};//部分编译器不支持这样写
int main()
{
    
    return 0;
}

上面结构体中的arr就为柔性数组

柔性数组的特点

  • 结构中的柔性数组成员前面必须至少一个其他成员。
struct S
{
    int n;
    int arr[0];//大小是未知的
};
  • sizeof 返回的这种结构大小不包括柔性数组的内存。
struct S
{
    int n;
    int arr[0];//大小是未知的
};
int main()
{
    struct S s={0};
    printf("%d\n",sizeof(s));//计算大小不包含柔性数组的内存
    return 0;
}

image-20210719180858925

  • 包含柔性数组成员的结构用malloc ()函数进行内存的动态分配时，分配的内存应该大于结构的大小，以适应柔性数组的预期大小。

柔性数组的使用

//代码1
struct S
{
    int n;
    int arr[];//大小是未知的
};
int main()
{
    //期望arr的大小是10个整形
    struct S* ps = (struct S*)malloc(sizeof(struct S)+10*sizeof(int));
    //前4个是给n的，后40个字节是给arr的
    if(ps==NULL)
    {
        return;
    }
    ps->n=10;
    int i=0;
    for(i=0;i<10;i++)
    {
        ps->arr[i]=i;
    }
    //增加空间
    struct S* ptr=(struct S*)realloc(ps,sizeof(struct S)+20*sizeof(int));
    if(ptr!=NULL)
    {
        ps=ptr;
    }
    //使用
    
    //释放
    free(ps);
    ps=NULL;
    printf("%d\n",sizeof(s));//计算大小不包含柔性数组的内存
    return 0;
}

柔性数组的优势

为什么会有柔性数组呢？它的优势是什么呢？，看下面的解释

上面的struct S结构也可以设计为这样：

//代码2
struct S
{
    int n;
    int *arr;
};
int main()
{
    struct S* ps=(struct S*)malloc(sizeof(struct S));
    if(ps==NULL)
    {
        return 1;
    }
    ps->n=10;
    ps->arr=(int*)malloc(10*sizeof(int));
    if(ps->arr==NULL)
    {
        return 1;
    }
    int i=0;
    for(i=0;i<10;i++)
    {
        *(ps->arr+i)=i;
        //p->arr[i]=i;
    }
    //增加
    int *ptr=realloc(ps->arr,20*sizeof(int));
    if(ptr!=NULL)
    {
        ps->arr=ptr;
    }
    //使用
    //释放
    free(ps->arr);
    ps->arr=NULL;
    free(ps);
    ps=NULL;
    return 0;
}

image-20210723102536832

上述代码1和代码2可以完成同样的功能，但是方法1的实现有两个好处：

  • 方便内存释放

如果我们的代码是在一个给别人用的函数中，你在里面做了二次内存分配，并把整个结构体返回给用户。用户调用free可以释放结构体，但是用户并不知道这个结构体内的成员也需要free，所以你不能指望用户来发现这个事。所以，如果我们把结构体的内存以及其成员要的内存一次性分配好了，并返回给用户一个结构体指针，用户做一次free就可以把所有的内存也给释放掉。

  • 有利于访问速度

连续的内存有益于提高访问速度，频繁开辟空间，效率会变低，内存碎片也会变多

如果觉得博主写的还不错的话，希望大家点赞+评论+收藏哦！！！欢迎大家学习讨论

小赵小赵福星高照～
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
C语言柔性数组实例详解
01-20
包含柔数组成员的结构用malloc函数进行内存的动态分配,且分配的内存应该大于结构的大小以适应柔性数组的预期大小。柔性数组到底如何使用？ 不完整类型 C和C++对于不完整类型的定义是一样的，不完整类型是这样一种...
C语言变长消息定义：柔性数组
07-29
C语言中柔性数组是指在结构体中定义一个数组，但是不指定数组的大小，而是根据实际需要动态分配内存空间的数组。这是一种常用的技术，特别是在网络通信和数据存储等领域。 首先，让我们来了解一下为什么需要使用...
【C进阶】——C/C++程序的内存开辟 及 柔性数组详解
m0_70980326的博客
10-10 1659
详解：1. C/C++程序的内存开辟2. 柔性数组2.1 柔性数组的定义2.2 柔性数组的特点2.3 柔性数组的使用2.4 柔性数组的优势
柔性数组的详解及C/C++内存分配区域的划分解析
m0_70811813的博客
09-29 951
C/C++中程序内存区域划分图解、柔性数组的定义、柔性数组的特点、柔性数组的使用、柔性数组的替代实现、柔性数组的优势
C语言：动态内存管理(动态内存+柔性数组讲解)
2301_77649794的博客
07-20 211
C语言提供了一个动态内存的开辟的函数：malloc这个函数向内存申请一块连续可用的空间，并返回指向这块空间的指针。1.如果开辟成功，则返回一个指向开辟好空间的指针。2.如果开辟失败，则返回一个NULL指针，因此malloc的返回值一定要做检查。3.返回值的类型是 void*(返回值为指针)，所以malloc函数并不知道开辟空间的类型，具体在使用的时候使用者自己来决定(强制类型转换)。4.如果参数size 为0，malloc的行为是标准是未定义的，取决于编译器。int main()
【Java】 【随机数 数组 静态初始化 动态初始化 内存分配 内存图 】 Notes and Insights 5
Zane Boy's blogs
09-08 215
随机数 数组 静态初始化 动态初始化 内存分配 内存图
你 还 不知道什么是“柔性数组”吗？详细深入讲解以及扩展，快进来学习以便所需之时使用
foodsx的博客
03-04 1005
柔性数组的详细讲解以及扩展
[C][动态内存分配][柔性数组]详细讲解
最新发布
SnowK博客
05-29 4456
[C][动态内存分配][柔性数组]详细讲解
超详细——动态内存分配+柔性数组
fighting小泽的博客
04-05 1133
C语言提供了一个内存开辟的函数：malloc可以向内存申请一块连续的空间，并返回一个指向这块空间的指针如果开辟成功，则返回一个指向开辟好空间的指针。如果开辟失败，则返回一个NULL指针，因此malloc的返回值一定要做检查。返回值的类型是 void* ，所以malloc函数并不知道开辟空间的类型，具体在使用的时候使用者自己来决定。如果参数 size 为0，malloc的行为是标准是未定义的，取决于编译器举个例子这样我们就开辟了一个20个字节的空间。
【C语言】你听说过柔性数组吗？
Weraphael的博客
02-18 1491
这篇博客将带你了解柔性数组的概念、如何定义、特点、使用以及优势，快进来看看吧
【C/C++动态内存 or 柔性数组】——对动态内存分配以及柔性数组的概念进行详细解读（张三 or 李四）
诺诺的包包
11-11 2063
采用画图、具体题目以及一些案例，来对动态内存分配以及柔性数组进行详细解读。🌹
SoftArray.rar_95O_柔性数组
09-15
柔性数组（Flexible Array Member）是C++中一种特殊的数据结构设计，主要应用于结构体或类的设计，以提高内存效率和程序的灵活性。在C++标准库中，它被广泛用于容器如`std::vector`、`std::string`等内部实现。在本...
PCB技术中的什么是FPC？柔性电路板
11-18
什么是FPC？ 　FPC软性印制电路是以聚酰亚胺或聚酯薄膜为基材制成的一种具有高度可靠性，绝佳的可挠性印刷电路。 　产品特点： 　1....　2....　3....　MP3、MP4播放器、便携式CD播放机、家用VCD、DVD 、数码照相机、手机...
指针的这些知识你知道吗？C语言超硬核指针进阶版3w+字详解+指针笔试题画图+文字详细讲解
小赵小赵福星高照的博客
06-02 4978
指针的进阶 文章目录指针的进阶字符指针指针数组数组指针数组指针的使用传统的方式访问二维数组利用数组指针来访问二维数组数组参数、指针参数一维数组传参二维数组传参一级指针传参二级指针传参函数指针—指向函数的指针函数指针函数调用C陷阱和缺陷中的两个代码函数指针数组实现一个计算器普通实现函数指针数组实现指向函数指针数组的指针回调函数qsort函数qsort函数对int型数组排序qsort对结构体排序模拟实现qsort函数指针和数组笔试题一维数组的sizeof和&的那些事字符数组与sizeof、&、s
C语言有关指针的详解笔记
小赵小赵福星高照的博客
04-08 1489
指针 1.指针是什么 2.指针和指针类型 3.野指针 4.指针运算 5. 指针和数组 6.二级指针 7.指针数组 1.指针是什么 在计算机科学中，指针是编程语言中的一个对象，利用地址，他的值直接指向存在电脑存储器中另一个地方的值。由于通过地址能找到所需的变量单元，可以说，地址指向该变量单元。因此，将地址形象化的称为"指针"。意思是通过它能找到以它为地址的内存单元。 内存 如何使用内存呢？ 生活中，房子对应编号，编号-就为地址，将内存单元划分为一个一个格子，给每个格子编号 1.一个内存单元该是多大的空间？
C语言描述，将一句话的单词进行倒置，标点符号不倒置。
小赵小赵福星高照的博客
05-20 1452
题目描述 将一句话的单词进行倒置，标点符号不倒置。 输入示例 每次输入一个测试用例，输入长度不超过100 I love you. 输出实例 依次输出倒置后的字符串，以空格分割 you. love I #include<stdio.h> #include<string.h> #include<assert.h> void ReverseArr(char* begin, char* end) { assert(begin && end);
暑假第十三天之每天一些题系列
小赵小赵福星高照的博客
08-24 1287
暑假第十三天之每天一些题系列 一、选择题 如果二进制文件 a.dat 已经存在，现在要求写入全新数据，应以什么方式打开 A. “w” B. “wb” C. “w+” D. “wb+” 答案解析： 首先a.dat是二进制文件，现在要求写入数据，那我们需要以二进制写文件的方式打开文件，即"wb" 文件的打开方式表： 文件使用方式 含义 如果指定文件不存在 “r”（只读） 为了输入数据，打开一个已经存在的文本文件 出错 “w”（只写） 为了输出数据，打开一个文本文件 建立一个新的文件
C语言分支语句和循环语句笔记详解
小赵小赵福星高照的博客
04-09 1263
分支语句和循环语句 什么是语句？ C语言中由一个分号；隔开的就是一条语句。比如： int main() { int a=10; 10; ;//空语句 return 0; } C语言是结构化的程序设计语言 1.顺序结构 2.选择结构 3.循环结构 顺序结构就是从头到尾顺序执行，这里着重讲解选择和循环 分支语句（选择结构） if语句 如果你好好学习，校招时拿号offer，不好好学习，回家种红薯 这就是选择。 那if语句的语法结构是怎么样的呢？ 不得不提到一个问题，C语言是如何表
字符和字符串函数的这些知识你知道吗？超硬核3w字文章带你领略C语言字符与字符串的美！！！
小赵小赵福星高照的博客
06-10 1132
字符函数和字符串函数 文章目录字符函数和字符串函数字符串基础知识函数介绍长度不受限制的字符串函数strlen(字符串长度)strcpy(字符串拷贝)strcat(连接字符串)strcmp（字符串比较）长度受限制的字符串函数介绍strncpystrncatstrncmp字符串查找函数strstr(查找子串)strtok(分割字符串)错误信息报告strerrorperror(打印错误信息)字符操作字符分类字符转换内存操作函数memcpymemmovememcmp(内存比较)memset总结长度不受限制的字符串.
有柔性数组的结构体，必须配合malloc使用吗？
06-08
是的，有柔性数组的结构体必须配合 `malloc` 函数使用，才能正确地分配内存空间。 柔性数组是一种特殊的数组，它的长度是在运行时动态确定的。为了使用柔性数组，我们通常需要先定义一个包含柔性数组的结构体类型，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小赵小赵福星高照～

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值