【【萌新的c语言学习-11】】

萌新的c语言学习-11

判断题

void GetMemory(char* p)

{
    p = (char*)malloc(100);
}
void Test(void)

{
    char* str = NULL;
    GetMemory(str);
    //改正方法 改成&str
    strcpy(str, "hello world");
    printf(str);
}
int main()
{
    Test();
    return 0;
}

这题为什么不对，p其实是str的拷贝
然后在堆上malloc开了一块空间 地址赋给了p
回来之后 str其实没有传过去 里面还是空指针
结束之后p又销毁了，没人记住p里面是什么

---

//还有一种方法

char* GetMemory(char* p)

{
    p = (char*)malloc(100);
    return p;
}
void Test(void)

{
    char* str = NULL;
    str=GetMemory(str);
    //我把p这个指针传递出去 让str接受
    strcpy(str, "hello world");
    printf(str);
}
int main()
{
    Test();
    return 0;
}

---

char* getmemory(void)
{
char p[] = "hello world";
return p;
}
void test(void)
{
char* str = NULL;
str = getmemory();
printf(str);
}
int main()
{
test();
return 0;
}
//输出乱码
//因为他并不是由malloc申请的 再出了这个空间就销毁了
//那么虽然传过来一个地址 但是里面什么也没有
//返回栈空间地址的题

---

int* test()
{
    static int a = 10;
    return &a;
}
int main()
{
    int* p = test();
    *p = 20;
    return 0;
}
//这样就可以了，因为static修饰全局变量

malloc的空间在堆区 堆区不释放就不会销毁

void getmemory(char** p, int num)
{
    *p = (char*)malloc(num);

}
void test(void)
{
    char* str = NULL;
    getmemory(&str, 100);
    strcpy(str, "hello");
    printf(str);
}
int main()
{
    test();
    return 0;
}

这个问题就是最后忘记释放那部分内存 可能会导致内存泄漏

---

C/C++ 内存开辟的过程
内存区域
只要关注 栈 堆区 静态区
比如说计算机是4G那么有2个G是分给内核空间 （用户不能读写）
剩下2个G是给我们来操作的
数据段 代码段就叫静态区
一般来说全局变量 局部变量这种都算是放到我们的静态区的
然后int a int*p 这种都是放到栈内的
常量字符串就会放到代码段中，就是只读数据

//柔性数组
//意思就是结构中的最后一个元素允许是未知大小的数组
//

struct s
{

    int n;
    int arr[];//这种写法和int arr[0] 这两种写法是一样的
    //柔性数组成员-数组的大小是可以调整的

};
int main()
{
    struct s s;
    //我们开始对柔性数组进行创建
    struct s* p =(struct s*) malloc(sizeof(struct s) + 5 * sizeof(int));
    //这一句代码相当于前面那段是描述int 就是创建了sizeof(struct s)
    // 而后面的5*sizeof(int) 这20个字节都是赋给了arr
    return 0;
}

---

struct s 
{
    int n;
    int* arr;
};
int main()
{
    struct s* ps = (struct s*)malloc(sizeof(struct s));
    //首先根据柔性数组的定义创建
    ps->arr = malloc(5 * sizeof(int));
    //然后数组指定多少空间
    int i = 0;
    for (i = 0;i < 5;i++)
    {
        ps->arr[i] = i;
    }
    //赋值
    for (i = 0;i < 5;i++)
    {
        printf("%d ", ps->arr[i]);
    }
    //接下来调整整个空间的大小
    int* ptr = realloc(ps->arr, 10 * sizeof(int));
    if (ptr != NULL)
    {
        ps->arr = ptr;
    }
    for (i = 5;i < 10;i++)
    {
        ps->arr[i] = i;
    }
    for (i = 0;i < 10;i++)
    {
        printf("%d ", ps->arr[i]);
    }
    free(ps->arr);
    ps->arr = NULL;
    free(ps);
    ps=NULL;
    return 0;
}

//0 1 2 3 4 1 2 3 4 5 6 7 8 9
分析我们先创建一个结构体 使它可大可小
我们先创建一个指针指向了malloc开辟的空间
这个空间他写了sizeof(struct(s)),那么空间既有n 又有 arr 是malloc开辟 我们希望空间可以调整
那么再开辟一个空间
因为我一开始就是用的Int * arr 这arr 本来就是一个地址 我们接下来再开辟的空间就由指针arr指向它不就行了
柔性数组的创建时
structuralsps（struct s)malloc(sizeof(struct s)+5*sizeof(int))
在柔性数组开辟空间的时候 sizeof(struct s) 并没有包含arr的创建
而后面直接创建了一个大的数组
柔性数组的好处
柔性太方便了
后面的话指定指定下去可能会出错
两次malloc开辟的空间并不确定，那么我们去拿数据的时候，效率就会大大下降了