局部变量，动态内存

已于 2022-11-13 10:38:00 修改
阅读量137 收藏
点赞数
文章标签： c语言
于 2022-11-10 22:50:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_54005982/article/details/127797976
版权

#define _CRT_SECURE_NO_WARNINGS//必须放在第一行
#include <stdio.h>
#include <string.h>
#include <assert.h>
#include <stdlib.h>
//#include <vld.h>//必须先安装

/*
* 局部变量:定义在函数内部的变量,包括形参,在栈(stack)中,
     作用域在函数内部有效,生存周期:进入函数创建,退出函数销毁
* void :没有,可以修饰返回值或参数列表
* void *:通用指针,仅仅只标记地址,不包含类型信息
* 动态内存:
*    内存区域:堆(heap),很大接近可用内存,内存申请和销毁需要程序自行管理
*    malloc:
*    calloc:把每个元素初始化为0
*    realloc:
*    free:释放内存,不释放则内存泄漏
*    泄漏的内存什么情况还给系统:
*        1.程序(进程)退出
*        2.关机(重启)
*    应用场景:
        1.需要根据变量作为长度定义数组
        2.函数结束后还需要继续使用的内存(例如返回局部数组的地址,链表)
        3.长度较大的数组(大内存,超过栈1M的大小)

*/

char* GetStr1()//error
{
    char str[] = "hello world";
    return str;//0x00200
}

int Getnum()
{
    int a = 10;
    return a;
}

char* GetStr()
{
    int len = strlen("hello world");
    //char* str = (char*)malloc(len * sizeof(char));//常见错误
    char* str = (char*)malloc((len+1) * sizeof(char));
    assert(str != NULL);
    strcpy(str,"hello world");

    return str;
}

//课堂练习,返回str复制n次,("abc",2)->"abcabc"
char* GetMemory(const char* str, int n)
{
    char *p = (char *)malloc(strlen(str)*n +1);
    assert(p != NULL);
    if (p == NULL)
    {
        perror("");
        return NULL;
    }

    p[0] = '\0';//把p变成字符串
    for (int i = 0; i < n; i++)
        strcat(p,str);

    return p;
}

//int main()
//{
//    int n = 10;
//    int *arr = (int *)calloc(n,sizeof(int));
//    for (int i = 0; i < n; i++)
//        printf("%d ",arr[i]);
//    free(arr);
//
//    return 0;
//}

int main()//作业
{
    int n = 10;
    int* arr = (int*)malloc(n * sizeof(int));
    assert(arr != NULL);
    for (int i = 0; i < n; i++)//模拟arr被使用
        arr[i] = i;
    //使用的过程中发现内存不足,实际需要20个单元
    //1.申请更大的内存
    //2.把原数据复制到新内存
    //3.释放原内存
    //4.更新地址

    return 0;
}

//int main()
//{
//    int* arr = (int*)malloc(40);
//    free(arr);
//    return 0;
//}

//int main()
//{
//    //定义1000000长度的int数组
//    //int arr[1000000];//不能定义这么大的数组
//    //int* arr = (int*)malloc(1000000 * sizeof(int));//ok
//    //char* arr = (char*)malloc(1024 * 1024 * 1024);//1G,ok
//    char* arr = (char*)malloc(1024 * 1024 * 1020*2);//20亿字节,2G失败
//    if (arr == NULL)
//        perror("出错了");
//    assert(arr != NULL);
//    printf("好了\n");
//    getchar();
//    free(arr);
//
//    return 0;
//}

//int main()
//{
//    char* p = GetMemory("abcde",5);
//    printf("%s\n",p);
// free(p);
//    return 0;
//}

//int main() 
//{
//    char* p = GetStr();//0x00200
//    printf("%s\n",p);
//
//    int n = Getnum();
//    printf("%d\n",n);
//
//    return 0;
//}

//int main(void)
//{
//    int n = 10;
//    //int arr[n];//error,变量不能作为数组的长度,C99合法
//    int *p = (int *)malloc(n*sizeof(int));//创建成功后,p类似数组名
//    assert(p != NULL);
//    if (p == NULL)
//    {
//        perror("出错了");
//        return 0;
//    }
//
//    for (int i = 0; i < n; i++)
//        p[i] = i;
//    for (int i = 0; i < n; i++)
//        printf("%d ",p[i]);
//
//    return 0;
//}

