C10_动态内存分配

来源:互联网 发布:java 数字分割 编辑:程序博客网 时间:2024/06/16 01:02


//

//  main.m

//  C10_动态内存分配

//

//  Created by dllo on 15/7/13.

//  Copyright (c) 2015 Clare. All rights reserved.

//


#import <Foundation/Foundation.h>


void func(){

   int x = 5;

   int y = 6;

    printf("x = %p\n", &x);

    printf("y = %p\n", &y);

}


char * fun()

{

    //是把一个常量区的常量字符串地址返回,但是如果返回一个数组的地址,在函数调用最好会回收栈的内容,返回不了结果,造成错误

   char *str = "iPhone";

   return str;

}


// 定义一个全局变量

int global =10;


// 测试静态变量只会初始化一次

void test()

{

   static int test =10;

    test +=2;

    printf("%d\n", test);

}


int main(int argc,const char * argv[]) {

//    // 五大区所对应的内存地址

///    /// 1.栈区(自动区)

//    int a = 10;

//    int b = 6;

//    printf("栈区的地址%p\n", &a);

//    printf("%p\n", &b);

//    func();

//    char *p = fun();

//    printf("%s\n", p);

//

//    // 所有地址都是16进制

//    // 栈空间一般会放变量,C语言的数组等数据

//    // 栈空间系统自己管理,开辟还是回收内存都由系统来做

//    // 先进后出

//    // 栈底对应的是内存的高地址,栈顶对应低地址,栈里的变量先进后出

//    

///    /// 2.堆区(手动区)

//    // 堆区只能使用匿名访问

//    int *p = malloc(40);

//    printf("堆区的地址%p\n", p);

//    // 这块内存:手动开辟,手动回收

//    

///    /// 3.全局静态区(静态区)

//    // 静态的变量

//    static int c;

//    printf("c = %d\n", c);

//    printf("全局静态区地址:%p\n", &c);

//    printf("%p\n", &global);

//

//    // 1.如果没有初始值,默认是0

//    // 2.周期从程序开始一直到程序结束才会消失

//    // 3.它只会被初始化一次

//    test();

//    test();

//    test();

//

///    /// 4.常量区(静态区)

//    int d = 10;

//   if (100 == d) {

//

//   }

//    // 常量在执行过程中不能发生变化,不能对常量进行赋值

//    char *p2 = "iPhone";

//    printf("常量区的地址:%p\n", p2);

//    char str[] = "iPhone";

//    

///    /// 5.代码区(静态区)

//    printf("代码区的地址:%p\n", test);

    

    

    ///动态分配堆区的空间

    

    // void * malloc(int size)

    //参数指的是所要申请的空间字节的大小

    // void *指的是无类型指针,需要它是什么类型,只需要用相应类型指针接收即可转换成相应的类型

    //返回的是堆空间的内存首地址

//    int *p = malloc(40); // 先申请内存

//    p[0] = 10; // *(p + 1) = 10一样

//    printf("%d\n", p[0]);

//    printf("%p\n", &p[0]);

//    printf("%p\n", p);

//    

//    int arr[5] = {1, 2, 3, 4, 5};

//    arr[0] = 10;

//    // 堆空间使用第一件事先开辟内存

//    

//    // 堆空间进行随机数的赋值,范围30 - 70

//    for (int i = 0; i < 10; i++) {

//        p[i] = arc4random() % (70 - 30 + 1) + 30;

//        printf("%d ", p[i]);

//    }

    

//    int *p = malloc(10 * sizeof(int));

    

//    // 开辟10个字节空间

//    

//    // 然后char * 指针来接收

//    

//    // 对这块内存进行赋值,赋值内容"iPhone"

//    char *p = malloc(10);

//    strcpy(p, "iPhone");

//    printf("%s\n", p);

//    

//    // 如果对p进行指针的重指向,原本保存堆空间的地址被替换,这部分堆空间就找不到了,发生这种问题称为内存泄露

//    

//    // 回收

//    free(p);

//    // 过度释放,释放两次以上

//    // free(p);

//    p[0] = 97;

//    printf("%d\n", p[0]);

//    

//    // 野指针:对一块已经释放掉的内存进行操作

//    

//    // 1.先使用malloc,申请相应字节数的空间

//    // 2.使用者部分内存

//    // 3.别忘了对他进行释放,不要过度释放

    

//    

//    // 有⼀字符串,其中包含数字,提取其中的数字.要求动态分配内存保存提示: 先计算出有⼏几个数字,然后根据数字的个数来开辟空间.

//    

//    char str[] = "ajdlai9184892u4oirjo914okrl2adkq9313k1faj912";

//    // 用来保存数字的个数

//    int numCount = 0;

//    for (int i = 0; i < strlen(str); i++) {

//        if (str[i] >= '0' && str[i] <= '9') {

//            numCount++;

//        }

//    }

//    

//    // 为数字进行内存分配,有多少个数字相应分配多少字节数

//    char *p = malloc(numCount + 1);

//    

//    // 把数字放入到堆空间的字符串里

//    int numIndex = 0;

//

//    for (int i = 0; i < strlen(str); i++) {

//        if (str[i] >= '0' && str[i] <= '9') {

//            p[numIndex] = str[i];

//            numIndex++;

//        }

//    }

//    // 把最后一位的'\0'进行赋值

//    p[numIndex] = '\0';

//    printf("%s\n", p);

//    

//    // 内存释放

//    free(p);


//    // calloc

//    // 用法和malloc差不多,只不过比malloc多一个刷碗的动作,会把每个字节的内容都清零

//    // void * calloc(int n, int size) n 个数 size 每一个字节尺寸

//    int *p = calloc(10, sizeof(int));

//    for (int i = 0; i < 10; i++) {

//        printf("%d", p[i]);

//    }

//    printf("\n");

//    

//    int *p1 = malloc(10 * sizeof(int));

//    for (int i = 0; i < 10; i++) {

//        printf("%d", p1[i]);

//    }

//    printf("\n");

    

//    int a = 10, b = 5, c = 1;

//    // 指针数组

//    int * arr[3] = {&a, &b, &c};

//    for (int i = 0; i < 3; i++) {

//        printf("%d \n", *arr[i]);

//    }

    

//    char *str[3] = {"iPhone", "Win8", "Android"};// 指针数组

//    char str1[3][20] = {"iPhone", "Win8", "Android"};// 字符串数组

//    for (int i = 0; i < 3; i++) {

//        printf("%s\n", str[i]); // 通过%s找到地址相应的内容

//    }

//    char *c = "iPhone";

    

    

//    // 输⼊3个学员的姓名,动态分配内存保存学员姓名,并在最后输出.提示:定义一个指针数组保存数据 char * word[3] = {0};

//    

//    // 输入三个学员的姓名,根据姓名长度,动态分配内存,然后进行存贮,最后进行打印

//    // 定义一个指针数组

//    char *words[3] = {0};

//    for (int i = 0; i < 3; i++) {

//        char temp[50] = "";

//        scanf("%s", temp);

//        words[i]/* ( 或者用 )char *p */ = calloc(strlen(temp) + 1, sizeof(char));

//        strcpy(words[i], temp);

      // strcpy(p, temp);

      // words[i] = p;

//    }

//    for (int i = 0; i < 3; i++) {

//        printf("%s\n", words[i]);

//        // free(words[i];

//    }

//    // 释放

//    for (int i = 0; i < 3; i++) {

//        free(words[i]);

//    }

    

    // recalloc:重新进行内存分配

//    int *p = calloc(10, sizeof(int));

//    int *pNew = realloc(p, 80);

//    printf("%p\n", p);

//    printf("%p\n", pNew);

    

//    // 内存操作函数

//    // 内存初始化

//    int *p =malloc(40);

//    // 对内存进行初始化设置

//    // 1.要初始化的空间

//    // 2.初始化把值设置成0

//    // 3.设置的范围

//    memset(p, 0, 40);

//    for (int i = 0; i < 10; i++) {

//        printf("%d\n", p[i]);

//    }

//    printf("\n");

    

//    // 内存拷贝

//    // 第三个参数:拷贝的范围字节数

//    int *p = calloc(10, sizeof(int));

//    int *pNew = calloc(10, sizeof(int));

//    for (int i = 0; i < 10; i++) {

//        p[i] = arc4random() % (70 - 30 + 1) + 30;

//        printf("%d ", p[i]);

//    }

//    printf("\n");

//    memcpy(pNew, p, 40);

//    for (int i = 0; i < 10; i++) {

//        printf("%d ", pNew[i]);

//    }

//    // strcpy(<#char *#>, <#const char *#>)

//    

    

//    // 内存比较

//    // 第三个参数:比较的范围

//    

//    int *p1 = calloc(1, sizeof(int));

//    int *p2 = calloc(1, sizeof(int));

//    *p1 = 256;

//    *p2 = 100;

//    

//    printf("%d\n", memcmp(p1, p2, 4));

//    // 比较的范围从0255

//

//    // strcmp(<#const char *#>, <#const char *#>)

    

    //定义两个整型指针,分别⽤用malloccalloc对其分配空间保存3个元,malloc分配的空间用memset清零,随机对数组进⾏行赋值随机范1-3,赋值后⽤用memcmp⽐比较两个数组。如果相同打印Good!否则打印Failed...

    

   int *p1 = malloc(3 *sizeof(int));

   int *p2 = calloc(3,sizeof(int));

    // 清零

    memset(p1,0, 12);

   for (int i =0 ; i < 3; i++) {

        p1[i] = arc4random() % (3 -1 + 1) + 1;

        p2[i] = arc4random() % (3 -1 + 1) + 1;

        printf("%d %d\n", p1[i], p2[i]);

    }

//    for (int i = 0; i < 3; i++) {

//        printf("%d ",p1[i]);

//    }

//    printf("\n");

//    for (int i = 0; i < 3; i++) {

//        

//        printf("%d ",p2[i]);

//    }

//    printf("\n");

    // 最后内存比较

    memcmp(p1, p2,12);

   if (memcmp(p1, p2, 12) == 0) {

        printf("Good!\n");

    }else {

        printf("Failed!\n");

    }

    printf("\n");

    

    free(p1);

    free(p2);

    

    


   return 0;

}


0 0