C10_动态内存分配

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

// main.m

// C10_动态内存分配

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

#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();

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

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

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

//定义两个整型指针,分别⽤用malloc、calloc对其分配空间保存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