//课堂练习
//int main()
//{
//    int n;
//    scanf("%d",&n);
//    //创建n长度的double类型数组
//    double* arr = (double*)malloc(n * sizeof(double));
//    assert(arr != NULL);
//    if (arr == NULL)
//        return -1;
//    for (int i = 0; i < n; i++)
//        arr[i] = i;
//    for (int i = 0; i < n; i++)
//        printf("%.1f ",arr[i]);
//
//    return 0;
//}

#define _CRT_SECURE_NO_WARNINGS//必须放在第一行
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <assert.h>
#include <vld.h>
/*
*动态内存: 一定把它当作数组使用
*    内存区域:堆(heap),很大接近可用内存,内存申请和销毁需要程序自行管理
*    malloc:动态申请内存
*    calloc:把每个元素初始化为0
*    realloc:扩容,数据结构(顺序表,顺序栈,C++中string)
*    free:释放内存,不释放则内存泄漏
*    free崩溃的原因:
*      1.越界
*      2.移到指针
*      3.重复释放或者释放非动态内存
*     
*/
/*
* 1.二进制求和
给你两个二进制字符串 `a` 和 `b` ，以二进制字符串的形式返回它们的和。
​    例1:输入参数("11","1"),返回"100";例2:输入("1010","1011"),返回"10101"
*/
char* AddBinary(char* str1, char* str2)
{
    int len1 = strlen(str1);
    int len2 = strlen(str2);
    int n = len1 > len2 ? len1 : len2;
    char* s = (char*)malloc((n + 1 + 1) * sizeof(char));
    assert(s != NULL);
    char* p1 = str1 + len1-1;//str1的尾
    char* p2 = str2 + len2 - 1;//str2的尾
    int i = 0;//s的下标
    int tmp = 0;//保存进位
    int count;//和
    while (p1 >= str1 && p2 >= str2)//p1,p2都还有值
    {
        count = (*p1 - '0') + (*p2 - '0') + tmp;
        s[i++] = count%2 + '0';
        tmp = count / 2;
        p1--;
        p2--;
    }
    while (p1 >= str1)//只剩p1
    {
        count = (*p1 - '0') + tmp;
        s[i++] = count % 2 + '0';
        tmp = count / 2;
        p1--;
    }
    while (p2 >= str2)//只剩p2
    {
        count = (*p2 - '0') + tmp;
        s[i++] = count % 2 + '0';
        tmp = count / 2;
        p2--;
    }
    if (tmp > 0)
        s[i++] = '1';
    s[i] = '\0';

    //s逆置
    --i;//跳过'\0'
    for (int j = 0; j < i; j++, i--)
    {
        tmp = s[i];
        s[i] = s[j];
        s[j] = tmp;
    }
    return s;
}

/*
* 4.有 n 个整数,使前面各数顺序向后移 m 个位置,
最后 m 个数变成最前面的 m个数,见下图,
写一个函数实现该功能。 
*/
void Move(int* arr, int n, int m)
{
    if (m < 0 || m >= n)
        return;
    int* brr = (int*)malloc(m * sizeof(int));
    assert(brr != NULL);
    //把后面m个数据移到brr
    
    //把arr的前n-m个数据后移m个位置
    //把brr的数据复制到arr的前面
    free(brr);
}
int main()
{
    char str1[] = "0101";
    char str2[] = "101";
    char *p = AddBinary(str1,str2);
    printf("%s\n",p);
    free(p);

    return 0;
}

/*
//1.越界
int main()
{
    int n = 10;
    int* arr = (int*)malloc(n );
    assert(arr != NULL);
    for (int i = 0; i < n; i++)
        arr[i] = i;
    for (int i = 0; i < n; i++)
        printf("%d ",arr[i]);
    printf("\n");
    free(arr);

    return 0;
}
*/

