iOS-C_Day12___内存

2015.2.3

//内存

//.text: 可执行程序

//.data: 分为只读数据段, 以及可读可写数据段, 只读数据段存放常量如:"hello world" 可读可以数据段存初始化的全局变量及static关键字修饰的变量

//.bss: 未初始化的全局变量及static修饰的变量

//.heap: 也叫堆内存,需要手动申请,手动释放,堆空间比较大,运行效率低于栈内存

//.stack: 也叫栈区,存放局部变量,系统自动释放内存,内存比较小,运行效率最高

//static

//1.修饰全局变量,只在当前.c文件内有效

//2.修饰局部变量,作用域是局部的变量的作用域,但是存储在.data区,只有在第一次调用的使用开辟内存

//3.修饰函数,这个函数只能在当前.c文件内使用

#include "Static.h"

static int num=100;

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

{

printf("num = %d\n", num);

num++;

printf("num = %d\n", num);

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

print();

changeValue(300);

print();

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

printScore();

}

//printHello();

hello() ;

return 0;

}

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

//malloc

//void *memset(void *, int, size_t);

//void *malloc(size_t);

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

//    //1.申请内存

//    char *pstr = (char *)malloc(100*sizeof(char));//有可能内存申请失败,内存申请失败返回NULL;

//    //int *score = malloc(50*sizeof(int));

//    //2.判断内存是否申请成功

//    if(!pstr)

//    {

//        return -1;

//    }

//    //3.申请到的内存值是未定义的,需要给这块内存赋初值

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

////        printf("%c", *(pstr+i));

////    }

//    //

//    memset(pstr,0,100);//把内存清0

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

////        printf("%d", *(pstr+i));

////    }

//    //4.使用内存,

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

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

//    //5.释放内存,告诉操作系统,当前这块内存可以被其它程序使用

//    free(pstr);

//    //6.指针该内存的指针变量赋值为NULL

//    pstr = NULL;

//

//    return 0;

//}

//calloc

//void *calloc(size_t count, size_t size);

//1.内存大小 = count * size

//2.申请到的内存被初始化成0

//The calloc() function contiguously allocates enough space for count objects that are size bytes of memory each and returns a pointer to the allocated memory.  The allocated memory is filled with bytes of value zero.

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

//{

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

//    if (!score) {

//        return -1;

//    }

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

//        scanf("%d", &score[i]);

//    }

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

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

//    }

//    printf("\n");

//    free(score);

//    score = NULL;

//    return 0;

//}

//利用malloc 跟memset 实现my_calloc

//void *my_calloc(size_t count, size_t size)

//{

//    void *p = malloc(count*size);

//    if (!p) {

//        return NULL;

//    }

//    memset(p, 0, count*size);

//    return p;

//}

//

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

//{

//    char *pstr = my_calloc(100, sizeof(char));

//    if (!pstr) {

//        return -1;

//    }

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

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

//    free(pstr);

//    pstr = NULL;

//

//    return 0;

//}

//free()

// The free() function deallocates the memory allocation pointed to by ptr. If ptr is a NULL pointer, no operation is performed.

//1. 不能释放一个空指针

//2. 同一块内存不能释放多次

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

//{

//    char *ptr = (char *)malloc(100*sizeof(char));

//    if (!ptr) {

//        return -1;

//    }

//    free(ptr);

//    //free(ptr);

//    ptr = NULL;

//    return 0;

//}

//realloc

//void *realloc(void *ptr, size_t size);

//realloc(NULL , 100) <==> malloc(100)

//realloc(ptr, 0)  <==> free(ptr)

//如果ptr指针指向的内存空间足够扩展新的内存,ptr指向的内存地址不变,否则,重新在堆内存中开辟新的内存块,把原来内存块的内容复制一份到新的内存块中, 并释放原来的内存块,扩展的内存不一定初值为0

//The realloc() function tries to change the size of the allocation pointed to by ptr to size, and returns ptr.  If there is not enough room to enlarge the memory allocation pointed to by ptr, realloc() creates a new allocation, copies as much of the old data pointed to by ptr as will fit to the new allocation, frees the old allocation, and returns a pointer to the allocated memory.  If ptr is NULL,realloc() is identical to a call to malloc() for size bytes.  If size is zero and ptr is not NULL, a new, minimum sized object is allocated and the original object is freed.  When extending a region  allocated with calloc(3), realloc(3) does not guarantee that the additional memory is also zero-filled.

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

//{

//    char *ptr = malloc(10*sizeof(char));

//    if (!ptr) {

//        return -1;

//    }

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

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

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

//    int len = (int)strlen(ptr);

//

//    ptr = realloc(ptr, 1000);

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

//    scanf("%s", ptr+len);

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

