内存管理(new)

内存管理(new)

一、作用域和生命周期

（1）变量

作用域：作用的范围

a.普通局部变量

#include <stdio.h>

int main(int argc,char *argv[])
{
    //在{}内部定义的变量就是局部变量
    //只有执行到定义变量的这个语句，系统才会给这个变量分配空间
    //当离开{}，这个非static局部自动释放
    //局部变量的作用域在当前的{}，离开此{}，无法使用此变量
    //{}的普通局部变量，加不加auto关键字等价，普通局部变量也加自动变量
    //不同的{}中，变量名字可以一样
    //普通局部变量不初始化，它的数为随机数
    int tmp=11;

    {
		int a=10;  
        
        {
            a=11;//ok还在作用域内
        }
    }
    
    a=11;//err因为a只有在上面的{}内有效
}

b.static局部变量

#include <stdio.h>

	//在{}内部定义的变量就是局部变量
    //static局部变量，实在编译阶段就已经分配空间，函数没有调研前，它就已经存在
    //当离开{}，static局部变量不会释放，只有程序结束，static变量才会自动释放
    //局部变量的作用域在当前的{}，离开此{}，无法使用此变量
    //{}的普通局部变量，加不加auto关键字等价，普通局部变量也加自动变量
    //不同的{}中，变量名字可以一样
	//如果static局部变量不初始化，
	//如果static局部变量不初始化，它的值默认为0
	//static局部变量初始化语句，只会执行一次，但是可以赋值多次 
	//static变量只能用常量初始化
void fun()
{
    int i=0;
    i++;
    printf("i=%d\n",i);
}

void static_fun()
{
    static int i=0;
    i++;
    printf("static_i=%d\n",i);
}

int main(int argc,char *argv[])
{
    fun();//1
    fun();//1
    fun();//1
    
    static_fun();//1
    static_fun();//2
    static_fun();//3
    
    
}

c.普通局部变量和static局部变量的区别

1. 内存分配和释放
   1. 普通局部变量只有执行到定义变量的语句才分配空间
   2. static局部变量在编译阶段（函数还没有执行），变量的空间已经分配
   3. static局部变量只有在整个程序结束才自动释放
2. 初始化
   1. 普通局部变量不初始化，值为随机数
   2. static局部变量不初始化，值为0
   3. static局部变量初始化语句只有第一次执行时有效
   4. static局部变量只能用常量初始化

d.普通全局变量

#include <stdio.h>

//在{}外面（函数外面）定义的变量为全局变量
//只有定义了全局变量。任何地方都能使用此变量
//如果使用变量时，在前面找不到此全局变量的定义，需要声明才能使用
//全局变量不初始化，默认赋值为0
//声明只是针对全局变量，不是针对局部变量
//全局变量只能定义一次，但是能声明多次
//全局变量在编译阶段已经分配空间（函数没有执行前），只有在整个程序结束，才自动释放

void fun2()
{
    printf("fun2 a=%d\n",a);//err在定义的前面，需要声明
}

void fun3()
{
    extern int a;//声明时，不能赋值
    printf("fun3 a=%d\n",a);
}

int a=10;

void fun()
{
    a=11;
}

int main()
{
    fun();
    
    printf("a=%d\n",a);
    
    fun2()
    
    
}

e.C语言全局变量的缺陷

#include <stdio.h>

int a;
int a;
int a=0;//定义，其他为声明
int a;
int a;

int b;
int b;
int b;
int b;
//有一次是定义，其他为声明
//如果定义一个全局变量，没有赋值，无法确定是定义还是声明

f.C语言全局变量声明和定义的建议写法

#include <stdio.h>

//定义一个全局变量，建议初始化
int a=10;

//如果声明一个全局变量，建议加extern
extern int a;

g.static全局变量

1. static全局变量和普通全局变量的区别就是作用域不一样（文件作用域）
2. extern关键字只适用于普通全局变量
3. 一个文件只能有一个static全局变量
4. static全局变量只能在当前文件使用，别的文件不能使用
5. 不同文件只能出现一个普通全局变量的定义
6. 一个文件只能有一个static全局变量的定义，不同文件间的static全局变量就算名字相同，也是没有关系的两个变量

h.普通函数和static函数的区别（文件作用域）

1. 所以文件只能有一个普通函数的定义
2. 一个文件可以有一个static函数的定义
3. 普通函数所有文件都能调用，前提是使用前声明
4. static函数只能在定义所在的文件中使用

i.总结