/*
//2.移到指针
int main()
{
    int n = 10;
    int* arr = (int*)malloc(n*sizeof(int));
    assert(arr != NULL);
    for (int i = 0; i < n; i++)    
    {//arr[i] = i;
        *arr = i;
        arr++;
    }

    printf("\n");
    free(arr);

    return 0;
}
*/
/*
//重复释放同一段内存
int main()
{
    int n = 10;
    int* arr = (int*)malloc(n * sizeof(int));
    assert(arr != NULL);
    for (int i = 0; i < n; i++)
    {
        arr[i] = i;
    }
    
    printf("%p\n", arr);
    free(arr);
    printf("%p\n",arr);//arr是野指针
    free(NULL);//可以
    //free(arr);//崩溃,重复释放

    return 0;
}
*/
//int main()
//{
//    int n = 10;
//    int* arr = (int*)malloc(n * sizeof(int));
//    assert(arr != NULL);
//    free(arr);
//
//    arr = (int*)malloc(2*n * sizeof(int));//arr还能不能继续使用
//
//    free(arr);
//
//    return 0;
//}
//int main()
//{
//    int n = 10;
//    int* arr = (int*)malloc(n * sizeof(int));
//    assert(arr != NULL);
//    printf("%p\n",arr);
//    arr = (int*)realloc(arr,n*2*sizeof(int));
//    printf("%p\n", arr);
//    free(arr);
//    return 0;
//}

/*
int main()
{
    int n = 10;
    int* arr = (int*)malloc(n * sizeof(int));
    assert(arr != NULL);
    for (int i = 0; i < n; i++)//模拟arr被使用
        arr[i] = i;
    //使用的过程中发现内存不足,实际需要20个单元
    arr = (int *)realloc(arr,2*n*sizeof(int));//等同下面所有语句
    1.申请更大的内存
    //int* p = (int*)malloc(2 * n * sizeof(int));
    //assert(p != NULL);
    2.把原数据复制到新内存
    //for (int i = 0; i < n; i++)
    //{
    //    p[i] = arr[i];
    //}
    3.释放原内存
    //free(arr);
    4.更新地址
    //arr = p; p = NULL;

    return 0;
}
*/