//

//    free(ptr);

//    ptr = NULL;

//    return 0;

//}

//realloc(NULL , 100) <==> malloc(100)

//realloc(ptr, 0)  <==> free(ptr)

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

//{

//    char *ptr = (char *)realloc(NULL, 100*sizeof(char));//malloc(100)

//    if (!ptr) {

//        return -1;

//    }

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

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

//    realloc(ptr, 0);//<==> free(ptr)

//    ptr = NULL;

//    return 0;

//}

//memchr

//void *memchr(const void *s, int c, size_t n);

//s:要查找的内存地址

//c:要查找的字符

//n:查找内存块的大小

//返回字符在内存中第一次出现的地址,找不到返回NULL

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

{

//    char *pstr = (char *)malloc(100*sizeof(char));

//    if (!pstr) {

//        return -1;

//    }

//    memset(pstr, 0, 100);

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

//    printf("%s\n",memchr(pstr, ‘A‘, 100));

//    free(pstr);

//    pstr = NULL;

int *pint = malloc(100*sizeof(int));

if (!pint) {

return -1;

}

memset(pint, 0, 100*sizeof(int));

pint[10]=97;

printf("%c\n",*((char *)memchr(pint, ‘a‘,100*sizeof(int))));

return 0;

}

*/

//比较两个内存块的大小

//int memcmp(const void *s1, const void *s2, size_t n);

//s1,s2分别指向两块内存

//n:比较内存的字节数

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

//{

//    int a[5]={1,2,-1,4,5};

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

//

//    int ret = memcmp(a, b, 20);

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

//

//    return 0;

//}

//void *memcpy(void *dst, const void *src, size_t n);

//The memcpy() function copies n bytes from memory area src to memory area dst.  If dst and src overlap,behavior is undefined.  Applications in which dst and src might overlap should use memmove(3) instead

//把src指向的内存空间的值复制n个字节到dst指针指向的内存空间,dst 跟 src 指向的内存空间不能有重叠;

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

{

//char str[100]="helloworldqianfengjiaoyu";

char *str=malloc(100*sizeof(char));

strcpy(str, "helloworldqianfengjiaoyu");

char buf[100]={};

memcpy(buf, str, 10);

printf("%s\n", buf);

memcpy(&str[1], str, 20);

printf("%s\n",str);

return 0;

}*/

//void *memmove(void *dst, const void *src, size_t n);

//把src指向内存空间的值拷贝n个字节到dst 指向的内存中

//dst 与 src指向的内存空间可以重叠

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

//{

//    char dst[100]={};

//    char src[100]="qianfengjiaoyu";

//    src[20]=‘A‘;

//    memmove(dst, src, 21);

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

//    int len = (int)strlen(src);

//    memmove(src, &src[1], len-1);

//    *(src+len-1) = ‘\0‘;

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

//

//    return 0;

//}

//void *memmem(const void *big, size_t big_len, const void *little, size_t little_len)//C89标准中没有这个函数

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

{

char big[100]="hellowordlqianfengjiaoyu";

char little[20]="feng";

char *pstr = NULL;

pstr = memmem(big, 100, little, 3);

printf("%s\n", pstr);

return 0;

}

时间： 2024-10-26 19:21:09

iOS-C_Day12___内存的相关文章

iOS平台内存使用原则

2 iOS平台内存使用原则 2.1 对象的所有权与销毁 2.1.1 谁创建,谁释放: 如果是以alloc,new或者copy,mutableCopy创建的对象,则必须调用release或者autorelease方法释放内存: 如果没有释放,则导致内存泄漏! 2.1.2 谁retain,谁释放: 如果对一个对象发送 retain消息,其引用计数会+1,则使用完必须发送release或者autorelease方法释放内存或恢复引用计数: 如果没有释放,则导致内存泄漏! 2.1.3 没创建且没reta

说说iOS与内存管理（上）

http://www.cocoachina.com/ios/20150625/12234.html 说起内存管理,看似老生常谈,而真正掌握内存管理的核心其实并不简单.ARC/MRR以及“谁分配谁就负责释放”这种基本原则是很重要的,但不是本文要讨论的重点.之前本人还没在小站发过相关的文章,本篇文章中,我本人是想结合实际开发和调试中遇到的一些细节问题,来谈谈iOS的内存管理内在机制和调试方法. 上一篇文章已经是4月份的了,时间飞快又过去了好久,小站5月份没有文章更新,罪过罪过.最近小站的站长我又转换

理解 iOS 的内存管理