类型	作用域	生命周期
auto变量	一对{}内	当前函数
static局部变量	一对{}内	整个程序运行期
extern变量	整个程序	整个程序运行期
static全局变量	当前文件	整个程序运行期
extern函数	整个程序	整个程序运行期
static函数	当前文件	整个程序运行期
register变量	一对{}内	当前函数

二、内存分区

（1）内存分区

在程序没有执行前，有几个内存分区已经确定，虽然分区确定，但是没有加载内存，程序只有运行时才加载内存：

• text(代码区)：只读，函数
• data：初始化的数据，全局变量，static变量，文字常量区（只读）
• bss：没有初始化的数据，全局变量，static变量

当运行程序，加载内存，首先根据前面确定的内存分区（text,data，bsss)先加载，然后额外加载两个区

• stack（栈区）：普通局部变量，自动管理内存，有先进后出的特点
• heap（堆区）：手动申请，手动释放，整个程序结束，系统也会自动回收，如果没有手动释放，程序也没有结束，这个堆区不会自动释放

（2）栈越界

#include <Stdio.h>
#include <Stdlib.h>

int main()
{
    //语法上没有问题，栈区分配很大的内存，越界了，导致段错误
    //int a[100000000]={0};
    
    int *p=(int *)malloc(1000000000*sizeof(int));
    if(p==null)
    {
        printf("分配失败\n");
    }
    
    return 0;
}

(3)内存操作函数

a.memset()

#include <stdio.h>
void *memset(void *s,int c,size_t n);
//功能：将s的内存区域的前n个字符以参数c填入
//参数：
//s：需要操作内存s的首地址
//c：填充的字符：c虽然参数为int，但必须是unsigned char,范围为0~255
//n：指定需要设置的大小
//返回值：s的首地址

int a[10];

memset(a,0,sizeof(a));
memset(a,97,sizeof(a));
int i=0;
for(i=0;i<10;i++)
{
    printf("%c\n",a[i]);
}

#include <stdio.h>
#include <string.h>

int main()
{
    int a;
    memset(&a,0,sizeof(a));//常用
    printf("a=&d\n",a);
    
    //中间参数虽然是整型，但是以字符处理
    memset(&a,97,sizeof(a));
    printf("a1=%c\n",a);
    
    return 0;
}

b.memcpy的使用

#include <stdio.h>

int main()
{
    char p[]="hello\0mike";//以字符串初始化，自动默认隐藏一个结束符'\0'
    char buf[100];
    printf("sizeof(p)=%lu\n",sizeof(p));
    strncpy(buf,p,sizeof(p));
    printf("buf1=%s\n",buf);//hello
    printf("buf2=%s\n",buf+strlen("hello")+1);//NULL
    
    memset(buf,0,sizeof(buf));
    memcpy(buf,p,sizeof(p));
    printf("buf3=%s\n",buf);//hello
    printf("buf4=%s\n",buf+strlen("hello"+1));//mike
}

c.memmove和memcmp的使用

#include <Stdio.h>

int main()
{
    int a[10]={1,2,3,4,5,6,7,8,9,10};
    int b[10];
    
    //第3个参数是指拷贝内存的总大小
    memcpy(b,a,10*sizeof(int));
    memcpy(b,a,sizeof(a));
    
    //使用memcpy()最好别出现内存重叠
    //如果出现内存重叠，最好使用memmove
    memcpu(&a[2],a,5*sizeof(int));//err
    memmove(&a[2],a,5*sizeof(int));
}

三、栈区堆区空间

（1)指针指向栈区空间

#include <Stdio.h>

int main()
{
    int *p;
    int a;//定义一个栈区变量
    p=&a;//指针指向栈区空间
    
    *p=10;
    printf("*p=%d\n",*p);
    
    return 0;
}

(2)指针指向堆区空间

//malloc(sizeof(int));
//参数是指定堆区分配多大的空间
//返回值：成功就是堆区空间首元素地址
//失败返回NULL

#include <stdio.h>
#include <stdlib.h>

int main()
{
    int *p;
    
    p=(int *)malloc(sizeof(int));
    
    *p=10;
    printf("*p=%d\n",*p);
    
    return 0;
}
//动态分配的空间，如果程序没有结束，不会自动释放
//一般使用完，需要人为释放free()
//free(P)；不是释放p变量，而是释放p所指向的内存
//同一块堆区内存只能释放一次、
//释放不是指内存消失，而是指这块内存用户不能再使用，系统回收了，如果用户再用，就是操作非法内存

//内存泄漏：动态分配了空间，不释放