目录

需要用到的函数

利用malloc函数和free函数来实现动态内存的申请和释放;

利用realloc函数来修改上述malloc函数申请的动态内存的大小;

用链表结构,malloc函数和free函数实现将终端输入的一系列字符串用链表的形式保存下来。然后再将这些数据组装起来,回显到输出终端。

注:本文中的例子可以直接编译运行。

需要用到的函数

分配动态内存空间所使用的函数调用如下:

1
2
3
#include<stdio.h>
void *malloc(size_t size);
void *calloc(size_t nmemb, size_t size);

函数malloccalloc都是用于分配动态内存空间的函数。
函数malloc的参数size表示申请分配的内存空间的大小,以字节计。
函数calloc的参数nmemb表示申请分配的内存空间占的数据项数目,参数size表示一个数据项的大小,以字节计。也就是说,calloc函数分配大小为nmemb*size大小的内存空间。
函数calloc与函数malloc的最大区别就是函数calloc将初始化所分配的内存空间,把所有位置0。调用成功时,函数calloc与函数malloc的返回值都为被分配的内存空间的指针;调用失败时,返回值为NULL

释放动态内存空间所使用的函数调用如下:

1
2
#include<stdio.h>
void free(void *ptr);

此函数的作用是释放由函数calloc或函数malloc分配的动态内存。参数ptr是指向要释放的动态内存的指针。

注意:当动态内存被释放后,原来指向它的指针就会变为悬空指针。此时使用该指针将会产生错误。

对于用函数calloc与函数malloc分配好的动态内存,可以使用realloc函数来调整它的大小。该函数的说明如下:

1
2
#include<stdio.h>
void*realloc(void *ptr, size_t size);

realloc函数的作用是重新调整一块动态内存区域的大小。

参数ptr是指向要调整的动态内存的指针,应是函数calloc与函数malloc的返回值。
参数size是新定义的动态内存的大小。Size可以大于或小于动态内存的原大小,调用realloc函数时,通常是在原来的内存空间调整动态内存的大小,原有数据不被改动。当size大于原大小,而原位置中无法完成调整时,将重新开辟内存空间并将原数据拷贝到新的内存空间中。

注意:如果参数ptrNULL,则函数realloc的作用相当于函数malloc。如果参数size0,则函数realloc的作用相当于函数free

利用malloc函数和free函数来实现动态内存的申请和释放;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

char *upcase(char *inputstring);

int main(void) {
char *string;

string=upcase("Hello" );

printf("string=%s\n", string);

free(string);

return 0;
}


char* upcase(char *inputstring) {
char *newstring;
int counter;

if(!(newstring=malloc(strlen(inputstring)+1))){
printf("ERROR ALLOCATING MEMORY! \n");
exit(255);
}
strcpy(newstring, inputstring);
for(counter=0; counter<strlen(newstring); counter++){
if(newstring[counter]>=97&&newstring[counter]<=122)
newstring[counter]-=32;
}
return newstring;
}

利用realloc函数来修改上述malloc函数申请的动态内存的大小;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

char* upcase(char *inputstring, char *newstring);

int main(void) {

char *string;

string = upcase("Hello",string);

printf("string=%s\n", string);

free(string);

return 0;
}


char* upcase(char *inputstring, char *newstring) {

int counter;

if(!newstring) {
if(!(newstring=realloc(NULL, strlen(inputstring)+1))) {
printf("ERROR ALLOCATING MEMORY! \n");
exit(255);
}
} else {
if(!(newstring=realloc(newstring, sizeof(inputstring)+1))) {
printf("ERROR REALLOCATING MEMORY! \n");
exit(255);
}
}

strcpy(newstring, inputstring);

for(counter=0; counter<strlen(newstring); counter++) {
if(newstring[counter]>=97&&newstring[counter]<=122)
newstring[counter]-=32;
}

return newstring;
}

用链表结构,malloc函数和free函数实现将终端输入的一系列字符串用链表的形式保存下来。然后再将这些数据组装起来,回显到输出终端。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define DATASIZE 10

typedef struct stringdata {
char *string;
int iscontinuing;
struct stringdata *next;
} mydata;

mydata *append(mydata *start, char *input);
void displaydata(mydata *start);
void freedata(mydata *start);

int main(void) {
char input[DATASIZE];
mydata *start=NULL;

printf("ENTER SOME DATA,AND PRESS Ctrl+D WHEN DONE. \n");

while(fgets(input, sizeof(input), stdin)) {
start=append(start, input);
}

displaydata(start);
freedata(start);
return 0;
}

mydata *append(mydata *start, char *input) {
mydata *cur=start, *prev=NULL, *new;

while(cur) {
prev=cur;
cur=cur->next;
}
cur=prev;

new=malloc(sizeof(mydata));
if(!new) {
printf("COULDN’T ALLOCATE MEMORY! \n");
exit(255);
}

if(cur)
cur->next=new;
else
start=new;

cur=new;

if(!(cur->string=malloc(sizeof(input)+1))) {
printf("ERROR ALLOCATING MEMORY! \n");
exit(255);
}
strcpy(cur->string, input);
cur->iscontinuing=!(input[strlen(input)-1]=='\n'||input[strlen(input)-1]=='\r');
cur->next=NULL;

return start;
}


void displaydata(mydata *start) {
mydata *cur;
int linecounter=0, structcounter=0;
int newline=1;

cur=start;
while(cur) {
if(newline)
printf("LINE %d:",++linecounter);
structcounter++;
printf("%s",cur->string);
newline=!cur->iscontinuing;
cur=cur->next;
}
printf("THIS DATA CONTAINED %d LINES AND WAS STORED IN %d STRUCTS. \n",
linecounter,structcounter);
}


void freedata(mydata *start) {
mydata *cur, *next=NULL;

cur=start;
while(cur) {
next=cur->next;
free(cur->string);
free(cur);
cur=next;
}
}
最后修改日期:2020年5月14日

留言

撰写回覆或留言