C／C++语言复习(一)

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;  

}