c/c++面试大全
指针和引用的区别 指针指向一块内存,它的内容是指向内存的地址;引用是某内存的别名 引用使用是无需解引用,指针需解引用 引用不能为空,指针可以为空 引用在定义是被初始化一次,之后不可变;指针可变 程序为指针变量分配内存区域,而引用不需要分配内存区域 memcpy和strcpy的区别 memcpy用来内存拷贝的,它有指定的拷贝数据长度,他可以拷贝任何数据类型的对象 Strcpy它只能去拷贝字符串,它遇到’\0′结束拷贝 new和malloc的区别,free和delete的区别 malloc与free是C++/C语言的标准库函数,new/delete是C++的运算符。它们都可用于申请动态内存和释放内存。 对于非内部数据类型的对象而言,光用maloc/free无法满足动态对象的要求。对象在创建的同时要自动执行构造函数,对象在消亡之前要自动执行析构函数。由于malloc/free是库函数而不是运算符,不在编译器控制权限之内,不能够把执行构造函数和析构函数的任务强加于malloc/free。 因此C++语言需要一个能完成动态内存分配和初始化工作的运算符new,以及一个能完成清理与释放内存工作的运算符delete。注意new/delete不是库函数。 struct和class的区别 1.成员变量 结构在默认情况下的成员是公共(public)的, 而类在默认情况下的成员是私有(private)的。 2.存储 struct保证成员按照声明顺序在内存中存储。class不保证等等 3.继承 struct A { }; class B : A{ }; //private继承 struct C : B{ }; //public继承 这是由于class默认是private,struct默认是public。 struct与union的区别.(一般假定在32位机器上) 1.一个union类型的变量,所有成员变量共享一块内存,该内存的大小有这些成员变量中长度最大的一个来决定,struct中成员变量内存都是独立的 2.union分配的内存是连续的,而struct不能保证分配的内存是连续的 队列和栈有什么区别? 队列先进先出,栈后进先出 指针在16位机、32位机、64位机分别占用多少个字节 16位机 2字节 32位机 4字节 64位机 8字节 如何引用一个已经定义过的全局变量? extern 可以用引用头文件的方式,也可以用extern关键字,如果用引用头文件方式来引用某个在头文件中声明的全局变理,假定你将那个变写错了,那么在编译期间会报错,如果你用extern方式引用时,假定你犯了同样的错误,那么在编译期间不会报错,而在连接期间报错 全局变量可不可以定义在可被多个.C文件包含的头文件中?为什么? 可以,在不同的C文件中以static形式来声明同名全局变量。 可以在不同的C文件中声明同名的全局变量,前提是其中只能有一个C文件中对此变量赋初值,此时连接不会出错 语句for( ;1 ;)有什么问题?它是什么意思? for( ;1 ;)和while(1)相同。 do……while和while……do有什么区别? 前一个循环一遍再判断,后一个判断以后再循环 请写出下列代码的输出内容 #include<stdio.h> main() { int a,b,c,d; a=10; b=a++; c=++a; d=10*a++; printf(“b,c,d:%d,%d,%d”,b,c,d); return 0; } 10,12,120 对于一个频繁使用的短小函数,在C语言中应用什么实现,在C++中应用什么实现? c用宏定义,c++用inline main 函数执行以前,还会执行什么代码? 全局对象的构造函数会在main 函数之前执行。 main 主函数执行完毕后,是否可能会再执行一段代码,给出说明? 可以,可以用on_exit 注册一个函数,它会在main 之后执行int fn1(void), fn2(void), fn3(void), fn4 (void); void main( void ) { String str(“zhanglin”); on_exit( fn1 ); on_exit( fn2 ); on_exit( fn3 ); on_exit( fn4 ); printf( “This is executed first.\n” ); } int fn1() { printf( “next.\n” ); return 0; } int fn2() { printf( “executed ” ); return 0; } int fn3() { printf( “is ” ); return 0; } int fn4() { printf( “This ” ); return 0; } 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. This is executed next. 局部变量能否和全局变量重名? 能,局部会屏蔽全局。要用全局变量,需要使用”::” 局部变量可以与全局变量同名,在函数内引用这个变量时,会用到同名的局部变量,而不会用到全局变量。对于有些编译器而言,在同一个函数内可以定义多个同名的局部变量,比如在两个循环体内都定义一个同名的局部变量,而那个局部变量的作用域就在那个循环体内 描述内存分配方式以及它们的区别? 1.从静态存储区域分配。内存在程序编译的时候就已经分配好,这块内存在程序的整个运行期间都存在。例如全局变量,static 变量。 2. 在栈上创建。在执行函数时,函数内局部变量的存储单元都可以在栈上创建,函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集。 3. 从堆上分配,亦称动态内存分配。程序在运行的时候用malloc 或new 申请任意多少的内存,程序员自己负责在何时用free 或delete 释放内存。动态内存的生存期由程序员决定,使用非常灵活,但问题也最多。 类成员函数的重载、覆盖和隐藏区别? 1.成员函数被重载的特征: (1)相同的范围(在同一个类中); (2)函数名字相同; (3)参数不同; (4)virtual 关键字可有可无。 2.覆盖是指派生类函数覆盖基类函数,特征是: (1)不同的范围(分别位于派生类与基类); (2)函数名字相同; (3)参数相同; (4)基类函数必须有virtual 关键字。 3.”隐藏”是指派生类的函数屏蔽了与其同名的基类函数,规则如下: (1)如果派生类的函数与基类的函数同名,但是参数不同。此时,不论有无virtual关键字,基类的函数将被隐藏(注意别与重载混淆)。 (2)如果派生类的函数与基类的函数同名,并且参数也相同,但是基类函数没有virtual 关键字。此时,基类的函数被隐藏(注意别与覆盖混淆) static有什么用途?(请至少说明两种) 1.限制变量的作用域 2.设置变量的存储域 请说出const与#define 相比,有何优点? 1.const 常量有数据类型,而宏常量没有数据类型。编译器可以对前者进行类型安全检查。而对后者只进行字符替换,没有类型安全检查,并且在字符替换可能会产生意料不到的错误。 2.有些集成化的调试工具可以对const 常量进行调试,但是不能对宏常量进行调试。 堆栈溢出一般是由什么原因导致的? 没有回收垃圾资源 简述数组与指针的区别? 数组要么在静态存储区被创建(如全局数组),要么在栈上被创建。指针可以随时指向任意类型的内存块。 (1)修改内容上的差别 char a[] = “hello”; a[0] = ‘X’; char *p = “world”; // 注意p 指向常量字符串 p[0] = ‘X’; // 编译器不能发现该错误,运行时错误 (2) 用运算符sizeof 可以计算出数组的容量(字节数)。sizeof(p),p 为指针得到的是一个指针变量的字节数,而不是p 所指的内存容量。C++/C 语言没有办法知道指针所指的内存容量,除非在申请内存时记住它。注意当数组作为函数的参数进行传递时,该数组自动退化为同类型的指针。 char a[] = “hello world”; char *p = a; cout<< sizeof(a) << endl; // 12 字节 cout<< sizeof(p) << endl; // 4 字节 计算数组和指针的内存容量 void Func(char a[100]) { cout<< sizeof(a) << endl; // 4 字节而不是100 字节 } 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. ( ( a + b ) + abs( a – b ) ) / 2 冒泡排序算法的时间复杂度是什么? O(n^2) 什么函数不能声明为虚函数? 构造函数(Constructor) 变量在内存中存放的位置 全局变量 全局静态区 全局静态变量 全局静态区 全局常量 有初始化 代码区 无初始化 全局静态区 局部变量 堆栈区 局部静态变量 静态区 局部常量 堆栈区 new和malloc分配空间 堆区 进程间通信方式 管道(有名管道,无名管道),共享内存,消息队列,信号量,socket通信 线程同步方式 临界区:通过对多线程的串行化来访问公共资源或一段代码,速度快,适合控制数据访问 互斥量:为协调共同对一个共享资源的单独访问而设计 信号量(PV操作):为控制一个具有有限数量用户资源而设计 事件:用来通知线程有一些事件已 进程和线程的区别 资源:进程是拥有资源的一个独立单位,线程是不拥有资源。 调度:线程作为调度和分配的基本单位,进程是作为资源的基本单位 并发性:进程之间可以有并发性进行,同一个进程中的多个线程是可以并发执行 系统开销:进程在创建和撤销的时候,由于系统要分配和回收资源,导致系统的开销明显大于线程 一个进程可以拥有多个线程。 局部变量和全局变量能否重名 能,局部屏蔽全局。在C++里使用全局,需要使用”::”。在C语言里,extern 虚函数和纯虚函数的区别 虚函数必须实现,纯虚函数没有实现 虚函数在子类里可以不重载,但是纯虚函数必须在每一个子类里去实现 在动态内存分配的时候,析构函数必须是虚函数,但没有必要是纯虚函数 面向对象的三大特性(四大特性) 封装、继承、多态(抽象) 封装:把客观事物封装成抽象的类,并且类可以把自己的数据和方法只让可信的类或者对象操作,对不可信的进行信息隐藏 继承:子类可以拥有父类的属性和方法,但父类没有子类的属性和方法 多态:允许将子类类型的指针赋值给父类类型的指针 实现多态,有二种方式,覆盖,重载 覆盖,是指子类重新定义父类的虚函数的做法 重载,是指允许存在多个同名函数,而这些函数的参数表不同(或许参数个数不同,或许参数类型不同,或许两者都不同) vi编辑器打开时跳到指定的行 vi +5000 filename int型在Touble C里占多少个字节 2个字节 判断一个单链表是否有环 两个指针指向链表头,一个指针每次走一步,另一个指针每次走两步,若有一个指针先指向为NULL表示这个链表无环。若两个指针重合表示链表有环 刷新缓冲区方式? 换行刷新缓冲区 printf(“\n”); 使用函数刷新缓冲区 fflush(stdout); 程序结束刷新缓冲区 return 0; 类和对象的两个基本概念什么? 对象就是对客观事物在计算机中的抽象描述。 类就是对具体相似属性和行为的一组对象的统一描述。 类的包括:类说明和类实现两大部分: 类说明提供了对该类所有数据成员和成员函数的描述。 类实现提供了所有成员函数的实现代码。 数据库三范式 第一范式:没有重复的列 第二范式:非主属的部分依赖于主属部分 第三范式:属性部分不依赖于其他非主属部分 ASSERT( )是干什么用的 是在调试程序使用的一个宏,括号里面要满足,如果不满足,程序将报告错误,并将终止执行。 如果只想让程序有一个实例运行,不能运行两个。像winamp一样,只能开一个窗口,怎样实现? 用内存映射或全局原子(互斥变量)、查找窗口句柄 FindWindow,互斥,写标志到文件或注册表,共享内存 如何截取键盘的响应,让所有的’a’变成’b’? 键盘钩子SetWindowsHookEx 网络编程中设计并发服务器,使用多进程 与 多线程 ,请问有什么区别? 1.进程:子进程是父进程的复制品。子进程获得父进程数据空间、堆和栈的复制品。 2.线程:相对与进程而言,线程是一个更加接近与执行体的概念,它可以与同进程的其他线程共享数据,但拥有自己的栈空间,拥有独立的执行序列。 两者都可以提高程序的并发度,提高程序运行效率和响应时间。 线程和进程在使用上各有优缺点:线程执行开销小,但不利于资源管理和保护;而进程正相反。同时,线程适合于在SMP机器上运行,而进程则可以跨机器迁移。 编程 字符串实现 strcat char *strcat(char *strDes, const char *strSrc) { assert((strDes != NULL) && (strSrc != NULL)); char *address = strDes; while (*strDes != ‘\0′) ++ strDes; while ((*strDes ++ = *strSrc ++) != ‘\0′) NULL; return address; } strncat char *strncat(char *strDes, const char *strSrc, int count) { assert((strDes != NULL) && (strSrc != NULL)); char *address = strDes; while (*strDes != ‘\0′) ++ strDes; while (count — && *strSrc != ‘\0′ ) *strDes ++ = *strSrc ++; *strDes = ‘\0′; return address; } strcmp int strcmp(const char *s, const char *t) { assert(s != NULL && t != NULL); while (*s && *t && *s == *t) { ++ s; ++ t; } return (*s – *t); } strncmp int strncmp(const char *s, const char *t, int count) { assert((s != NULL) && (t != NULL)); while (*s && *t && *s == *t && count –) { ++ s; ++ t; } return (*s – *t); } strcpy char *strcpy(char *strDes, const char *strSrc) { assert((strDes != NULL) && (strSrc != NULL)); char *address = strDes; while ((*strDes ++ = *strSrc ++) != ‘\0′) NULL; return address; } strncpy char *strncpy(char *strDes, const char *strSrc, int count) { assert(strDes != NULL && strSrc != NULL); char *address = strDes; while (count — && *strSrc != ‘\0′) *strDes ++ = *strSrc ++; return address; } strlen int strlen(const char *str) { assert(str != NULL); int len = 0; while (*str ++ != ‘\0′) ++ len; return len; } strpbrk char *strpbrk(const char *strSrc, const char *str) { assert((strSrc != NULL) && (str != NULL)); const char *s; while (*strSrc != ‘\0′) { s = str; while (*s != ‘\0′) { if (*strSrc == *s) return (char *) strSrc; ++ s; } ++ strSrc; } return NULL; } strstr char *strstr(const char *strSrc, const char *str) { assert(strSrc != NULL && str != NULL); const char *s = strSrc; const char *t = str; for (; *t != ‘\0′; ++ strSrc) { for (s = strSrc, t = str; *t != ‘\0′ && *s == *t; ++s, ++t) NULL; if (*t == ‘\0′) return (char *) strSrc; } return NULL; } strcspn int strcspn(const char *strSrc, const char *str) { assert((strSrc != NULL) && (str != NULL)); const char *s; const char *t = strSrc; while (*t != ‘\0′) { s = str; while (*s != ‘\0′) { if (*t == *s) return t – strSrc; ++ s; } ++ t; } return 0; } strspn int strspn(const char *strSrc, const char *str) { assert((strSrc != NULL) && (str != NULL)); const char *s; const char *t = strSrc; while (*t != ‘\0′) { s = str; while (*s != ‘\0′) { if (*t == *s) break; ++ s; } if (*s == ‘\0′) return t – strSrc; ++ t; } return 0; } strrchr char *strrchr(const char *str, int c) { assert(str != NULL); const char *s = str; while (*s != ‘\0′) ++ s; for (– s; *s != (char) c; — s) if (s == str) return NULL; return (char *) s; } strrev char* strrev(char *str) { assert(str != NULL); char *s = str, *t = str, c; while (*t != ‘\0′) ++ t; for (– t; s < t; ++ s, — t) { c = *s; *s = *t; *t = c; } return str; } strnset char *strnset(char *str, int c, int count) { assert(str != NULL); char *s = str; for (; *s != ‘\0′ && s – str < count; ++ s) *s = (char) c; return str; } strset char *strset(char *str, int c) { assert(str != NULL); char *s = str; for (; *s != ‘\0′; ++ s) *s = (char) c; return str; } strtok char *strtok(char *strToken, const char *str) { assert(strToken != NULL && str != NULL); char *s = strToken; const char *t = str; while (*s != ‘\0′) { t = str; while (*t != ‘\0′) { if (*s == *t) { *(strToken + (s – strToken)) = ‘\0′; return strToken; } ++ t; } ++ s; } return NULL; } strupr char *strupr(char *str) { assert(str != NULL); char *s = str; while (*s != ‘\0′) { if (*s >= ‘a’ && *s <= ‘z’) *s -= 0×20; s ++; } return str; } strlwr char *strlwr(char *str) { assert(str != NULL); char *s = str; while (*s != ‘\0′) { if (*s >= ‘A’ && *s <= ‘Z’) *s += 0×20; s ++; } return str; } memcpy void *memcpy(void *dest, const void *src, int count) { assert((dest != NULL) && (src != NULL)); void *address = dest; while (count –) { *(char *) dest = *(char *) src; dest = (char *) dest + 1; src = (char *) src + 1; } return address; } memccpy void *memccpy(void *dest, const void *src, int c, unsigned int count) { assert((dest != NULL) && (src != NULL)); while (count –) { *(char *) dest = *(char *) src; if (* (char *) src == (char) c) return ((char *)dest + 1); dest = (char *) dest + 1; src = (char *) src + 1; } return NULL; } memchr void *memchr(const void *buf, int c, int count) { assert(buf != NULL); while (count –) { if (*(char *) buf == c) return (void *) buf; buf = (char *) buf + 1; } return NULL; } memcmp int memcmp(const void *s, const void *t, int count) { assert((s != NULL) && (t != NULL)); while (*(char *) s && *(char *) t && *(char *) s == *(char *) t && count –) { s = (char *) s + 1; t = (char *) t + 1; } return (*(char *) s – *(char *) t); } memmove void *memmove(void *dest, const void *src, int count) { assert(dest != NULL && src != NULL); void *address = dest; while (count –) { *(char *) dest = *(char *) src; dest = (char *) dest + 1; src = (const char *)src + 1; } return address; } memset void *memset(void *str, int c, int count) { assert(str != NULL); void *s = str; while (count –) { *(char *) s = (char) c; s = (char *) s + 1; } return str; } strdup char *strdup(const char *strSrc) { assert(strSrc != NULL); int len = 0; while (*strSrc ++ != ‘\0′) ++ len; char *strDes = (char *) malloc (len + 1); while ((*strDes ++ = *strSrc ++) != ‘\0′) NULL; return strDes; } strchr_ char *strchr_(char *str, int c) { assert(str != NULL); while ((*str != (char) c) && (*str != ‘\0′)) str ++; if (*str != ‘\0′) return str; return NULL; } strchr char *strchr(const char *str, int c) { assert(str != NULL); for (; *str != (char) c; ++ str) if (*str == ‘\0′) return NULL; return (char *) str; } atoi int atoi(const char* str) { int x=0; const char* p=str; if(*str==’-’||*str==’+’) { str++; } while(*str!=0) { if((*str>’9′)||(*str<’0′)) { break; } x=x*10+(*str-’0′); str++; } if(*p==’-’) { x=-x; } return x; } itoa char* itoa(int val,char* buf,unsigned int radix) { char *bufptr; char *firstdig; char temp; unsigned int digval; assert(buf != NULL); bufptr = buf; if (val < 0) { *bufptr++ = ‘-’; val = (unsigned int)(-(int)val); } firstdig = bufptr; do { digval =(unsigned int) val % radix; val /= radix; if (digval > 9) { *bufptr++ = (char)(digval – 10 + ‘a’); } else { *bufptr++ = (char)(digval + ’0′); } } while(val > 0); *bufptr– = ‘\0′;//设置字符串末尾,并将指针指向最后一个字符 do //反转字符 { temp = *bufptr; *bufptr = *firstdig; *firstdig = temp; –bufptr; ++firstdig; } while(firstdig < bufptr); return buf; } String实现 已知String原型为: class String { public: //普通构造函数 String(const char *str = NULL) //拷贝构造函数 String(const String &other) //析构函数 ~String(void); //赋值函数 String & operator=(String &other) //oh,原题目打错了,string可是一个关键字 private: char* m_str; unsigned m_uCount; }; 分别实现以上四个函数 //普通构造函数 String::String(const char* str) { if(str==NULL) //如果str为NULL,存空字符串 { m_str = new char[1]; //分配一个字节 *m_str = ‘\0′; //赋一个’\0′ }else { m_str = new char[strlen(str) + 1];//分配空间容纳str内容 strcpy(m_str, str); //复制str到私有成员m_str中 } } //析构函数 String::~String() { if(m_str!=NULL) //如果m_str不为NULL,释放堆内存 { delete [] m_str; m_str = NULL; } } //拷贝构造函数 String::String(const String &other) { m_str = new char[strlen(other.m_str)+1]; //分配空间容纳str内容 strcpy(m_str, other.m_str); //复制other.m_str到私有成员m_str中 } //赋值函数 String & String::operator=(String &other) { if(this == &other) //若对象与other是同一个对象,直接返回本身 { return *this } delete [] m_str; //否则,先释放当前对象堆内存 m_str = new char[strlen(other.m_str)+1]; //分配空间容纳str内容 strcpy(m_str, other.m_str); //复制other.m_str到私有成员m_str中 return *this; } 编写一个二分查找的功能函数 int BSearch(elemtype a[],elemtype x,int low,int high) /*在下届为low,上界为high的数组a中折半查找数据元素x*/ { int mid; if(low>high) return -1; mid=(low+high)/2; if(x==a[mid]) return mid; if(x<a[mid]) return(BSearch(a,x,low,mid-1)); else return(BSearch(a,x,mid+1,high)); } 2) 非递归方法实现: int BSearch(elemtype a[],keytype key,int n) { int low,high,mid; low=0;high=n-1; while(low<=high) { mid=(low+high)/2; if(a[mid].key==key) return mid; else if(a[mid].key<key) low=mid+1; else high=mid-1; } return -1; } 字符串逆序 方法一 #include <stdio.h> #include <string.h> void main() { char str[]=”hello,world”; int len=strlen(str); char t; int i; for(i=0; i<len/2; i++) { t=str[i]; str[i]=str[len-i-1]; str[len-i-1]=t; } printf(“%s\n”,str); return 0; } 方法二 #include <stdio.h> int main(){ char* src = “hello,world”; int len = strlen(src); char* dest = (char*)malloc(len+1);//要为\0分配一个空间 char* d = dest; char* s = &src[len-1];//指向最后一个字符 while( len– != 0 ) *d++=*s–; *d = 0;//尾部要加\0 printf(“%s\n”,dest); free(dest);// 使用完,应当释放空间,以免造成内存汇泄露 return 0; } 排序 冒泡排序 void bubble_sort(int a[],int n) { int i,j; for(i=0;i<n-1;i++) { bool x=ture; for(j=0;j<n-1-i;j++) { int temp; if(a[j]>a[j+1]) { temp=a[j]; a[j]=a[j+1]; a[j+1]=temp; x=false; } } if(x) break; } } 时间复杂度O(N^2) 选择排序 void select_sort(int a[],int n) { int i,j; for(i=0;i<n-1;i++) { int min=i; for(j=i+1;j<n;j++) { if(a[j]<a[min]) min=j; if(min!=i) { int temp=a[j]; a[j]=a[min]; a[min]=temp; } } } } 时间复杂度O(N^2) 插入排序 void insert_sort(int a[],int n) { int i,j; for(i=1;i<n;i++) { int x=a[i]; for(j=i;j>0&&x<a[j-1];j–) a[j]=a[j-1]; a[j]=x; } } 时间复杂度O(N^2) 快速排序 void quick_sort(int a[],int ileft,int iright) { int iPivot=(left+right)/2; int nPivot=a[iPivot]; for(int i=ileft,j=iright;i<j;) { while(!(i>=iPivot||nPivot<a[i])) i++; if(i<iPivot) { a[iPivot]=a[i]; iPivot=i; } while(!(j<=iPivot||nPivot>a[j])) j–; if(j>iPivot) { a[iPivot]=a[j]; iPivot=j; } } a[iPivot]=nPivot; if(iPivot-ileft>1) quick_sort(a,ileft,iPivot-1); if(iright-iPivot>1) quick_sort(a,iPivot+1,iright); } 时间复杂度O(NlogN) 链表 单链表 双链表 循环链表 单链表逆置 void reverse(link *head) { link *p, *s, *t; p = head; s = p->next; while(s->next!=NULL) { t = s->next; s->next = p; p = s; s = t; } s->next = p; head->next->next = NULL; //尾指针置为空 head->next = s; //赋值到头指针后一位 } 链表合并 Node * Merge(Node *head1 , Node *head2) { if ( head1 == NULL) return head2 ; if ( head2 == NULL) return head1 ; Node *head = NULL ; Node *p1 = NULL; Node *p2 = NULL; if ( head1->data < head2->data ) { head = head1 ; p1 = head1->next; p2 = head2 ; }else { head = head2 ; p2 = head2->next ; p1 = head1 ; } Node *pcurrent = head ; while ( p1 != NULL && p2 != NULL) { if ( p1->data <= p2->data ) { pcurrent->next = p1 ; pcurrent = p1 ; p1 = p1->next ; }else { pcurrent->next = p2 ; pcurrent = p2 ; p2 = p2->next ; } } if ( p1 != NULL ) pcurrent->next = p1 ; if ( p2 != NULL ) pcurrent->next = p2 ; return head ; } 递归方式: Node * MergeRecursive(Node *head1 , Node *head2) { if ( head1 == NULL ) return head2 ; if ( head2 == NULL) return head1 ; Node *head = NULL ; if ( head1->data < head2->data ) { head = head1 ; head->next = MergeRecursive(head1->next,head2); } else { head = head2 ; head->next = MergeRecursive(head1,head2->next); } return head ; } 写一个Singleton模式 #include<iostream> using namespace std; class Singleton { private: static Singleton* _instance; protected: Singleton() { cout<<”Singleton”<<endl; } public: static Singleton* Instance() { if(NULL==_instance) { _instance=new Singleton(); } return _instance; } }; static Singleton* Singleton::_instance=NULL; int main() { Singleton * s =Singleton::Instance(); Singleton * s1=Singleton::Instance(); } 如何对String类型数据的某个字符进行访问? #include<iostream> using namespace std; int main() { string s=”abcdefg”; const char *c=s.c_str(); while(*c!=’\0′) { printf(“%c”,*c++); } } 文件加密、解密 1.加密(encryption): #include<stdio.h> void encryption(char *ch) { (*ch)^=0xFF; //算法可自行修改调整,使用AES加密算法 } int main(int argc,char *argv[]) { if(argc<2) { printf(“参数不足”); return -1; } //文件的打开(fopen函数) /* r read 只读 w write 只写 a append 追加 t text 文本文件,可省略不写 b banary 二进制文件 + 读和写 */ a.out a.c b.txt argv[0] argv[1] argv[2] FILE* fpr=NULL; FILE* fpw=NULL; //文件打开失败返回一个空指针值NULL if(NULL==(fpr=fopen(argv[1],”r”))){printf(“%m\n”);return -1;} if(NULL==(fpw=fopen(argv[2],”w+”))){printf(“%m\n”);return -1;} char ch; while((ch=fgetc(fpr))!=EOF) { //putchar(ch); encryption(&ch);//加密函数 printf(“%c”,ch);//加密后字符显示 fputc(ch,fpw);//存放进文件 } printf(“\n文件加密成功!\n”); //文件的关闭(fclose函数) fclose(fpr); fclose(fpw); } 2.解密(decryption): #include<stdio.h> #include<time.h> void show() { time_t start=time(NULL); while(start==time(NULL)); } void decryption(char ch) { (*ch)^=0xFF;//算法可自行修改调整 } int main(int argc,char *argv[]) { if(argc<2) { printf(“参数不足”); return -1; } //文件的打开(fopen函数) /* r read 只读 w write 只写 a append 追加 t text 文本文件,可省略不写 b banary 二进制文件 + 读和写 */ FILE* fpr=NULL; FILE* fpw=NULL; //文件打开失败返回一个空指针值NULL if(NULL==(fpr=fopen(argv[1],”r”))){printf(“%m\n”);return -1;} if(NULL==(fpw=fopen(argv[2],”w+”))){printf(“%m\n”);return -1;} char ch; printf(“开始解密!\n”); while((ch=fgetc(fpr))!=EOF) { show(); ch=decryption(ch);//解密函数 printf(“%c”,ch);//解密后字符显示 fputc(ch,fpw);//存放进文件 fflush(stdout);//刷新显示 } printf(“\n文件解密成功!\n”); //文件的关闭(fclose函数) fclose(fpr); fclose(fpw); } 斐波那契数列(Fibonacci sequence) int Funct( int n ) { if( n==0 || n==1 ) return 1; retrurn Funct(n-1) + Funct(n-2); }