蓝欧--lessonc11[动态内存分配]

#import <Foundation/Foundation.h>
#import "header.h"

typedef struct student{
    char name[20];
    char sex;
    int  age;
    float score;
    
}STUDENT;

int maxValue(int a, int b);
int square(int n);

char * getString();

int maxValue(int a, int b){
    int max = square(a) > square(b) ? square(a) : square(b);
    return max;
    
}

int square(int n){
    int number = n * n;
    return number;
}

char * getString(){
    char * str = malloc(10);
    strcpy(str, "iphone");
    return str;
}



int main(int argc, const char * argv[]) {
    //动态分配内存
//    int x = 10, y = 15;
//    int a = maxValue(x, y);
//    printf("max = %d",a);
    
//    char * pStr = getString();
//    printf("str = %s",pStr);

//栈内存的作用和管理特点:
//栈内存是发生函数调用时给函数里面的局部变量和形参分配内存,栈内存由操作系统负责分配,当函数调用完毕,给这个函数分配的内存的所有栈内存就会被操作系统回收.
    
    
    //static 修饰的变量只会被初始化一次
    //static 修饰的变量会被储存在静态区,到程序运行结束再释放
//    for (int i = 0;i < 10; i++){
//        static int a = 0;
//        int * p = &a;
//        printf("%p\n",p);
//        a++;
//        printf("a = %d\n",a);
//    }
    
    //void * 泛型指针,可以通配任何类型的指针
//    int a = 5;
//    void * p = &a;
//    printf("a = %d",*((int *)p));//强制类型转换
    
    //栈区的离歌指针变量存储一块堆(dui)区内存的首地址
//    char * p = malloc('a');
//    *p = 'r';
//    printf("%c",*p);
//    //释放内存
//    free(p);//只是删除标记,(标记删除)
 
    /*
//    char str[10] = "iphne";
    //用完堆内存之后要记得释放,否则导致内存泄漏
    char * p = malloc(10);
    char * m = p;//防止首地址丢失,导致内存泄漏
    strcpy(p, "iphone");//拷贝到堆区
    p = "Android";
    printf("%s", p);
    free(m);//必须要传这段堆内存的首地址
    //free(p);//过度释放,只需释放一次
//    p = NULL;//释放完之后,指针置空,防止野指针异常
//    printf("%s", p);//野指针异常
    */
    
//向操作系统申请一段能够存储n个整型数堆内存空间,当成一个整型一维数组来使用
//    int * pArray = malloc(sizeof(int) * 10);
//    for (int i = 0 ; i < 10; i++) {
//        *(pArray + i) = arc4random() % 101;
//        printf("%d\t",*(pArray + i));
//    }
//    free(pArray);
//    pArray = NULL;
    
   //在堆取申请一块内存,当成一个二维数组来使用
//  int (*p)[3] = malloc(sizeof(int) * 2 * 3);
//    for (int i = 0; i < 2; i++) {
//        for (int j = 0; j < 3; j++) {
//            *(*(p + i) + j) = arc4random() % 51;
//            printf("%d\t",*(*(p + i) + j));
//        }
//        printf("\n");
//    }
//    free(*p);
//    p = NULL;
    
    
//    STUDENT stu = {"zhangyishan",'M',24,86.55};
//    STUDENT * stu = malloc(sizeof(STUDENT));
//    strcpy(stu->name, "zhangyishan");
//    (*stu).sex = 'M';
//    stu->age = 24;
//    (*stu).score = 86.9;
//    printf("%s %c %d %.2f",stu->name, stu->sex,stu->age,stu->score);
//    free(stu);
//    stu = NULL;
    
    //    有一字符串,其中包含数字,提取其中的数字.要求动态分配内存保存
//    char temp[100] = {0};
//    printf("请输入一个字符串:");
//    scanf("%s", temp);
//    
//    int i = 0;
//    int count = 0;
//    while (*(temp + i) != '\0') {
//        if (*(temp + i) >= '0' && *(temp + i) <= '9'){
//            count++;//当记录输入数字的个数
//        }
//    i++;
//    }
//    char *pNumber = malloc(count + 1);//定义新的内存空间
//    i = 0;
//    int j = 0;
//    while (*(temp + i) != '\0') {
//    if (*(temp + i) >= '0' && *(temp + i) <= '9'){
//        *(pNumber + j) = *(temp + i);//给新的内存空间赋值
//            j++;
//            }
//            i++;
//        }
//    *(pNumber + j) = '\0';//最后一位赋值\0
//    printf("%s", pNumber);
//    free(pNumber);//释放内存
//    pNumber = NULL;//指针置空
    
    //输入3个单词的姓名,动态分配内存保存单词,并在最后输出
//    char * words[3] = {0};
//    printf("输入:");
//    for (int i = 0; i < 3; i++) {
//        char temp[100] = {0};
//        scanf("%s",temp);
//        unsigned long lenth =sizeof(temp);
//        char * word = malloc(lenth + 1);
//        strcpy(word, temp);
//        words[i] = word;
//    }
//    for (int i = 0; i < 3; i++) {
//        printf("%s\t",words[i]);
//        free(words[i]);
//        words[i] = NULL;
//    }
    
    //calloc
    //分配N个size字节的连续的存储空间
    //和malloc的区别是 calloc一定会把分配的这块内存清零0
//    int * p = calloc(50, sizeof(int));
//    for (int i = 0 ; i < 50; i++) {
//        *(p + i) = arc4random() % 101;
//        printf("%d\t",*(p+i));
//    }
    
    //realloc 内存重新分配函数
    //如果从给定的函数地址开始检查,如果下面的够分配,则直接追加
    //如果不够分配,则会重新找一段连续的存储空间,并发原内存中的数据拷贝过来之后释放
//    char * p = malloc(7);
//    strcpy(p, "iphone");
//    printf("%p\n",p);
//    char * p1 = realloc(p, 17);//自动释放p
//    printf("%p\n",p1);
//    strcpy(p1 + 6, "Android");
//    printf("%s",p1);
//    free(p1);//只需释放p1就ok
//    p1 = NULL;
    
//    //memcpy
//    int a[3] = {1,2,3};
//    int b[4] = {4,5,6,7};
//    int *p = malloc(sizeof(a) + sizeof(b));
//    //内存拷贝函数,从a的地址开始,拷贝到p地址的地方,拷贝n个字节
//    memcpy(p, a, sizeof(a));
//    memcpy(p + sizeof(a)/sizeof(int), b, sizeof(b));
//    for (int i = 0; i < (sizeof(a) + sizeof(b)) / sizeof(int); i++) {
//        printf("%d\t",*(p + i));
//    }
    
    //memset 内存重置函数,从给定的地址开始,重置为N,重置多少个字节
    //通常用于清除内存中的数据
    //memcpy(<#void *#>, <#const void *#>, <#size_t#>)
//    memset(p, 0 ,sizeof(a)+sizeof(b));
//    for (int i = 0; i < sizeof(a) + sizeof(b); i++) {
//        printf("%d\t",*((char *)p + i));
//    }
    
    //memcmp内存比较函数
    //从给定的两个地址开始比较,比较N个字节,比每个存储单元里面的内容,如果不相等,返回差值.
    char str[5] = "asdf";
    char str1[5] = "asdc";
    int result = memcmp(str, str1, 4);
    printf("%d",result);
    
    return 0;
}