蓝欧--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;
}

时间: 2024-10-29 19:11:07

蓝欧--lessonc11[动态内存分配]的相关文章

C++动态内存分配

笔者介绍:姜雪伟,IT公司技术合伙人,IT高级讲师,CSDN社区专家,特邀编辑,畅销书作者,已出版书籍:<手把手教你架构3D游戏引擎>电子工业出版社和<Unity3D实战核心技术详解>电子工业出版社等. CSDN视频网址:http://edu.csdn.net/lecturer/144 C / C ++中的动态内存分配是指程序员手动执行内存分配, 动态分配的内存分配给堆,非静态和局部变量获取在Stack上分配的内存.详情查看上篇博文:C程序的内存布局. 什么是应用程序? 动态分配的

【C语言天天练(九)】动态内存分配

引言:数组的元素存储于内存中连续的位置上.当一个数组被声明时.它所须要的内存在编译时就被分配. 可是,我们能够使用动态内存分配在执行时为它分配内存. 一块内存的生命周期能够分为四个阶段:分配.初始化.使用.释放. 内存的分配一般使用C函数库里的malloc函数(原型:void *malloc(size_t size)). 关于malloc函数应该注意一下几点: 1.malloc的參数就是须要分配的内存的字节数. 2.malloc所分配的是一块连续的内存. 3.分配成功.则返回指向分配内存起始地址

SQLite剖析之动态内存分配

SQLite通过动态内存分配来获取各种对象(例如数据库连接和SQL预处理语句)所需内存.建立数据库文件的内存Cache.以及保存查询结果.我们做了很多努力来让SQLite的动态内存分配子系统可靠.可预测.健壮并且高效.本文概述SQLite的动态内存分配,软件开发人员在使用SQLite时可以据此获得最佳性能. 1.特性    SQLite内核和它的内存分配子系统提供以下特性:    (1)对内存分配失败的健壮处理.如果一个内存分配请求失败(即malloc()或realloc()返回NULL),SQ

继承和动态内存分配

假设基类使用了动态内存分配,而且定义了析构函数.复制构造函数和赋值函数,但是在派生类中没有使用动态内存分配,那么在派生类中不需要显示定义析构函数.复制构造函数和赋值函数. 当基类和派生类采用动态内存分配时,派生类的析构函数.复制构造函数.赋值运算符都必须使用相应的基类方法来处理基类元素.这种要求是通过三种不同的方式来满足的.对于析构函数.这是自动完成的,也就是说在派生类的析构函数中无需显示调用基类的析构函数.对于构造函数,这是通过在初始化成员类别中调用基类的复制构造函数来完成的,如果不这样做,将

【Cpp】考点·堆栈&amp;动态内存分配

动态内存分配 堆内存分配与释放 C/C++定义了四个内存区间:代码区,全局变量与静态变量区,局部变量区(栈区),动态内存区(堆区) 通常定义变量(或对象),编译器在编译时都可以根据该变量(或对象)的类型知道所需内存空间的大小,从而系统在适当的时候为他们分配确定的存储空间.这种内存分配称为静态存储分配.有些操作对象只在程序运行时才确定,这样编译时无法为他们预定存储空间,只能在程序运行时,系统根据运行时的要求进行内存分配,这种方法称为动态存储分配.所有动态存储分配都在堆区中进行. 当程序运行到需要一

C++ 动态内存分配(6种情况,好几个例子)

1.堆内存分配 : C/C++定义了4个内存区间: 代码区,全局变量与静态变量区,局部变量区即栈区,动态存储区,即堆(heap)区或自由存储区(free store). 堆的概念: 通常定义变量(或对象),编译器在编译时都可以根据该变量(或对象)的类型知道所需内存空间的大小,从而系统在适当的时候为他们分配确定的存储空间.这种内存分配称为静态存储分配: 有些操作对象只在程序运行时才能确定,这样编译时就无法为他们预定存储空间,只能在程序运行时,系统根据运行时的要求进行内存分配,这种方法称为动态存储分

28._动态内存分配

动态内存分配 传统数组的缺点(静态内存分配):   1.数组长度必须事先指定,且只能是常整数,不能是变量    例子:     int a[5]; //OK     int len = 5; int a[len]; //error   2.传统形式定义的数组,该数组的内存程序员无法手动编    程释放,在一个函数运行期间,系统为该函数中数组所     分配的空间会一直存在,直到该函数运行完毕时,数组    元素所占存储空间才会被系统释放 3.数组的长度一旦定义,长度就能被改变     4.A函数

一维和二维数组 动态内存分配

一维数组的动态内存分配 #include "stdafx.h" #include <iostream> using namespace std; int main() { int length,i; int *p; cin>>length; p=new int[length]; for(i=0;i<length;i++) { p[i]=i; //不要写成*p[i]=i; cout<<p[i]<<endl; //不要写成cout<

Lesson(DynamicMerry)动态内存分配

//  main.m //  1-27随堂笔记 //讲师: 小辉 //笔者: 王学文 //  Created by lanouhn on 15/1/27. //  Copyright (c) 2015年 lanouhn. All rights reserved. //动态内存分配(DynamicMerry) #import <Foundation/Foundation.h> void test() { int x = 10; int y = 20; } //函数返回栈区的数据,是不安全的;一i