liuyani12138
关注
各种变量（static、局部、全局、动态内存等等）的生命周期、链接属性、作用域、内存区域、默认值
小程的博客
11-25 455
局部变量：定义在函数内部的变量；（包括形参） 全局变量：定义在函数外部的变量 ；（尽量不要使用） C语言简单把内存分为四个存储区： 堆 栈 全局(静态)变量区 代码区 生命周期 作用域 默认值 内存区域 链接属性 静态全局变量 程序运行时创建 程序退出时销毁 整个文件 0 全局（静态）变量区 内部 普通全局变量 ...
为啥要动态内存和局部变量
acararduino的博客
12-28 369
先看代码,发现问题 #include <iostream> #include <Windows.h> using namespace std; int * add(int x,int y){ int sum=x+y; return &sum; } int * add1(int x,int y){ int *sum=NULL; sum=new int; ...
C语言 全局变量和局部变量的申请
北枫凉的博客
03-28 1191
今天在学习排序算法比较性能的时候，针对数组的申请出现了问题。 然后就去寻找为什么？ #include <stdio.h> int main(){ int a[1000000];//局部变量 return 0; } //编译运行后发现溢出错误 #include <stdio.h> int a[1000000];//全局变量 int main(){ return 0; ...
堆和栈的概念和区别
热门推荐
pt666的博客
04-27 31万+
在说堆和栈之前，我们先说一下JVM（虚拟机）内存的划分：       Java程序在运行时都要开辟空间，任何软件在运行时都要在内存中开辟空间，Java虚拟机运行时也是要开辟空间的。JVM运行时在内存中开辟一片内存区域，启动时在自己的内存区域中进行更细致的划分，因为虚拟机中每一片内存处理的方式都不同，所以要单独进行管理。       JVM内存的划分有五片：        1.   寄存器；
全局变量与局部变量在内存中的区别详细解析
01-01
1、栈区（stack）— 由编译器自动分配释放，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中的栈。 2、堆区（heap） — 一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收 。注意它与...
指针做形参做局部变量以及内存分配
08-18
指针做形参做局部变量以及内存分配 指针做形参是编程语言中的一种重要概念，它对程序的执行和结果产生重要影响。在C语言中，指针做形参可以分为一级指针和二级指针两种形式。一级指针做形参是指形参是一个指针变量...
深入探讨C语言中局部变量与全局变量在内存中的存放位置
09-05
在函数执行时，局部变量在栈（Stack）上分配内存，当函数执行完毕，这些内存会被自动释放。在程序的其他地方，局部变量是不可见的，不能被访问。例如，考虑以下示例： ```c int f1(int a) { int b, c; // ... } `...
局部变量申请栈空间时的入栈顺序
weixin_33881140的博客
03-29 432
运行环境：ubuntu 14.04(32bit) 编译环境：gcc Source Code: {stack_test.c} #include <stdio.h> #include <string.h> int main(int argc, char *argv[]) { char buffer_on...
C/C++ 局部变量 和new 动态申请
刘洋_heaven的博客
03-25 2763
下面一段c++程序 int i = 5; cout &lt;&lt; "dui_apply:" &lt;&lt; endl; while (--i){ int *dui_apply = new int; cout &lt;&lt; dui_apply &lt;&lt; endl; } cout &lt;&lt;endl&lt;&lt; "stack_init:&quo
局部变量全局变量和动态分配的数据分别在内存中存放的位置
wonder
02-28 2万+
局部变量分配的内存在栈里：栈大小与编译器有关。默认情况下，visual studio 2010 的栈大小为1M。 全局变量存放在静态存储区：对于全局变量来说，与编译器有关，默认情况下， VS2010可容纳的全局变量数组大小是2G。由于程序本身的应用，所以只能使用小于2G大小。 动态分配的数据存在内存的堆里面：在VS2010的默认情况下，32位程序可以申请的堆大小最大是2G，
静态局部变量和动态局部变量区别
ADbyCool的博客
05-13 6037
静态局部变量和动态局部变量区别： 1.静态局部变量属于静态存储类别，在静态存储区分配存储单元，在整个运行期间都不释放。 而自动变量(动态局部变量)属于动态存储类别，占动态存储空间，函数调用后释放 2.静态局部变量在编译时赋初值，程序运次时已经有初值，以后每次调用函数不再重新赋初值而只是保留上次函数调用结束时的值。 3.静态局部变量编译时赋初值默认是0 而自动变量，如果不赋初值则它的值是不确定的值。 4.静态局部变量在函数调用结束后仍然存在，但其他函数不能引用它。 如果用static修饰全局变量，那么该全局变
c语言中变量（存储区 栈）和malloc（动态申请 堆）的区别
小蚂蚁快溜跑
01-02 6951
1、变量： 不管全局变量还市局部变量都是系统自动分配管理的（静态储存区和动态存储区即栈），全局变量如果不人工初始化时系统会自动初始化；对于静态局部变量，编译时自动赋初值初始化；自动局部变量不初始化，他的值是不确定的，因为每次函数调用结束后储存单元已经释放，下一次调用是又重新分配存储单元，而其中内存的内容是不知道的。 2、 malloc可以随时开辟，不用时随时释放。这些数据是临时存放在一个特别
函数、全局变量、局部变量和动态内存的特点归纳
帅气的羊的博客
08-16 2443
   生命周期 作用域 默认值 内存区域 链接属性   全局变量(定义在函数外部的变量)   普通全局变量 程序运行开始创建，程序退出才销毁 从定义变量处到本文件结尾都能使用...
C语言的内存分配{静态内存&动态内存&堆栈}
xiandang8023的博客
07-28 1万+
除此之外，c语言还允许建立内存动态分配区域，以存放一些临时用的数据，这些数据不必在程序的声明部分定义，也不必等到函数结束时才释放，而是需要时随时开辟，不需要是随时释放。通常是用于那些在编译期间就能确定存储大小的变量的存储区，但它用于的是在整个程序运行期间都可见的全局变量和静态变量。静态全局变量则限制了其作用域，即只在定义该变量的源文件内有效，在同一源程序的其它源文件中不能使用它。所有的函数外部定义的变量，它的作用域是整个程序，也就是所有的源文件，包括.c和.h文件。已初始化的静态变量存放在.data段。..
【C语言刷力扣】1832.判断句子是否为全字母句
2301_76779875的博客
10-16 448
【C语言刷力扣】1832.判断句子是否为全字母句
nitime-0.8.1-cp35-cp35m-win_amd64.whl
最新发布
10-19
nitime-0.8.1-cp35-cp35m-win_amd64.whl
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值