1、每个函数被调用时都需要开辟空间存储数据，函数调用时开辟的空间称为栈空间。每个函数的栈空间大小，取决于函数中声明变量占用的空间。
2、//冒泡排序法
for (int i =0; i < 5 - 1; i++) {
//i = 0
//i = 1
for (int j =0; j < 5 - 1 - i; j++) {
//j = 0, 1, 2, 3
//j = 0, 1, 2
if (a[j] < a[j + 1]){
int tmp = a[j];
a[j]= a[j + 1];
a[j+ 1] = tmp;
}
}
}
、3、指针就是用来访问当前栈外面的空间的。不能在声明时确定指向的指针，应当初始化为NULL。静态内存分配（编译时决定空间的大小；确定空间大小的是编译器；开辟的空间在栈段、数据段、只读数据段；自动释放）；动态内存分配（程序运行时，确定空间大小；确定空间大小的是程序员；开辟的空间在堆段；通过代码手动释放）
4、
【栈段】函数调用时生成的空间
…
【堆段】
【数据段】全局变量和静态变量
【只读数据段】字符串
【代码段】函数
//函数名是函数入口地址，但不是栈地址，是代码段地址，代码段存函数体。而当cpu执行函数时需要开辟空间执行函数代码里的操作，比如开辟空间存数据（所以函数里的变量是在栈中,当然除了函数里的字符串，因为所有的字符串都单独存在只读数据段），这时开辟的空间就是栈地址，所以栈地址会随着程序执行完而销毁。
5、<string.h>里的一些常用的函数：
1 <string.h>
2 标准库<string.h>
3 1 复制
4
5 char* strcpy (char *s1, const char *s2);
6 将字符串s2复制到s1指定的地址
7
8 char* strncpy (char *s1, const char *s2, size_t len);
9 void* memcpy (void *s1, const void *s2, size_t len);
10 将s2的前len个字符(字节)复制到s1中指定的地址, 不加'/0'
11
12 void* memmove (void *s1, const void *s2, size_t len);
13 当源单元和目的单元缓冲区交迭时使用
14
15 size_t strxfrm (char *s1, const char *s1, size_t len);
16 根据程序当前的区域选项, 将s2的前len个字符(字节)复制到s1中指定的地址, 不加'/0'
17
18 2 连接
19
20 char* strcat (char *s1, const char *s2);
21 将字符串s2连接到s1尾部
22
23 char* strncat (char *s1, const char *s2, size_t len);
24 将字符串s2的前len个字符连接到s1尾部, 不加'/0'
25
26 3 比较
27
28 int strcmp (const char *s1, const char *s2);
29 比较字符串s1和s2
30
31 int strncmp (const char *s1, const char *s2, size_t len);
32 int memcmp (const void *s1, const void *s2, size_t len);
33 对s1和s2的前len个字符(字节)作比较
34
35 int strcoll (const char *s1, const char *s2);
36 根据程序当前的区域选项中的LC_COLLATE, 比较字符串s1和s2
37
38 4 查找
39
40 char* strchr (const char *s, int ch);
41 void* memchr (const void *s, int ch, size_t len);
42 在s中查找给定字符(字节值)ch第一次出现的位置
43
44 char* strrchr (const char *s, int ch);
45 在串s中查找给定字符ch最后一次出现的位置, r表示从串尾开始
46
47 char* strstr (const char *s1, const char *s2);
48 在串s1中查找指定字符串s2第一次出现的位置
49
50 size_t strspn (const char *s1, const char *s2);
51 返回s1中第一个在s2中不存在的字符的索引(find_first_not_of)
52
53 size_t strcspn (const char *s1, const char *s2);
54 返回s1中第一个也在s2中存在的字符的索引(find_first_of)
55
56 char* strpbrk (const char *s1, const char *s2);
57 与strcspn类似, 区别是返回指针而不是索引
58
59 char* strtok (char *s1, const char *s2);
60 从串s1中分离出由串s2中指定的分界符分隔开的记号(token)
61 第一次调用时s1为需分割的字串, 此后每次调用都将s1置为NULL,
62 每次调用strtok返回一个记号, 直到返回NULL为止
63
64 5 其他
65
66 size_t strlen (const char *s);
67 求字符串s的长度
68
69 void* memset (void *s, int val, size_t len);
70 将从s开始的len个字节置为val
71
72 char* strerror (int errno);
返回指向错误信息字符串的指针
73 strstr ( )/* -- C语言库函数源代码 - */
74 /*
75 得到s1中第一次包含s2字符串的位置指针。
76 */
77 #include <stdlib.h>
78 char * my_strstr(const char *s1,const char *s2)
79 {
80 if (*s1 == 0)
81 {
82 if (*s2)
83 return (char *) NULL;
84 return (char *) s1;
85 }
86 while (*s1)
87 {
88 size_t i;
89 i = 0;
90 while (1)
91 {
92 if (s2[i] == 0)
93 {
94 return (char *) s1;
95 }
96 if (s2[i] != s1[i])
97 {
98 break;
99 }
100 i++;
101 }
102 s1++;
103 }
104 return (char *) NULL;
105 }
106 int main()
107 {
108 char *str1 = "ammana_babi";
109 char *str2 = "babi";
110 char *p;
111 if( (p = my_strstr(str1,str2)) == NULL)
112 printf("Can't find the string /"%s/"!/n",str2);
113 else
114 printf("Find the string /"%s/"!/n",p);
115 str1 = "abc";
116 str2 = "def";
117 if( (p = my_strstr(str1,str2)) == NULL)
118 printf("Can't find the string /"%s/"!/n",str2);
119 else
120 printf("Find the string /"%s/"!/n",p);
121 system("pause");
122 return 0;
123 }
124 strpbrk ( )/* -- C语言库函数源代码 - */
125 /*
126 得到s1中第一个且是s2中字符的位置指针。
127 */
128 #include <stdlib.h>
129 char * my_strpbrk(const char *s1 ,const char *s2)
130 {
131 const char *c = s2;
132 if (!*s1)
133 return (char *) NULL;
134 while (*s1)
135 {
136 for (c = s2; *c; c++)
137 {
138 if (*s1 == *c)
139 break;
140 }
141 if (*c)
142 break;
143 s1++;
144 }
145 if (*c == '/0')
146 s1 = NULL;
147 return (char *) s1;
148 }
149 int main()
150 {
151 char *str1 = "ammana_babi";
152 char *str2 = "babi";
153 char *p;
154 if( (p = my_strpbrk(str1,str2)) == NULL)
155 printf("No same character!/n");
156 else
157 printf("%c/n",*p);
158 str1 = "abc";
159 str2 = "def";
160 if( (p = my_strpbrk(str1,str2)) == NULL)
161 printf("No same character!/n");
162 else
163 printf("%c/n",*p);
164 system("pause");
165 return 0;
166 }
167 strcspn ( )/* -- C语言库函数源代码 - */
168 /*
169 得到s1中第一个且是s2中字符的字符位置。
170 */
171 int my_strcspn(const char *s1 ,const char *s2)
172 {
173 const char *s = s1;
174 const char *p;
175 while (*s1)
176 {
177 for (p = s2; *p; p++)
178 {
179 if (*s1 == *p)
180 break;
181 }
182 if (*p)
183 break;
184 s1++;
185 }
186 return s1 - s;
187 }
188 int main()
189 {
190 char *str1 = "ammana_babi";
191 char *str2 = "babi";
192 int offset;
193 if((offset = my_strcspn(str1,str2)) >= strlen(str1))
194 printf("Can't find the same character!/n");
195 else
196 printf("%c/n",*(str1 + offset));
197 str1 = "abc";
198 str2 = "def";
199 if((offset = my_strcspn(str1,str2)) >= strlen(str1))
200 printf("Can't find the same character!/n");
201 else
202 printf("%c/n",*(str1 + offset));
203 system("pause");
204 return 0;
205 }
206 strspn ( )/* -- C语言库函数源代码 - */
207 /*
208 得到s1中第一个且不是s2中任意字符的字符位置。
209 */
210 int my_strspn(const char *s1 ,const char *s2)
211 {
212 const char *s = s1;
213 const char *p;
214 while (*s1)
215 {
216 for (p = s2; *p; p++)
217 {
218 if (*s1 == *p)
219 break;
220 }
221 if (*p == '/0')
222 break;
223 s1++;
224 }
225 return s1 - s;
226 }
227 int main()
228 {
229 char *str1 = "ammana_babi";
230 char *str2 = "babi";
231 int offset;
232 if((offset = my_strspn(str1,str2)) >= strlen(str1))
233 printf("Can't find the different character!/n");
234 else
235 printf("%c/n",*(str1 + offset));
236 str1 = "abc";
237 str2 = "abc";
238 if((offset = my_strspn(str1,str2)) >= strlen(str1))
239 printf("Can't find the different character!/n");
240 else
241 printf("%c/n",*(str1 + offset));
242 system("pause");
243 return 0;
244 }
245 strrev ( )/* -- C语言库函数源代码 - */
246 /*
247 Reverses the order of characters in the string.
248 The terminating null character remains in place.
249 把字符串的所有字符的顺序颠倒过来（不包括空字符NULL）。
250 返回指向颠倒顺序后的字符串指针。
251 */
252 char * my_strrev(char *str)
253 {
254 char *right = str;
255 char *left = str;
256 char ch;
257 while (*right) right++;
258 right--;
259 while (left < right)
260 {
261 ch = *left;
262 *left++ = *right;
263 *right-- = ch;
264 }
265 return(str);
266 }
267 /*
268 而我自己写的代码就略微显的有些啰里啰嗦，不简洁，
269 更不是很太爽快。这个问题是值得好好想一下的了。
270 下面就是我的垃圾代码
271 */
272 char * my_StrReverse(char * ch)
273 {
274 char tempch,* tch;
275 int Len,i;
276 tch = ch;
277 Len = strlen(ch);
278 for(i=0;i<Len/2;i++)
279 {
280 tempch = *tch;
281 *tch = *(tch + Len - 2*i - 1);
282 *(tch+Len-2*i-1) = tempch;
283 tch++;
284 }
285 return ch;
286 }
287 int main()
288 {
289 char str[] ="ammana_babi";
290 puts(my_strrev(str));
291 puts(my_StrReverse(str));
292 system("pause");
293 return 0;
294 }
295 strnset ( )/* -- C语言库函数源代码 - */
296 /*
297 Sets the first count characters of string the character value.If the length of string is less than count, the length of string is used in place of n.
298 把字符串的前count个字符设置为字符val。
299 */
300 char * my_strnset(char * str,int val,int count)
301 {
302 char *p = str;
303 while (count-- && *p)
304 *p++ = (char)val;
305 return(p);
306 }
307 int main()
308 {
309 char str[] ="ammana_babi";
310 my_strnset(str,'*',strlen(str)-4);
311 puts(str);
312 system("pause");
313 return 0;
314 }
315 strset ( )/* -- C语言库函数源代码 - */
316 /*
317 Sets all of characters in string (except the terminating '/0'character) equal to val.
318 把字符串的所有字符都设置为字符val。
319 */
320 char * my_strset(char *str,int val)
321 {
322 char *p = str;
323 while (*str)
324 *str++ = (char)val;
325 return(p);
326 }
327 int main()
328 {
329 char str[] ="ammana_babi";
330 my_strset(str,'z');
331 puts(str);
332 system("pause");
333 return 0;
334 }
335 strupr ( )/* -- C语言库函数源代码 - */
336 /*
337 Force string to lower case。
338 将字符串转换为大写。只改变字符串中出现的小写字母，不改变其他字符。
339 */
340 char * my_strupr(char *str)
341 {
342 char *p = str;
343 while (*p != '/0')
344 {
345 if(*p >= 'a' && *p <= 'z')
346 *p -= 0x20;
347 p++;
348 }
349 return str;
350 }
351 int main()
352 {
353 int i;
354 char str1[]= "Ammana";
355 char str2[] = "baBi";
356 char str3[] = "AMMANA";
357 char str4[] = "aMmAn_BabI";
358 puts(my_strupr(str1));
359 puts(my_strupr(str2));
360 puts(my_strupr(str3));
361 puts(my_strupr(str4));
362 system("pause");
363 return 0;
364 }
365 strlwr ( )/* -- C语言库函数源代码 - */
366 /*
367 Force string to lower case。
368 将字符串转换为小写。只改变字符串中出现的大写字母，不改变其他字符。
369 */
370 char * my_strlwr(char *str)
371 {
372 char *p = str;
373 while (*p != '/0')
374 {
375 if(*p >= 'A' && *p <= 'Z')
376 *p = (*p) + 0x20;
377 p++;
378 }
379 return str;
380 }
381 int main()
382 {
383 int i;
384 char str1[]= "Ammana";
385 char str2[] = "baBi";
386 char str3[] = "AMMANA";
387 char str4[] = "aMmAn_BabI";
388 puts(my_strlwr(str1));
389 puts(my_strlwr(str2));
390 puts(my_strlwr(str3));
391 puts(my_strlwr(str4));
392 system("pause");
393 return 0;
394 }
395 strdup ( )/* -- C语言库函数源代码 - */
396 /*
397 Allocates enough storage via malloc() for a copy of the string, copies the string into the new memory, and returns a pointer to it.
398 复制字符串，返回指向被复制字符串的指针。所需空间由malloc()分配，且可以由free()释放。需要注意的是，在调用完这个函数后，一定要记得释放内存空间吆。
399 */
400 #include <stdlib.h>
401 int my_strlen ( const char * str )
402 {
403 const char *p = str;
404 while( *p++ ) ;
405 return( (int)(p - str - 1) );
406 }
407 char * my_strcpy(char * dst, const char * src)
408 {
409 char * cp = dst;
410 while( *cp++ = *src++ ) ;
411 return( dst );
412 }
413 char * my_strdup(const char *str)
414 {
415 char *p;
416 if (!str)
417 return(NULL);
418 if (p = malloc(my_strlen(str) + 1))
419 return(my_strcpy(p,str));
420 return(NULL);
421 }
422 int main()
423 {
424 char *str = "ammana_babi";
425 char *p;
426 p = my_strdup("ammana_babi");
427 puts(p);
428 free(p);
429 system("pause");
430 return 0;
431 }
432 strrchr ( )/* -- C语言库函数源代码 - */
433 /*
434 Finds the last occurrence of ch in string. The terminating null character is used as part of the search.
435 查找在字符串中最后一次出现字符’ch’的位置。如果str中存在字符ch，返回出现ch的位置的指针；否则返回NULL。
436 */
437 #include <stdlib.h>
438 char * my_strrchr(const char * str,int ch)
439 {
440 char *p = (char *)str;
441 while (*str) str++;
442 while (str-- != p && *str != (char)ch);
443 if (*str == (char)ch)
444 return( (char *)str );
445 return(NULL);
446 }
447 int main()
448 {
449 char *str = "ammana_babi";
450 char * p;
451 char ch;
452
453 ch = '9';
454 p = (char *)my_strrchr(str,ch);
455 if(p == NULL)
456 printf("Can't find the character %c !/n",ch);
457 else
458 printf("Find the character %c !/n",*p);
459
460 ch = 'b';
461 p = (char *)my_strrchr(str,ch);
462 if(p == NULL)
463 printf("Can't find the character %c !/n",ch);
464 else
465 printf("Find the character %c !/n",*p);
466 system("pause");
467 return 0;
468 }
469 strchr ( )/* -- C语言库函数源代码 - */
470 #include <stdlib.h>
471 /*
472 Searches a string for a given character, which may be the null character '/0'.
473 查找字符串string中首次出现字符ch的位置。如果string中存在字符ch，返回首次出现ch的位置的指针；否则返回NULL。
474 */
475 char * my_strchr(const char *str, int ch)
476 {
477 while (*str && *str != (char)ch)
478 str++;
479 if (*str == (char)ch)
480 return((char *)str);
481 return(NULL);
482 }
483 int main()
484 {
485 char *str = "ammana_babi";
486 char * p;
487 char ch;
488
489 ch = '9';
490 p = (char *)my_strchr(str,ch);
491 if(p == NULL)
492 printf("Can't find the character %c !/n",ch);
493 else
494 printf("Find the character %c !/n",*p);
495
496 ch = 'b';
497 p = (char *)my_strchr(str,ch);
498 if(p == NULL)
499 printf("Can't find the character %c !/n",ch);
500 else
501 printf("Find the character %c !/n",*p);
502 system("pause");
503 return 0;
504 }
505 memset ( )/* -- C语言库函数源代码 - */
506 /*
507 Sets the first "count" bytes of the memory starting at "dst" to the character value "val".
508 把dst所指内存区域的前count个字节设置为val。返回指向dst的指针。
509 在实际应用中，我们有时候会用malloc函数来申请一些内存空间，这个内存空间有时候需要初始化，常用memset来进行初始化。
510 如：
511 int *p;
512 p = (int *)malloc( 0x400 * sizeof(int));
513 memset(p,0,0x400);
514 */
515 void * my_memset(void *dst,int val,int count)
516 {
517 void *p = dst;
518 while (count--)
519 {
520 *(char *)dst = (char)val;
521 dst = (char *)dst + 1;
522 }
523 return p;
524 }
525 int main()
526 {
527 char str[] ="ammana_babi";
528 my_memset(str,'z',strlen(str));
529 puts(str);
530 system("pause");
531 return 0;
532 }
533 memicmp ( )/* -- C语言库函数源代码 - */
534 /*
535 memicmp perform a case-insensitive memory comparision.
536 For differences,upper case letters are mapped to lower case.Thus, "abc_" < "ABCD" since "_" < "d".
537 (与memcmp区别就是在比较的时候不区分大小写)比较内存区域buffer1和buffer2的前count个字节。当buffer1 < buffer2时，返回值 < 0；当buffer1 = buffer2时，返回值 0；当buffer1 > buffer2时，返回值 > 0。
538 */
539 int my_tolower(char ch)
540 {
541 if(ch >= 'A' && ch <= 'Z')
542 return (ch + 0x20);
543 return ch;
544 }
545 int my_memicmp(const void *buffer1,const void *buffer2,int count)
546 {
547 int f = 0;
548 int l = 0;
549 while (count--)
550 {
551 if ( (*(unsigned char *)buffer1 == *(unsigned char *)buffer2) ||
552 ((f = my_tolower( *(unsigned char *)buffer1 )) ==
553 (l = my_tolower( *(unsigned char *)buffer2 ))) )
554 {
555 buffer1 = (char *)buffer1 + 1;
556 buffer2 = (char *)buffer2 + 1;
557 }
558 else
559 break;
560 }
561 return ( f - l );
562 }
563 void Print(char * str1,char *str2,int t)
564 {
565 if(t > 0)
566 printf("/n%s Upper Than %s/n",str1,str2);
567 else if(t < 0)
568 printf("/n%s Lower Than %s/n",str1,str2);
569 else
570 printf("/n%s Equal %s/n",str1,str2);
571
572 }
573 int main()
574 {
575 char *str1= "ammana";
576 char *str2 = "babi";
577 char *str3 = "AMMANA";
578 char *str4 = "bab_";
579 Print(str1,str2,my_memicmp(str1,str2,4));
580 Print(str3,str1,my_memicmp(str3,str1,4));
581 Print(str4,str2,my_memicmp(str4,str2,4));
582
583 system("pause");
584 return 0;
}
扫一扫
78
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
