iOS C语言10_动态内存分配

//

//  main.m

//  C10_动态内存分配

//

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

//  Copyright (c) 2015年 zhozhicheng. 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);

    // 栈空间一般会放变量,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;

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

//    char *p2 ="iphone";     //常量字符串

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

    

    // 5.代码区

//    printf("代码区的地址%p",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);

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

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

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

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

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

//    }

    

    

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

    

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

//    char * p=malloc(10);

//    

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

//    strcpy(p, "iphone" );

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

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

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

//    // 回收

//    free(p);

//    // 过度释放

    free(p);       // 崩溃

//    // ( 开辟  使用 回收 )

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

    

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

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

    // 2.使用这部分内存

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

    

    // 练习

//    char str[]="fjaikgfasg14fs5df4a2445as";

//    int j = 0;               // 保存数字个数

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

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

//            j++;

//          

//            

//        }

//    }

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

//    char *p = malloc(j + 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)

//    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"};

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

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

//    }

    

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

    //定义一个指针数组

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

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

//        char temp[50]="";

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

//        words[i] = calloc(strlen(temp)+1, sizeof(char));

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

//        

//  

//        

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

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

//    }

//    // 释放

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

//        free(words[i]);

//    }

//    

//    

    

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

//    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]);

//    }

//    printf("\n");

    

    

    // 内存比较

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

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

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

//    *p1=255;

//    *p2=100;

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

//    // 比较的范围从0--255

  

//    int *p =malloc(12);

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

//    memset(p, 0, 12);

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

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

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

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

//    }

//    // 最后比较

//    if (memcmp(p, p1, 12)==0) {

//        printf("GOOD\n");

//    }else{

//        printf("Failed\n");

//    }

//    free(p);

//    free(p1);

    

    

    

    

    return 0;

}