C语言10 -- 动态内存分配

//
// main.m
// C10 – 内存
//
// Created by dllo on 15/7/13.
// Copyright (c) 2015年 Gaozi. All rights reserved.
//

import

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

//1.栈区(定义的变量)
  /*
 栈空间一般会存放变量,C语言的数组等数据.
 栈空间系统自己管理,开辟还是回收内存都有系统来做
 栈底对应的是内存高的地址,栈顶对应的是低地址,栈里的变量先进后出.
 */

// int a = 10;
int b = 6;
// printf(“栈区的地址:%p\n”,&a);
printf(“b的栈区地址:%p\n”,&b);
FUNC();
// 栈区的不安全性:
char *p = fun();
printf(“%s\n”,p);

//
// //2.堆区
// //堆区只能使用匿名访问
// int *p = malloc(40);
// printf(“堆区的地址:%p\n”,p);
// // 这块内存:手动开辟,手动回收.
//
//
// //3.全局静态区
// //静态变量
// static int c = 10;
// printf(“全局静态地址:%p\n”,&c);
// printf(“全局变量地址%p\n”,&global);
//
// // 特点:1.如果c没有初始值,默认是0.
// // 2.它的活动周期从程序开始一直到程序结束才会消失.
// // 3.它只会被初始化一次.证明如下:
// test();//test 从10开始,+2 得12;
// test();// 已有了test,值为12,得14;
// test();

//4.常量区
// int d = 10;
// for (int i = 0; i = 100/* 100 = i || 100 == i */ ; i++) {
// printf(“%d\n”,i);
// }//会不断循环打印100;
// //常量在执行过程中不能发生变化,不能对常量进行赋值.
// char *p2 = “iphone”;
// printf(“常量区地址:%p\n”,p2);
// // 使用时提取复制放回.

// //5.代码区
// printf(“代码区地址:%p\n”,test);

// 二 – 堆内存分配函数

// 动态内存分配
//  void *malloc(unsigned int size);
// 参数指的是所要申请的空间字节大小.
// void *指的是无类型指针,需要他是什么类型,只要有相应类型指针接手即可缓缓为其他类型.
//返回的是堆空间内存的首地址.

// int *p = malloc(40);// 40字节数.
// p[0] = 10;
// *(p + 1) = 20;
// printf(“%d\n”,p[1]);
// 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 “,p[i]);
// }
// printf(“\n”);
// int p = malloc(10 sizeof(int));

// //开辟10个字节空间,对内存赋值.
// char *p = malloc(10);
//
// char str[7] = “iphone”;
// strcpy(p, str);
// printf(“%s\n”,p);
//
// //如果对p进行指针的重指向,原本保存的堆空间的地址被替换,这部分空间就找不到了,发生这种情形称为内存泄露.
//

// // 回收!

// free(p);
// // free(p);// 称为过度释放,系统将会崩溃.
// p[2] = 97;
// printf(“%d\n”,p[2]);

// 野指针: 对一块已经释放掉的内存进行操作,程序将会崩溃.

// 1.先使用malloc申请一部分内存空间.
// 2.使用这部分内存
// 3.别忘了释放啊且只能释放一次!!!free(p)

// // 练习.
// char str1[50] = “ha333isfh112sld1iugskosd”;
// int len = 0;
// for (int i = 0; i < strlen(str1); i++) {
// if (str1[i] <= ‘9’ && ‘0’ <= str1[i]) {
// len++;
// }
// }
// // 为数字进行内存分配,有多少个数字分配多少个字节数.
// char *p1 = malloc(len + 1);// +1 是为’\0’准备的.
//
// // 把数字放入兑空间的字符串中.
// int numindex = 0;
// for (int i = 0; i < strlen(str1); i++) {
// if (str1[i] <= ‘9’ && ‘0’ <= str1[i]) {
// p1[numindex] = str1[i];
// numindex++;
// }
// }
// // 把最后一位’\0’进行赋值
// p1[numindex]=’\0’;
// printf(“%s\n”,p1);
// // 内存的释放.
// free(p1);

// // 三 – 内存分配的其他几种函数

// // calloc – 用法与malloc差不多,区别在使用前把该内存上的所有字节清零,相当于刷碗动作.
// //
// 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”);
// free(p);

