标签：ZZ int 汇总 C++ next char str NULL 函数
1 指针和引用的区别
2 指针指向一块内存，它的内容是指向内存的地址；引用是某内存的别名
3
4 引用使用是无需解引用，指针需解引用
5
6 引用不能为空，指针可以为空
7
8 引用在定义是被初始化一次，之后不可变；指针可变
9
10 程序为指针变量分配内存区域，而引用不需要分配内存区域
11
12 memcpy和strcpy的区别
13 memcpy用来内存拷贝的，它有指定的拷贝数据长度，他可以拷贝任何数据类型的对象
14
15 Strcpy它只能去拷贝字符串，它遇到’\0′结束拷贝
16
17 new和malloc的区别，free和delete的区别
18 malloc与free是C++/C语言的标准库函数，new/delete是C++的运算符。它们都可用于申请动态内存和释放内存。
19
20 对于非内部数据类型的对象而言，光用maloc/free无法满足动态对象的要求。对象在创建的同时要自动执行构造函数，对象在消亡之前要自动执行析构函数。由于malloc/free是库函数而不是运算符，不在编译器控制权限之内，不能够把执行构造函数和析构函数的任务强加于malloc/free。
21
22 因此C++语言需要一个能完成动态内存分配和初始化工作的运算符new，以及一个能完成清理与释放内存工作的运算符delete。注意new/delete不是库函数。
23
24 struct和class的区别
25 1.成员变量
26
27 结构在默认情况下的成员是公共(public)的,
28
29 而类在默认情况下的成员是私有(private)的。
30
31 2.存储
32
33 struct保证成员按照声明顺序在内存中存储。class不保证等等
34
35 3.继承
36
37 struct A { }；
38
39 class B : A{ }; //private继承
40
41 struct C : B{ }； //public继承
42
43 这是由于class默认是private，struct默认是public。
44
45 struct与union的区别.(一般假定在32位机器上)
46 1．一个union类型的变量，所有成员变量共享一块内存，该内存的大小有这些成员变量中长度最大的一个来决定，struct中成员变量内存都是独立的
47
48 2．union分配的内存是连续的，而struct不能保证分配的内存是连续的
49
50 队列和栈有什么区别？
51 队列先进先出，栈后进先出
52
53 指针在16位机、32位机、64位机分别占用多少个字节
54 16位机 2字节
55
56 32位机 4字节
57
58 64位机 8字节
59
60 如何引用一个已经定义过的全局变量？
61 extern
62
63 可以用引用头文件的方式，也可以用extern关键字，如果用引用头文件方式来引用某个在头文件中声明的全局变理，假定你将那个变写错了，那么在编译期间会报错，如果你用extern方式引用时，假定你犯了同样的错误，那么在编译期间不会报错，而在连接期间报错
64
65 全局变量可不可以定义在可被多个.C文件包含的头文件中？为什么？
66 可以，在不同的C文件中以static形式来声明同名全局变量。
67
68 可以在不同的C文件中声明同名的全局变量，前提是其中只能有一个C文件中对此变量赋初值，此时连接不会出错
69
70 语句for( ；1 ；)有什么问题？它是什么意思？
71 for( ；1 ；)和while(1)相同。
72
73 do……while和while……do有什么区别？
74 前一个循环一遍再判断，后一个判断以后再循环
75
76 请写出下列代码的输出内容
77 #include<stdio.h>
78
79 main()
80
81 {
82
83 int a,b,c,d;
84
85 a=10;
86
87 b=a++;
88
89 c=++a;
90
91 d=10*a++;
92
93 printf(“b，c，d：%d，%d，%d”，b，c，d）;
94
95 return 0;
96
97 }
98
99 10，12，120
100
101 对于一个频繁使用的短小函数,在C语言中应用什么实现,在C++中应用什么实现?
102 c用宏定义，c++用inline
103
104 main 函数执行以前，还会执行什么代码？
105 全局对象的构造函数会在main 函数之前执行。
106
107 main 主函数执行完毕后，是否可能会再执行一段代码，给出说明？
108 可以，可以用on_exit 注册一个函数，它会在main 之后执行int fn1(void), fn2(void), fn3(void), fn4 (void);
109
110 void main( void )
111
112 {
113
114 String str(“zhanglin”);
115
116 on_exit( fn1 );
117
118 on_exit( fn2 );
119
120 on_exit( fn3 );
121
122 on_exit( fn4 );
123
124 printf( “This is executed first.\n” );
125
126 }
127
128 int fn1()
129
130 {
131
132 printf( “next.\n” );
133
134 return 0;
135
136 }
137
138 int fn2()
139
140 {
141
142 printf( “executed ” );
143
144 return 0;
145
146 }
147
148 int fn3()
149
150 {
151
152 printf( “is ” );
153
154 return 0;
155
156 }
157
158 int fn4()
159
160 {
161
162 printf( “This ” );
163
164 return 0;
165
166 }
167
168 The on_exit function is passed the address of a function (func) to be called when the program terminates normally. Successive calls to on_exit create a register of functions that are executed in LIFO (last-in-first-out) order. The functions passed to on_exit cannot take parameters.
169
170 This is executed next.
171
172 局部变量能否和全局变量重名？
173 能，局部会屏蔽全局。要用全局变量，需要使用”::”
174
175 局部变量可以与全局变量同名，在函数内引用这个变量时，会用到同名的局部变量，而不会用到全局变量。对于有些编译器而言，在同一个函数内可以定义多个同名的局部变量，比如在两个循环体内都定义一个同名的局部变量，而那个局部变量的作用域就在那个循环体内
176
177 描述内存分配方式以及它们的区别?
178 1．从静态存储区域分配。内存在程序编译的时候就已经分配好，这块内存在程序的整个运行期间都存在。例如全局变量，static 变量。
179
180 2． 在栈上创建。在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集。
181
182 3． 从堆上分配，亦称动态内存分配。程序在运行的时候用malloc 或new 申请任意多少的内存，程序员自己负责在何时用free 或delete 释放内存。动态内存的生存期由程序员决定，使用非常灵活，但问题也最多。
183
184 类成员函数的重载、覆盖和隐藏区别？
185 1.成员函数被重载的特征：
186
187 （1）相同的范围（在同一个类中）；
188
189 （2）函数名字相同；
190
191 （3）参数不同；
192
193 （4）virtual 关键字可有可无。
194
195 2.覆盖是指派生类函数覆盖基类函数，特征是：
196
197 （1）不同的范围（分别位于派生类与基类）；
198
199 （2）函数名字相同；
200
201 （3）参数相同；
202
203 （4）基类函数必须有virtual 关键字。
204
205 3.”隐藏”是指派生类的函数屏蔽了与其同名的基类函数，规则如下：
206
207 （1）如果派生类的函数与基类的函数同名，但是参数不同。此时，不论有无virtual关键字，基类的函数将被隐藏（注意别与重载混淆）。
208
209 （2）如果派生类的函数与基类的函数同名，并且参数也相同，但是基类函数没有virtual 关键字。此时，基类的函数被隐藏（注意别与覆盖混淆）
210
211 static有什么用途？（请至少说明两种）
212 1.限制变量的作用域
213
214 2.设置变量的存储域
215
216 请说出const与#define 相比，有何优点？
217 1．const 常量有数据类型，而宏常量没有数据类型。编译器可以对前者进行类型安全检查。而对后者只进行字符替换，没有类型安全检查，并且在字符替换可能会产生意料不到的错误。
218
219 2．有些集成化的调试工具可以对const 常量进行调试，但是不能对宏常量进行调试。
220
221 堆栈溢出一般是由什么原因导致的？
222
223 没有回收垃圾资源
224
225
226
227 简述数组与指针的区别？
228 数组要么在静态存储区被创建（如全局数组），要么在栈上被创建。指针可以随时指向任意类型的内存块。
229
230 (1)修改内容上的差别
231
232 char a[] = “hello”;
233
234 a[0] = ‘X’;
235
236 char *p = “world”; // 注意p 指向常量字符串
237
238 p[0] = ‘X’; // 编译器不能发现该错误，运行时错误
239
240 (2) 用运算符sizeof 可以计算出数组的容量（字节数）。sizeof(p),p 为指针得到的是一个指针变量的字节数，而不是p 所指的内存容量。C++/C 语言没有办法知道指针所指的内存容量，除非在申请内存时记住它。注意当数组作为函数的参数进行传递时，该数组自动退化为同类型的指针。
241
242 char a[] = “hello world”;
243
244 char *p = a;
245
246 cout<< sizeof(a) << endl; // 12 字节
247
248 cout<< sizeof(p) << endl; // 4 字节
249
250 计算数组和指针的内存容量
251
252 void Func(char a[100])
253
254 {
255
256 cout<< sizeof(a) << endl; // 4 字节而不是100 字节
257
258 }
259
260 There are two int variables: a and b, don’t use “if”, “? :”, “switch”or other judgement statements, find out the biggest one of the two numbers.
261 ( ( a + b ) + abs( a – b ) ) / 2
262
263 冒泡排序算法的时间复杂度是什么？
264 O(n^2)
265
266 什么函数不能声明为虚函数？
267 构造函数（Constructor）
268
269 变量在内存中存放的位置
270 全局变量 全局静态区
271
272 全局静态变量 全局静态区
273
274 全局常量
275
276 有初始化 代码区
277
278 无初始化 全局静态区
279
280 局部变量 堆栈区
281
282 局部静态变量 静态区
283
284 局部常量 堆栈区
285
286 new和malloc分配空间 堆区
287
288 进程间通信方式
289 管道（有名管道，无名管道），共享内存，消息队列，信号量，socket通信
290
291 线程同步方式
292 临界区：通过对多线程的串行化来访问公共资源或一段代码，速度快，适合控制数据访问
293
294 互斥量：为协调共同对一个共享资源的单独访问而设计
295
296 信号量（PV操作）：为控制一个具有有限数量用户资源而设计
297
298 事件：用来通知线程有一些事件已
299
300 进程和线程的区别
301 资源：进程是拥有资源的一个独立单位，线程是不拥有资源。
302
303 调度：线程作为调度和分配的基本单位，进程是作为资源的基本单位
304
305 并发性：进程之间可以有并发性进行，同一个进程中的多个线程是可以并发执行
306
307 系统开销：进程在创建和撤销的时候，由于系统要分配和回收资源，导致系统的开销明显大于线程
308
309 一个进程可以拥有多个线程。
310
311 局部变量和全局变量能否重名
312 能，局部屏蔽全局。在C++里使用全局，需要使用”：：”。在C语言里，extern
313
314 虚函数和纯虚函数的区别
315 虚函数必须实现，纯虚函数没有实现
316
317 虚函数在子类里可以不重载，但是纯虚函数必须在每一个子类里去实现
318
319 在动态内存分配的时候，析构函数必须是虚函数，但没有必要是纯虚函数
320
321 面向对象的三大特性（四大特性）
322 封装、继承、多态（抽象）
323
324 封装：把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏
325
326 继承：子类可以拥有父类的属性和方法，但父类没有子类的属性和方法
327
328 多态：允许将子类类型的指针赋值给父类类型的指针
329
330 实现多态，有二种方式，覆盖，重载
331
332 覆盖，是指子类重新定义父类的虚函数的做法
333
334 重载，是指允许存在多个同名函数，而这些函数的参数表不同（或许参数个数不同，或许参数类型不同，或许两者都不同）
335
336 vi编辑器打开时跳到指定的行
337 vi +5000 filename
338
339 int型在Touble C里占多少个字节
340 2个字节
341
342 判断一个单链表是否有环
343 两个指针指向链表头，一个指针每次走一步，另一个指针每次走两步，若有一个指针先指向为NULL表示这个链表无环。若两个指针重合表示链表有环
344
345 刷新缓冲区方式?
346 换行刷新缓冲区
347
348 printf(“\n”);
349
350 使用函数刷新缓冲区
351
352 fflush(stdout);
353
354 程序结束刷新缓冲区
355
356 return 0;
357
358 类和对象的两个基本概念什么？
359 对象就是对客观事物在计算机中的抽象描述。
360
361 类就是对具体相似属性和行为的一组对象的统一描述。
362
363 类的包括：类说明和类实现两大部分：
364
365 类说明提供了对该类所有数据成员和成员函数的描述。
366
367 类实现提供了所有成员函数的实现代码。
368
369 数据库三范式
370 第一范式：没有重复的列
371
372 第二范式：非主属的部分依赖于主属部分
373
374 第三范式：属性部分不依赖于其他非主属部分
375
376 ASSERT( )是干什么用的
377 是在调试程序使用的一个宏，括号里面要满足，如果不满足，程序将报告错误，并将终止执行。
378
379 如果只想让程序有一个实例运行，不能运行两个。像winamp一样，只能开一个窗口，怎样实现？
380 用内存映射或全局原子（互斥变量）、查找窗口句柄
381
382 FindWindow，互斥，写标志到文件或注册表,共享内存
383
384 如何截取键盘的响应，让所有的’a’变成’b’？
385 键盘钩子SetWindowsHookEx
386
387 网络编程中设计并发服务器，使用多进程 与 多线程 ，请问有什么区别？
388 1．进程：子进程是父进程的复制品。子进程获得父进程数据空间、堆和栈的复制品。
389
390 2．线程：相对与进程而言，线程是一个更加接近与执行体的概念，它可以与同进程的其他线程共享数据，但拥有自己的栈空间，拥有独立的执行序列。
391
392 两者都可以提高程序的并发度，提高程序运行效率和响应时间。
393
394 线程和进程在使用上各有优缺点：线程执行开销小，但不利于资源管理和保护；而进程正相反。同时，线程适合于在SMP机器上运行，而进程则可以跨机器迁移。
395
396 编程
397 字符串实现
398 strcat
399 char *strcat(char *strDes, const char *strSrc)
400
401 {
402
403 assert((strDes != NULL) && (strSrc != NULL));
404
405 char *address = strDes;
406
407 while (*strDes != ‘\0′)
408
409 ++ strDes;
410
411 while ((*strDes ++ = *strSrc ++) != ‘\0′)
412
413 NULL;
414
415 return address;
416
417 }
418
419 strncat
420 char *strncat(char *strDes, const char *strSrc, int count)
421
422 {
423
424 assert((strDes != NULL) && (strSrc != NULL));
425
426 char *address = strDes;
427
428 while (*strDes != ‘\0′)
429
430 ++ strDes;
431
432 while (count — && *strSrc != ‘\0′ )
433
434 *strDes ++ = *strSrc ++;
435
436 *strDes = ‘\0′;
437
438 return address;
439
440 }
441
442 strcmp
443 int strcmp(const char *s, const char *t)
444
445 {
446
447 assert(s != NULL && t != NULL);
448
449 while (*s && *t && *s == *t)
450
451 {
452
453 ++ s;
454
455 ++ t;
456
457 }
458
459 return (*s – *t);
460
461 }
462
463 strncmp
464 int strncmp(const char *s, const char *t, int count)
465
466 {
467
468 assert((s != NULL) && (t != NULL));
469
470 while (*s && *t && *s == *t && count –)
471
472 {
473
474 ++ s;
475
476 ++ t;
477
478 }
479
480 return (*s – *t);
481
482 }
483
484 strcpy
485 char *strcpy(char *strDes, const char *strSrc)
486
487 {
488
489 assert((strDes != NULL) && (strSrc != NULL));
490
491 char *address = strDes;
492
493 while ((*strDes ++ = *strSrc ++) != ‘\0′)
494
495 NULL;
496
497 return address;
498
499 }
500
501
502
503 strncpy
504 char *strncpy(char *strDes, const char *strSrc, int count)
505
506 {
507
508 assert(strDes != NULL && strSrc != NULL);
509
510 char *address = strDes;
511
512 while (count — && *strSrc != ‘\0′)
513
514 *strDes ++ = *strSrc ++;
515
516 return address;
517
518 }
519
520 strlen
521 int strlen(const char *str)
522
523 {
524
525 assert(str != NULL);
526
527 int len = 0;
528
529 while (*str ++ != ‘\0′)
530
531 ++ len;
532
533 return len;
534
535 }
536
537 strpbrk
538 char *strpbrk(const char *strSrc, const char *str)
539
540 {
541
542 assert((strSrc != NULL) && (str != NULL));
543
544 const char *s;
545
546 while (*strSrc != ‘\0′)
547
548 {
549
550 s = str;
551
552 while (*s != ‘\0′)
553
554 {
555
556 if (*strSrc == *s)
557
558 return (char *) strSrc;
559
560 ++ s;
561
562 }
563
564 ++ strSrc;
565
566 }
567
568 return NULL;
569
570 }
571
572 strstr
573 char *strstr(const char *strSrc, const char *str)
574
575 {
576
577 assert(strSrc != NULL && str != NULL);
578
579 const char *s = strSrc;
580
581 const char *t = str;
582
583 for (; *t != ‘\0′; ++ strSrc)
584
585 {
586
587 for (s = strSrc, t = str; *t != ‘\0′ && *s == *t; ++s, ++t)
588
589 NULL;
590
591 if (*t == ‘\0′)
592
593 return (char *) strSrc;
594
595 }
596
597 return NULL;
598
599 }
600
601 strcspn
602 int strcspn(const char *strSrc, const char *str)
603
604 {
605
606 assert((strSrc != NULL) && (str != NULL));
607
608 const char *s;
609
610 const char *t = strSrc;
611
612 while (*t != ‘\0′)
613
614 {
615
616 s = str;
617
618 while (*s != ‘\0′)
619
620 {
621
622 if (*t == *s)
623
624 return t – strSrc;
625
626 ++ s;
627
628 }
629
630 ++ t;
631
632 }
633
634 return 0;
635
636 }
637
638 strspn
639 int strspn(const char *strSrc, const char *str)
640
641 {
642
643 assert((strSrc != NULL) && (str != NULL));
644
645 const char *s;
646
647 const char *t = strSrc;
648
649 while (*t != ‘\0′)
650
651 {
652
653 s = str;
654
655 while (*s != ‘\0′)
656
657 {
658
659 if (*t == *s)
660
661 break;
662
663 ++ s;
664
665 }
666
667 if (*s == ‘\0′)
668
669 return t – strSrc;
670
671 ++ t;
672
673 }
674
675 return 0;
676
677 }
678
679 strrchr
680 char *strrchr(const char *str, int c)
681
682 {
683
684 assert(str != NULL);
685
686 const char *s = str;
687
688 while (*s != ‘\0′)
689
690 ++ s;
691
692 for (– s; *s != (char) c; — s)
693
694 if (s == str)
695
696 return NULL;
697
698 return (char *) s;
699
700 }
701
702 strrev
703 char* strrev(char *str)
704
705 {
706
707 assert(str != NULL);
708
709 char *s = str, *t = str, c;
710
711 while (*t != ‘\0′)
712
713 ++ t;
714
715 for (– t; s < t; ++ s, — t)
716
717 {
718
719 c = *s;
720
721 *s = *t;
722
723 *t = c;
724
725 }
726
727 return str;
728
729 }
730
731 strnset
732 char *strnset(char *str, int c, int count)
733
734 {
735
736 assert(str != NULL);
737
738 char *s = str;
739
740 for (; *s != ‘\0′ && s – str < count; ++ s)
741
742 *s = (char) c;
743
744 return str;
745
746 }
747
748 strset
749 char *strset(char *str, int c)
750
751 {
752
753 assert(str != NULL);
754
755 char *s = str;
756
757 for (; *s != ‘\0′; ++ s)
758
759 *s = (char) c;
760
761 return str;
762
763 }
764
765 strtok
766 char *strtok(char *strToken, const char *str)
767
768 {
769
770 assert(strToken != NULL && str != NULL);
771
772 char *s = strToken;
773
774 const char *t = str;
775
776 while (*s != ‘\0′)
777
778 {
779
780 t = str;
781
782 while (*t != ‘\0′)
783
784 {
785
786 if (*s == *t)
787
788 {
789
790 *(strToken + (s – strToken)) = ‘\0′;
791
792 return strToken;
793
794 }
795
796 ++ t;
797
798 }
799
800 ++ s;
801
802 }
803
804 return NULL;
805
806 }
807
808 strupr
809 char *strupr(char *str)
810
811 {
812
813 assert(str != NULL);
814
815 char *s = str;
816
817 while (*s != ‘\0′)
818
819 {
820
821 if (*s >= ‘a’ && *s <= ‘z’)
822
823 *s -= 0×20;
824
825 s ++;
826
827 }
828
829 return str;
830
831 }
832
833 strlwr
834 char *strlwr(char *str)
835
836 {
837
838 assert(str != NULL);
839
840 char *s = str;
841
842 while (*s != ‘\0′)
843
844 {
845
846 if (*s >= ‘A’ && *s <= ‘Z’)
847
848 *s += 0×20;
849
850 s ++;
851
852 }
853
854 return str;
855
856 }
857
858 memcpy
859 void *memcpy(void *dest, const void *src, int count)
860
861 {
862
863 assert((dest != NULL) && (src != NULL));
864
865 void *address = dest;
866
867 while (count –)
868
869 {
870
871 *(char *) dest = *(char *) src;
872
873 dest = (char *) dest + 1;
874
875 src = (char *) src + 1;
876
877 }
878
879 return address;
880
881 }
882
883 memccpy
884 void *memccpy(void *dest, const void *src, int c, unsigned int count)
885
886 {
887
888 assert((dest != NULL) && (src != NULL));
889
890 while (count –)
891
892 {
893
894 *(char *) dest = *(char *) src;
895
896 if (* (char *) src == (char) c)
897
898 return ((char *)dest + 1);
899
900 dest = (char *) dest + 1;
901
902 src = (char *) src + 1;
903
904 }
905
906 return NULL;
907
908 }
909
910 memchr
911 void *memchr(const void *buf, int c, int count)
912
913 {
914
915 assert(buf != NULL);
916
917 while (count –)
918
919 {
920
921 if (*(char *) buf == c)
922
923 return (void *) buf;
924
925 buf = (char *) buf + 1;
926
927 }
928
929 return NULL;
930
931 }
932
933 memcmp
934 int memcmp(const void *s, const void *t, int count)
935
936 {
937
938 assert((s != NULL) && (t != NULL));
939
940 while (*(char *) s && *(char *) t && *(char *) s == *(char *) t && count –)
941
942 {
943
944 s = (char *) s + 1;
945
946 t = (char *) t + 1;
947
948 }
949
950 return (*(char *) s – *(char *) t);
951
952 }
953
954 memmove
955 void *memmove(void *dest, const void *src, int count)
956
957 {
958
959 assert(dest != NULL && src != NULL);
960
961 void *address = dest;
962
963 while (count –)
964
965 {
966
967 *(char *) dest = *(char *) src;
968
969 dest = (char *) dest + 1;
970
971 src = (const char *)src + 1;
972
973 }
974
975 return address;
976
977 }
978
979 memset
980 void *memset(void *str, int c, int count)
981
982 {
983
984 assert(str != NULL);
985
986 void *s = str;
987
988 while (count –)
989
990 {
991
992 *(char *) s = (char) c;
993
994 s = (char *) s + 1;
995
996 }
997
998 return str;
999
1000 }
1001
1002
1003
1004 strdup
1005 char *strdup(const char *strSrc)
1006
1007 {
1008
1009 assert(strSrc != NULL);
1010
1011 int len = 0;
1012
1013 while (*strSrc ++ != ‘\0′)
1014
1015 ++ len;
1016
1017 char *strDes = (char *) malloc (len + 1);
1018
1019 while ((*strDes ++ = *strSrc ++) != ‘\0′)
1020
1021 NULL;
1022
1023 return strDes;
1024
1025 }
1026
1027 strchr_
1028 char *strchr_(char *str, int c)
1029
1030 {
1031
1032 assert(str != NULL);
1033
1034 while ((*str != (char) c) && (*str != ‘\0′))
1035
1036 str ++;
1037
1038 if (*str != ‘\0′)
1039
1040 return str;
1041
1042 return NULL;
1043
1044 }
1045
1046 strchr
1047 char *strchr(const char *str, int c)
1048
1049 {
1050
1051 assert(str != NULL);
1052
1053 for (; *str != (char) c; ++ str)
1054
1055 if (*str == ‘\0′)
1056
1057 return NULL;
1058
1059 return (char *) str;
1060
1061 }
1062
1063 atoi
1064 int atoi(const char* str)
1065
1066 {
1067
1068 int x=0;
1069
1070 const char* p=str;
1071
1072 if(*str==’-’||*str==’+’)
1073
1074 {
1075
1076 str++;
1077
1078 }
1079
1080 while(*str!=0)
1081
1082 {
1083
1084 if((*str>’9′)||(*str<’0′))
1085
1086 {
1087
1088 break;
1089
1090 }
1091
1092 x=x*10+(*str-’0′);
1093
1094 str++;
1095
1096 }
1097
1098 if(*p==’-’)
1099
1100 {
1101
1102 x=-x;
1103
1104 }
1105
1106 return x;
1107
1108 }
1109
1110 itoa
1111 char* itoa(int val,char* buf,unsigned int radix)
1112
1113 {
1114
1115 char *bufptr;
1116
1117 char *firstdig;
1118
1119 char temp;
1120
1121 unsigned int digval;
1122
1123 assert(buf != NULL);
1124
1125 bufptr = buf;
1126
1127 if (val < 0)
1128
1129 {
1130
1131 *bufptr++ = ‘-’; val = (unsigned int)(-(int)val);
1132
1133 }
1134
1135 firstdig = bufptr;
1136
1137 do
1138
1139 {
1140
1141 digval =(unsigned int) val % radix; val /= radix;
1142
1143 if (digval > 9)
1144
1145 {
1146
1147 *bufptr++ = (char)(digval – 10 + ‘a’);
1148
1149 }
1150
1151 else
1152
1153 {
1154
1155 *bufptr++ = (char)(digval + ’0′);
1156
1157 }
1158
1159 } while(val > 0);
1160
1161 *bufptr– = ‘\0′;//设置字符串末尾，并将指针指向最后一个字符
1162
1163 do //反转字符
1164
1165 {
1166
1167 temp = *bufptr; *bufptr = *firstdig; *firstdig = temp;
1168
1169 –bufptr; ++firstdig;
1170
1171 } while(firstdig < bufptr);
1172
1173 return buf;
1174
1175 }
1176
1177 String实现
1178 已知String原型为：
1179
1180 class String
1181
1182 {
1183
1184 public:
1185
1186 //普通构造函数
1187
1188 String(const char *str = NULL)
1189
1190 //拷贝构造函数
1191
1192 String(const String &other)
1193
1194 //析构函数
1195
1196 ~String(void);
1197
1198 //赋值函数
1199
1200 String & operator=(String &other) //oh,原题目打错了,string可是一个关键字
1201
1202 private:
1203
1204 char* m_str;
1205
1206 unsigned m_uCount;
1207
1208 };
1209
1210 分别实现以上四个函数
1211
1212 //普通构造函数
1213
1214 String::String(const char* str)
1215
1216 {
1217
1218 if(str==NULL) //如果str为NULL，存空字符串
1219
1220 {
1221
1222 m_str = new char[1]; //分配一个字节
1223
1224 *m_str = ‘\0′; //赋一个’\0′
1225
1226 }else
1227
1228 {
1229
1230 m_str = new char[strlen(str) + 1];//分配空间容纳str内容
1231
1232 strcpy(m_str, str); //复制str到私有成员m_str中
1233
1234 }
1235
1236 }
1237
1238 //析构函数
1239
1240 String::~String()
1241
1242 {
1243
1244 if(m_str!=NULL) //如果m_str不为NULL，释放堆内存
1245
1246 {
1247
1248 delete [] m_str;
1249
1250 m_str = NULL;
1251
1252 }
1253
1254 }
1255
1256 //拷贝构造函数
1257
1258 String::String(const String &other)
1259
1260 {
1261
1262 m_str = new char[strlen(other.m_str)+1]; //分配空间容纳str内容
1263
1264 strcpy(m_str, other.m_str); //复制other.m_str到私有成员m_str中
1265
1266 }
1267
1268 //赋值函数
1269
1270 String & String::operator=(String &other)
1271
1272 {
1273
1274 if(this == &other) //若对象与other是同一个对象，直接返回本身
1275
1276 {
1277
1278 return *this
1279
1280 }
1281
1282 delete [] m_str; //否则，先释放当前对象堆内存
1283
1284 m_str = new char[strlen(other.m_str)+1]; //分配空间容纳str内容
1285
1286 strcpy(m_str, other.m_str); //复制other.m_str到私有成员m_str中
1287
1288 return *this；
1289
1290 }
1291
1292 编写一个二分查找的功能函数
1293 int BSearch(elemtype a[],elemtype x,int low,int high)
1294
1295 /*在下届为low，上界为high的数组a中折半查找数据元素x*/
1296
1297 {
1298
1299 int mid;
1300
1301 if(low>high)
1302
1303 return -1;
1304
1305 mid=(low+high)/2;
1306
1307 if(x==a[mid])
1308
1309 return mid;
1310
1311 if(x<a[mid])
1312
1313 return(BSearch(a,x,low,mid-1));
1314
1315 else
1316
1317 return(BSearch(a,x,mid+1,high));
1318
1319 }
1320
1321 2) 非递归方法实现：
1322
1323 int BSearch(elemtype a[],keytype key,int n)
1324
1325 {
1326
1327 int low,high,mid;
1328
1329 low=0;high=n-1;
1330
1331 while(low<=high)
1332
1333 {
1334
1335 mid=(low+high)/2;
1336
1337 if(a[mid].key==key)
1338
1339 return mid;
1340
1341 else if(a[mid].key<key)
1342
1343 low=mid+1;
1344
1345 else
1346
1347 high=mid-1;
1348
1349 }
1350
1351 return -1;
1352
1353 }
1354
1355 字符串逆序
1356 方法一
1357
1358 #include <stdio.h>
1359
1360 #include <string.h>
1361
1362 void main()
1363
1364 {
1365
1366 char str[]=”hello,world”;
1367
1368 int len=strlen(str);
1369
1370 char t;
1371
1372 int i;
1373
1374 for(i=0; i<len/2; i++)
1375
1376 {
1377
1378 t=str[i];
1379
1380 str[i]=str[len-i-1];
1381
1382 str[len-i-1]=t;
1383
1384 }
1385
1386 printf(“%s\n”,str);
1387
1388 return 0;
1389
1390 }
1391
1392 方法二
1393
1394 #include <stdio.h>
1395
1396 int main(){
1397
1398 char* src = “hello,world”;
1399
1400 int len = strlen(src);
1401
1402 char* dest = (char*)malloc(len+1);//要为\0分配一个空间
1403
1404 char* d = dest;
1405
1406 char* s = &src[len-1];//指向最后一个字符
1407
1408 while( len– != 0 )
1409
1410 *d++=*s–;
1411
1412 *d = 0;//尾部要加\0
1413
1414 printf(“%s\n”,dest);
1415
1416 free(dest);// 使用完，应当释放空间，以免造成内存汇泄露
1417
1418 return 0;
1419
1420 }
1421
1422 排序
1423 冒泡排序
1424 void bubble_sort(int a[],int n)
1425
1426 {
1427
1428 int i,j;
1429
1430 for(i=0;i<n-1;i++)
1431
1432 {
1433
1434 bool x=ture;
1435
1436 for(j=0;j<n-1-i;j++)
1437
1438 {
1439
1440 int temp;
1441
1442 if(a[j]>a[j+1])
1443
1444 {
1445
1446 temp=a[j];
1447
1448 a[j]=a[j+1];
1449
1450 a[j+1]=temp;
1451
1452 x=false;
1453
1454 }
1455
1456 }
1457
1458 if(x) break;
1459
1460 }
1461
1462 }
1463
1464 时间复杂度O(N^2)
1465
1466 选择排序
1467 void select_sort(int a[],int n)
1468
1469 {
1470
1471 int i,j;
1472
1473 for(i=0;i<n-1;i++)
1474
1475 {
1476
1477 int min=i;
1478
1479 for(j=i+1;j<n;j++)
1480
1481 {
1482
1483 if(a[j]<a[min])
1484
1485 min=j;
1486
1487 if(min!=i)
1488
1489 {
1490
1491 int temp=a[j];
1492
1493 a[j]=a[min];
1494
1495 a[min]=temp;
1496
1497 }
1498
1499 }
1500
1501 }
1502
1503 }
1504
1505 时间复杂度O(N^2)
1506
1507 插入排序
1508 void insert_sort(int a[],int n)
1509
1510 {
1511
1512 int i,j;
1513
1514 for(i=1;i<n;i++)
1515
1516 {
1517
1518 int x=a[i];
1519
1520 for(j=i;j>0&&x<a[j-1];j–)
1521
1522 a[j]=a[j-1];
1523
1524 a[j]=x;
1525
1526 }
1527
1528 }
1529
1530 时间复杂度O(N^2)
1531
1532 快速排序
1533 void quick_sort(int a[],int ileft,int iright)
1534
1535 {
1536
1537 int iPivot=(left+right)/2;
1538
1539 int nPivot=a[iPivot];
1540
1541 for(int i=ileft,j=iright;i<j;)
1542
1543 {
1544
1545 while(!(i>=iPivot||nPivot<a[i]))
1546
1547 i++;
1548
1549 if(i<iPivot)
1550
1551 {
1552
1553 a[iPivot]=a[i];
1554
1555 iPivot=i;
1556
1557 }
1558
1559 while(!(j<=iPivot||nPivot>a[j]))
1560
1561 j–;
1562
1563 if(j>iPivot)
1564
1565 {
1566
1567 a[iPivot]=a[j];
1568
1569 iPivot=j;
1570
1571 }
1572
1573 }
1574
1575 a[iPivot]=nPivot;
1576
1577 if(iPivot-ileft>1)
1578
1579 quick_sort(a,ileft,iPivot-1);
1580
1581 if(iright-iPivot>1)
1582
1583 quick_sort(a,iPivot+1,iright);
1584
1585 }
1586
1587 时间复杂度O(NlogN)
1588
1589 链表
1590 单链表
1591 双链表
1592 循环链表
1593 单链表逆置
1594 void reverse(link *head)
1595
1596 {
1597
1598 link *p, *s, *t;
1599
1600 p = head;
1601
1602 s = p->next;
1603
1604 while(s->next!=NULL)
1605
1606 {
1607
1608 t = s->next;
1609
1610 s->next = p;
1611
1612 p = s;
1613
1614 s = t;
1615
1616 }
1617
1618 s->next = p;
1619
1620 head->next->next = NULL; //尾指针置为空
1621
1622 head->next = s; //赋值到头指针后一位
1623
1624 }
1625
1626 链表合并
1627 Node * Merge(Node *head1 , Node *head2)
1628
1629 {
1630
1631 if ( head1 == NULL)
1632
1633 return head2 ;
1634
1635 if ( head2 == NULL)
1636
1637 return head1 ;
1638
1639 Node *head = NULL ;
1640
1641 Node *p1 = NULL;
1642
1643 Node *p2 = NULL;
1644
1645 if ( head1->data < head2->data )
1646
1647 {
1648
1649 head = head1 ;
1650
1651 p1 = head1->next;
1652
1653 p2 = head2 ;
1654
1655 }else
1656
1657 {
1658
1659 head = head2 ;
1660
1661 p2 = head2->next ;
1662
1663 p1 = head1 ;
1664
1665 }
1666
1667 Node *pcurrent = head ;
1668
1669 while ( p1 != NULL && p2 != NULL)
1670
1671 {
1672
1673 if ( p1->data <= p2->data )
1674
1675 {
1676
1677 pcurrent->next = p1 ;
1678
1679 pcurrent = p1 ;
1680
1681 p1 = p1->next ;
1682
1683 }else
1684
1685 {
1686
1687 pcurrent->next = p2 ;
1688
1689 pcurrent = p2 ;
1690
1691 p2 = p2->next ;
1692
1693 }
1694
1695 }
1696
1697 if ( p1 != NULL )
1698
1699 pcurrent->next = p1 ;
1700
1701 if ( p2 != NULL )
1702
1703 pcurrent->next = p2 ;
1704
1705 return head ;
1706
1707 }
1708
1709
1710
1711 递归方式：
1712
1713 Node * MergeRecursive(Node *head1 , Node *head2)
1714
1715 {
1716
1717 if ( head1 == NULL )
1718
1719 return head2 ;
1720
1721 if ( head2 == NULL)
1722
1723 return head1 ;
1724
1725 Node *head = NULL ;
1726
1727 if ( head1->data < head2->data )
1728
1729 {
1730
1731 head = head1 ;
1732
1733 head->next = MergeRecursive(head1->next,head2);
1734
1735 }
1736
1737 else
1738
1739 {
1740
1741 head = head2 ;
1742
1743 head->next = MergeRecursive(head1,head2->next);
1744
1745 }
1746
1747 return head ;
1748
1749 }
1750
1751 写一个Singleton模式
1752 #include<iostream>
1753
1754 using namespace std;
1755
1756 class Singleton
1757
1758 {
1759
1760 private:
1761
1762 static Singleton* _instance;
1763
1764 protected:
1765
1766 Singleton()
1767
1768 {
1769
1770 cout<<”Singleton”<<endl;
1771
1772 }
1773
1774 public:
1775
1776 static Singleton* Instance()
1777
1778 {
1779
1780 if(NULL==_instance)
1781
1782 {
1783
1784 _instance=new Singleton();
1785
1786 }
1787
1788 return _instance;
1789
1790 }
1791
1792 };
1793
1794 static Singleton* Singleton::_instance=NULL;
1795
1796 int main()
1797
1798 {
1799
1800 Singleton * s =Singleton::Instance();
1801
1802 Singleton * s1=Singleton::Instance();
1803
1804 }
1805
1806 如何对String类型数据的某个字符进行访问？
1807 #include<iostream>
1808
1809 using namespace std;
1810
1811 int main()
1812
1813 {
1814
1815 string s=”abcdefg”;
1816
1817 const char *c=s.c_str();
1818
1819 while(*c!=’\0′)
1820
1821 {
1822
1823 printf(“%c”,*c++);
1824
1825 }
1826
1827 }
1828
1829 文件加密、解密
1830 1.加密（encryption）：
1831 #include<stdio.h>
1832
1833 void encryption(char *ch)
1834
1835 {
1836
1837 (*ch)^=0xFF; //算法可自行修改调整，使用AES加密算法
1838
1839 }
1840
1841 int main(int argc,char *argv[])
1842
1843 {
1844
1845 if(argc<2)
1846
1847 {
1848
1849 printf(“参数不足”);
1850
1851 return -1;
1852
1853 }
1854
1855 //文件的打开（fopen函数）
1856
1857 /*
1858
1859 r read 只读
1860
1861 w write 只写
1862
1863 a append 追加
1864
1865 t text 文本文件，可省略不写
1866
1867 b banary 二进制文件
1868
1869 + 读和写
1870
1871 */
1872
1873 a.out a.c b.txt
1874
1875 argv[0] argv[1] argv[2]
1876
1877
1878
1879
1880
1881
1882
1883 FILE* fpr=NULL;
1884
1885 FILE* fpw=NULL;
1886
1887 //文件打开失败返回一个空指针值NULL
1888
1889 if(NULL==(fpr=fopen(argv[1],”r”))){printf(“%m\n”);return -1;}
1890
1891 if(NULL==(fpw=fopen(argv[2],”w+”))){printf(“%m\n”);return -1;}
1892
1893 char ch;
1894
1895 while((ch=fgetc(fpr))!=EOF)
1896
1897 {
1898
1899 //putchar(ch);
1900
1901 encryption(&ch);//加密函数
1902
1903 printf(“%c”,ch);//加密后字符显示
1904
1905 fputc(ch,fpw);//存放进文件
1906
1907 }
1908
1909 printf(“\n文件加密成功！\n”);
1910
1911
1912
1913 //文件的关闭(fclose函数)
1914
1915 fclose(fpr);
1916
1917 fclose(fpw);
1918
1919 }
1920
1921
1922
1923 2.解密（decryption）：
1924 #include<stdio.h>
1925
1926 #include<time.h>
1927
1928
1929
1930 void show()
1931
1932 {
1933
1934 time_t start=time(NULL);
1935
1936 while(start==time(NULL));
1937
1938 }
1939
1940 void decryption(char ch)
1941
1942 {
1943
1944 (*ch)^=0xFF;//算法可自行修改调整
1945
1946 }
1947
1948 int main(int argc,char *argv[])
1949
1950 {
1951
1952 if(argc<2)
1953
1954 {
1955
1956 printf(“参数不足”);
1957
1958 return -1;
1959
1960 }
1961
1962 //文件的打开（fopen函数）
1963
1964 /*
1965
1966 r read 只读
1967
1968 w write 只写
1969
1970 a append 追加
1971
1972 t text 文本文件，可省略不写
1973
1974 b banary 二进制文件
1975
1976 + 读和写
1977
1978 */
1979
1980 FILE* fpr=NULL;
1981
1982 FILE* fpw=NULL;
1983
1984 //文件打开失败返回一个空指针值NULL
1985
1986 if(NULL==(fpr=fopen(argv[1],”r”))){printf(“%m\n”);return -1;}
1987
1988 if(NULL==(fpw=fopen(argv[2],”w+”))){printf(“%m\n”);return -1;}
1989
1990 char ch;
1991
1992 printf(“开始解密！\n”);
1993
1994 while((ch=fgetc(fpr))!=EOF)
1995
1996 {
1997
1998 show();
1999
2000 ch=decryption(ch);//解密函数
2001
2002 printf(“%c”,ch);//解密后字符显示
2003
2004 fputc(ch,fpw);//存放进文件
2005
2006 fflush(stdout);//刷新显示
2007
2008 }
2009
2010 printf(“\n文件解密成功！\n”);
2011
2012
2013
2014 //文件的关闭(fclose函数)
2015
2016 fclose(fpr);
2017
2018 fclose(fpw);
2019
2020 }
2021
2022 斐波那契数列（Fibonacci sequence）
2023 int Funct( int n )
2024
2025 {
2026
2027 if( n==0 || n==1 ) return 1;
2028
2029 retrurn Funct(n-1) + Funct(n-2);
2030
2031 }
标签：ZZ,int,汇总,C++,next,char,str,NULL,函数 来源： https://www.cnblogs.com/mch5201314/p/11480401.html
本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享； 2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关； 3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关； 4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除； 5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。