Objective-C学习准备__C语言7

C语言的准备到这里就差不多了最后来学习一下动态数组

我们知道C语言的数组在定义的时候都必须指定长度，那么如何定义动态的数组呢

事实上动态数组就是在堆中划出来一片空间供你使用 而这片空间只能用指针访问，我们来看代码

#include <stdio.h>
#include <stdlib.h>
int main(){
   int* arr1 = malloc(3*sizeof(int));
   int* arr2 = calloc(3 , sizeof(int));
   arr1[0]=2;
   arr1[2]=4;
   printf("%d\n",arr1[0]);
   printf("%d\n",arr1[1]);
   printf("%d\n",arr1[2]);
   arr2[0]=20;
   arr2[2]=40;
   printf("%d\n",arr2[0]);
   printf("%d\n",arr2[1]);
   printf("%d\n",arr2[2]);
   realloc(arr1,5*sizeof(int));
   arr1[3]=23;
   printf("%d\n",arr1[3]);                  　 free(arr1);　 free(arr2);
}    

可以看到malloc和calloc都能创建动态空间数组只是一个函数是两个参数一个函数是一个参数，为什么呢？

多运行几次，仔细观察arr1[1]与arr2[1]的输出结果   这两个空间均没有赋值 arr1[1]中还保留有原来内存中的数据，但arr2[1]却是0；

得出结论calloc创建的动态空间会进行数据清零，而malloc创建则不会，因为前者有两个参数可以知道多少个字节做一次清零处理；

realloc则能修改原动态数组的长度；

最后还有一个free()函数，用于释放动态空间，每个空间用完之后都要进行释放不然一直占用空间，久而久之越来越多的占用就会造成内存泄露，电脑越来越卡

既然已经知道动态数组的创建了那么不妨思考一下能否做出java或C#中类似于List单链表的集合呢？

单链表，用结构体表示是这样

typedef struct List{
    int value;
    struct List *next;
}ArrayList;

创建一个node类型指针  创建动态数组空间

node_t *head= malloc(sizeof(ArrayList));
head->value = 1;
head->next = NULL;

如何增加单链表呢？

head->next = malloc(sizeof(ArrayList));
head->next->value = 2;
head->next ->next = NULL;
head->next->next = malloc(sizeof(ArrayList));
head->next->next->value = 3;
head->next->next->next = NULL;
printf("%d\n",head->value);
printf("%d\n",head->next->value);
printf("%d\n",head->nex->nextt->value);

这样是不是很麻烦？  我们可以用一个方法来实现

void Listadd(ArrayList** head,int val){
    if((*head)==NULL){
        (*head)=malloc(sizeof(ArrayList));
        (*head)->value=val;
        (*head)->next=NULL;
        return;
    }
    ArrayList* he=*head;
    while(he->next!=NULL){
        he=he->next;
    }
    he->next=malloc(sizeof(ArrayList));
    he=he->next;
    he->value=val;
    he->next=NULL;
}

有了这个方法就可以直接调用add增加数据集了

这里提一下  -> 是指针访问结构体的符号  结构体变量名访问是打点访问

int main(){
 ArrayList* p=NULL;
 Listadd(&p,2);
 Listadd(&p,1);
 Listadd(&p,5);
}

既然有添加那么肯定有删除，删除就是用free()方法释放空间具体做法我就不多说了 大家好好思考一下..下面是我写的一个例子

ArrayList.c

#include <stdlib.h>
#include <stdio.h>
#include "ArrayList.h"
void Listadd(ArrayList** head,int val){
    if((*head)==NULL){
        (*head)=malloc(sizeof(ArrayList));
        (*head)->value=val;
        (*head)->next=NULL;
        return;
    }
    ArrayList* he=*head;
    while(he->next!=NULL){
        he=he->next;
    }
    he->next=malloc(sizeof(ArrayList));
    he=he->next;
    he->value=val;
    he->next=NULL;
}
void ListaddFrist(ArrayList** head,int val){
    if((*head)->value==0){
        (*head)->value=val;
        return;
    }
    ArrayList* p=malloc(sizeof(ArrayList));
    p->value=val;
    p->next=*head;
    *head=p;
}
void ListaddLast(ArrayList** head,int val){
    Listadd(head,val);
}
void ListRemoveFrist(ArrayList** head){
    ArrayList*p=(*head)->next;
    free(*head);
    *head=p;
}
void ListRemoveLast(ArrayList** head){
    if((*head)==NULL){
        printf("没有可释放的动态数组空间\n");
        return;
    }
    if((*head)->next==NULL){
        free(*head);
        printf("该动态数组空间已全部释放\n");
        return;
    }
    ArrayList* he=*head;
    while(he->next->next!=NULL)
        he=he->next;
    free(he->next);
    he->next=NULL;
}
void ListRemoveby(ArrayList** head,int i){
    ArrayList*p;
    if(i==0){
        ListRemoveFrist(head);
        return;
    }
    if(i==1){
        p=(*head)->next->next;
        free((*head)->next);
        (*head)->next=p;
        return;
    }
    ArrayList* he=*head;
    while(i!=1){
        he=he->next;
        i--;
    }
    p=he->next->next;
    free(he->next);
    he->next=p;
}
void print(ArrayList* head){
    while(head!=NULL){
        printf("%d\t",(*head).value);
        head=(*head).next;
    }
}
ArrayList*Listequals(ArrayList** head,int i){
    ArrayList* he=*head;
    while(i!=0){
        he=he->next;
        i--;
    }
    return he;
}

ArrayList.h

#ifndef _ArrayList_H_
#define _ArrayList_H_
typedef struct arr{
    int value;
    struct arr* next;
} ArrayList;
ArrayList* NewArrayList();
void Listadd(ArrayList**,int);
void print(ArrayList*);
void ListaddFrist(ArrayList**,int);
void ListaddLast(ArrayList**,int);
void ListRemoveFrist(ArrayList** head);
void ListRemoveLast(ArrayList** head);
ArrayList*Listequals(ArrayList**,int);
void ListRemoveby(ArrayList**,int);
#endif

test.c

#include <stdio.h>
#include <stdlib.h>
#include "ArrayList.h"
int main(){
    ArrayList* p=NULL;
    Listadd(&p,2);
    Listadd(&p,3);
    Listadd(&p,4);
    Listadd(&p,5);
    ListaddLast(&p,6);
    print(p);
    printf("\n-----------\n");
    ListaddFrist(&p,1);
    ListaddFrist(&p,0);
    print(p);
    printf("\n-----------\n");
    ListRemoveFrist(&p);
    print(p);
    printf("\n-----------\n");
    ListRemoveLast(&p);
    print(p);
    printf("\n-----------\n");
    ArrayList*test=Listequals(&p,2);
    printf("indexOf(2)=%d\n",test->value);
    printf("\n-----------\n");
    printf("remove indexOf(2)\n");
    ListRemoveby(&p,2);
    print(p);
    printf("\n-----------\n");
}

以上综合了我们复习过的知识..C就讲到这里了...如果有疑问的可以留言