// int a = 10,b = 9,c = 5;
// // 指针数组.
// int *arr[3] = {&a,&b,&c};
// for (int i = 0; i < 3; i++) {
// printf(“%d “,*arr[i]);
// printf(“%p\n”,arr[i]);
// }
//
char str[3][20] = {“iphone”,”lala”,”crazy”};– 字符串数组.
// // 字符串指针数组.
// char *str[3] = {“iphone”,”lala”,”crazy”};
// for (int i = 0; i < 3; i++) {
// printf(“%p “,str[i]);
// printf(“%s\n”,str[i]);
// }

// // 输入三个人姓名,根据姓名长度,动态分配内存,然后存储,最后打印.
//
// // 定义一个指针数组
// char *Name[3] = {};
// for (int i= 0; i < 3; i++) {
// char temp[50]=”“;
// scanf(“%s”, temp);
// Name[i] = calloc(strlen(temp)+1, sizeof(char));
// strcpy(Name[i], temp);
// }
// for (int i= 0; i< 3; i++) {
// printf(“%s的地址为: “, Name[i]);
// printf(“%p\n”, Name[i]);
// // 也可以在这释放.
// // free(Name[i]);
// }
// // 指针数组释放!
// for (int i = 0; i < 3; i++) {
// free(Name[i]);
// }

// // realloc – 重新进行内存分配
// int *p = calloc(10, sizeof(int));
// printf(“%p \n”,p);
// int *pNew = realloc(p, 80);
// printf(“%p \n”,p);
// printf(“%p \n”,pNew);

// 四– 内存操作函数

// // 1. 内存的初始化.
// int *p = malloc(40);
// for (int i = 0; i < 10; i++) {
// printf(“%d “,p[i]);
// }
// printf(“\n”);
// // 对内存进行初始化设置
// // 1.要初始化的地址
// // 2.初始化把值设置成0.
// // 3.设置的范围
// // memset(<#void *#>, <#int#>, <#size_t#>)
// memset(p, 0, 40);
// for (int i = 0; i < 10; i++) {
// printf(“%d “,p[i]);
// }
// printf(“\n”);
// free(p);
// malloc 与 memset 的组合效果和calloc一样.

// //2. 内存的拷贝
// // 对比发现: 第三个参数 — 拷贝的范围字节数,需要拷贝多少字节的内容.
// // memcpy(<#void #>, <#const void #>, <#size_t#>)
// //strcpy(<#char #>, <#const char #>)
//
// 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;
///法2:/ pNew[i] = p[i];
// printf(“%d “,p[i]);
// }
// printf(“\n”);
法1: memcpy(pNew, p, 10*sizeof(int));
// for (int i = 0; i < 10; i++) {
// printf(“%d “,pNew[i]);
// }
// printf(“\n”);
// free(p);
// free(pNew);

// // 3. 内存比较
// // 区别: 第三个参数比较的范围.
// // memcmp(<#const void #>, <#const void #>, <#size_t#>)
// // strcmp(<#const char #>, <#const char #>)
//
//
// int *p1 = calloc(1, sizeof(int));
// int *p2 = calloc(1, sizeof(int));
// *p1 = 1;
// *p2 = 255;
// printf(“%d\n”,memcmp(p1, p2, 1*sizeof(int)));
// // 比较的范围从0到255.
// free(p1);
// pree(p2);

// 练习

int *p1 = malloc(3*sizeof(int));
int *p2 = calloc(3, sizeof(int));
memset(p1, 0, 3*sizeof(int));
for (int i = 0; i < 3; i++) {
p1[i] = arc4random() % (3 - 1 +1)+1;
p2[i] = arc4random() % (3 - 1 +1)+1;
}printf(“p1:”);
for (int i = 0; i < 3; i++) {
printf(“%d “,p1[i]);
}
printf(“\n”);
printf(“p2:”);
for (int i = 0; i < 3; i++) {
printf(“%d “,p2[i]);
}
printf(“\n”);
if (memcmp(p1, p2, 3*sizeof(int)) == 0) {
printf(“Good!\n”);
}else{
printf(“Failed!\n”);
}
free(p1);
free(p2);

return 0;

}