理解 iOS 的内存管理 远古时代的故事 那些经历过手工管理内存(MRC)时代的人们,一定对 iOS 开发中的内存管理记忆犹新.那个时候大约是 2010 年,国内 iOS 开发刚刚兴起,tinyfool 大叔的大名已经如雷贯耳,而我还是一个默默无闻的刚毕业的小子.那个时候的 iOS 开发过程是这样的: 我们先写好一段 iOS 的代码,然后屏住呼吸,开始运行它,不出所料,它崩溃了.在 MRC 时代,即使是最牛逼的 iOS 开发者,也不能保证一次性就写出完美的内存管理代码.于是,我们开始一步一步调试

总结 IOS 7 内存管理

[iOS7的一些总结]5.iOS中的内存管理 我们知道,为了更加方便地处理内存管理问题,将开发人员从繁琐的内存的分配和释放工作中解放出来而专注于产品和逻辑,iOS提供了一种有效的方法, 即自动引用计数ARC.采用了ARC之后,绝大部分内存管理的问题就不需要我们继续操心了.但是从另一个方面讲,这个方便的工具也助长了程序员的懒惰情 绪,很多新手和学生甚至连引用计数的含义都不清楚.的确,这部分内容相对比较难以理解,不过如果能深刻地领悟之后将会是未来学习和开发中的强大助推器. 1.关于对象所有权的概念:

iOS之内存管理（ARC）

iOS的内存管理,相信大家都不陌生,之前是使用的MRC,由开发人员手动来管理内存,后来使用了ARC,来由系统管理内存.本文主要讲讲Autorelease,Core Foundation对象在内存管理方面要注意的地方. Autorelease 提到内存管理,就不得不提autorelease,虽然我们平时开发中很少会感知到它的存在.autorelease就是自动释放的意思,如果变量使用autorelease来修饰,就表明变量的释放由系统来完成. autoreleasepool是由runloop在开启

iOS基础 ----- 内存管理

Objective-C 的内存管理方式有引用计数机制,垃圾回收机制,自动释放池.有alloc,就有释放.iOS应?程序出现Crash(闪退),90%的原因是因为内存问 题.在?个拥有数?个甚?是上百个类的?程?,查找内存问 题极其困难,学会内存管理,能帮我们减少出错的?率.内存问题体现在两个??:内存溢出.野指针异常. 引用计数器 在Xcode4.2及之后的版本中由于引入了ARC(Automatic Reference Counting)机制,程序编译时Xcode可以自动给你的代码添加内存释放代

iOS中内存管理

iOS中创建对象的步骤: 1,分配内存空间,存储对象 2,初始化成员变量 3,返回对象的指针地址 第一:非ARC机制: 1,对象在创建完成的同时,内部会自动创建一个引用计数器,是系统用来判断是否回收对象的唯一标示,当我们的应用计数retainCount = 0的时候,系统会回收当前对象2,[对象 release] retainCount - 1:3,[对象 retain] retailCount + 1:4,当应用计数retailCount = 0的对象就会被销毁; 5,dealloc函数,当一

【点杀ios】内存管理

1.为什要进行内存管理 ios中,每个应用程序所能占有的内存是有限制的.如果你的应用程序所占用的内存超过了这个限制,系统会给你发出内存警告.如果警告后你的程序依然继续占用过多内存,那么系统有可能强制关闭你的应用程序(闪退).并且,如果内存管理没做好,对程序的流畅度也会产生很大的影响.所以,我们在开发应用程序的过程中,要进行内存管理. 2.对什么进行管理: 内存分为堆内存和栈内存.栈内存的分配和释放是系统做的,程序员无法参与.而堆内存,是程序员进行管理的.分配和释放是程序员完成的. 任何继承了NS

ios Instruments 内存泄露

本文转载至 http://my.oschina.net/sunqichao/blog?disp=2&p=3 虽然iOS 5.0版本之后加入了ARC机制,由于相互引用关系比较复杂时,内存泄露还是可能存在.所以了解原理很重要. 这里讲述在没有ARC的情况下,如何使用Instruments来查找程序中的内存泄露,以及NSZombieEnabled设置的使用. 本文假设你已经比较熟悉Obj-C的内存管理机制. 实验的开发环境:XCode 4.5.2 1.运行Demo. 先下载一个实现准备好的内存泄露的D

iOS优化内存方法推荐

1. 用ARC管理内存 ARC(Automatic ReferenceCounting, 自动引用计数)和iOS5一起发布,它避免了最常见的也就是经常是由于我们忘记释放内存所造成的内存泄露.它自动为你管理retain和release的过程,所以你就不必去手动干预了.忘掉代码段结尾的release简直像记得吃饭一样简单.而ARC会自动在底层为你做这些工作.除了帮你避免内存泄露,ARC还可以帮你提高性能,它能保证释放掉不再需要的对象的内存. 2. 在正确的地方使用 reuseIdentifier 一