1.编写my_strcpy函数，实现与库函数strcpy类似的功能，不能使用任何库函数；

答：char *strcpy(char *strDest, const char *strSrc)

{

if ( strDest == NULL || strSrc == NULL)

return NULL ;

if ( strDest == strSrc)

returnstrDest ;

char *tempptr = strDest ;

while( (*strDest++ = *strSrc++) != ‘’);

returntempptr ;

}

2. 头文件中的ifndef/define/endif的作用？

答：防止该头文件被重复引用。

3. ＃i nclude与＃i nclude “file.h”的区别？

答：前者编译器从标准库路径开始搜索file.h，而后者编译器从用户的工作路径开始搜索file.h。

4. 在C++ 程序中调用被C 编译器编译后的函数，为什么要加extern“C”？

答：extern是C/C++语言中表明函数和全局变量作用范围（可见性）的关键字，其声明的函数和变量可以在本模块或其它模块中使用。

通常，在模块的头文件中对本模块提供给其它模块引用的函数和全局变量以关键字extern声明。

5. 面向对象的三个基本特征，并简单叙述之？

答：1）封装：将客观事物抽象成类，每个类对自身的数据和方法实行protection(private, protected,public)

2）继承：实现继承（指使用基类的属性和方法而无需额外编码的能力）、可视继承（子窗体使用父窗体的外观和实现代码）、接口继承（仅使用属性和方法，实现滞后到子类实现）。

3）多态：允许将子类类型的指针赋值给父类类型的指针。

6. 重载（overload)和重写(overried，有的书也叫做“覆盖”）的区别？

答：从定义上来说：

重载：是指允许存在多个同名函数，而这些函数的参数表不同（或许参数个数不同，或许参数类型不同，或许两者都不同）。

重写：是指子类重新定义复类虚函数的方法。

从实现原理上来说：

重载：编译器根据函数不同的参数表，对同名函数的名称做修饰，然后这些同名函数就成了不同的函数。

重写：当子类重新定义了父类的虚函数后，父类指针根据赋给它的不同的子类指针，动态的调用属于子类的该函数，这样的函数调用在编译期间是无法确定的（调用的子类的虚函数的地址无法给出）。

7. 多态的作用？

答：主要是两个：1）隐藏实现细节，使得代码能够模块化；扩展代码模块，实现代码重用；2）接口重用，为了类在继承和派生的时候，保证使用家族中任一类的实例的某一属性时的正确调用。

8. 分别写出BOOL,int,float,指针类型的变量a 与“零”的比较语句。

答：BOOL :if ( !a ) or if(a)

int :if ( a ==0)

float :const EXPRESSION EXP = 0.000001

if ( a < EXP && a >-EXP)

pointer : if ( a != NULL) or if(a == NULL)

9. 请说出const与#define 相比，有何优点？

答案：1） const 常量有数据类型，而宏常量没有数据类型。编译器可以对前者进行类型安全检查。而对后者只进行字符替换，没有类型安全检查，并且在字符替换可能会产生意料不到的错误。

2） 有些集成化的调试工具可以对const 常量进行调试，但是不能对宏常量进行调试。

10.简述数组与指针的区别？

数组要么在静态存储区被创建（如全局数组），要么在栈上被创建。指针可以随时指向任意类型的内存块。

(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< cout< 计算数组和指针的内存容量

voidFunc(char a[100])

{

cout< }

11.变量的声明和定义有什么区别？

答：声明变量不分配空间，定义变量要分配空间。声明主要是告诉编译器,后面的引用都按声明的格式。定义其实包含了声明的意思,同时要分配内存空间。

12. 解释堆和栈的区别。

答：堆（heap）——一般由程序员分配释放，若程序员不释放，程序结束时可能由OS回收。注意它与数据结构中的堆是两回事，分配方式倒是类似于链表。速度比较慢，而且容易产生内存碎片,不过用起来最方便。

栈（stack）——由编译器自动分配释放，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中的栈。由系统自动分配，速度较快。但程序员是无法控制的。

13. const的作用是什么?

答：（1）可以定义const常量

（2）const可以修饰函数的参数、返回值，甚至函数的定义体。被const修饰的东西都受到强制保护，可以预防意外的变动，能提高程序的健壮性。

14. 下列哪两个是等同的

int b;

A constint* a = &b; //指向常量的指针，不能通过指针改变b，但指针的地址可以改变。

B const* int a = &b;// 指针的地址不可以改变，但可以通过指针改变b的值

C constint* const a = &b; //指针指向的值，和指针本身的地址都不能改变

D intconst* const a = &b;//与c相同

15. 完成程序，实现对数组的降序排序

#include

void sort(int array[] );

int main()

{

int array[]={45，56，76，234，1，34，23，2，3}； //数字任//意给出

sort( array );

return 0;

}

void sort( int array[] )

{____________________________________

inti,j,k;

for(i=1;i<=7;i++) { if(array[i]>array[i-1])

{

k=ARRAY[i];

j=i-1;

do

{

array[j+1]=array[j];

j– ;

}

while(k>array[j]&&j>=0);

array[j+1]=k;

}

}

—————————————————–

}

16. int i=(j=4,k=8,l=16,m=32); printf(“%d”, i); 输出是多少？

答：相当于 i=j=4；i=k=8；i=l=16；i=m=32; 故最后i=32；

17. 请简述以下两个for循环的优缺点（5分）

1）for (i=0; i {

if (condition)

DoSomething();

else

DoOtherthing();

}

2）if (condition)

{

for (i=0; i DoSomething();

}

else

{

for (i=0; i 0)

{

*psTo++ = *psFrom++;

}

returnpvTo;

}

19. .C++里面如何声明const void f(void)函数为C程序中的库函数？

答：在该函数前添加extern “C”声明。由于编译后的名字不同，C++程序不能直接调用C 函数。

20. 请写出下面代码在 32 位平台上的运行结果，并说明sizeof的性质：

#include

#include

int main(void)

{

char a[30];

char *b = (char *)malloc(20 * sizeof(char));

printf(“%d\n”, sizeof(a));

printf(“%d\n”, sizeof(b));

printf(“%d\n”, sizeof(a[3]));

printf(“%d\n”, sizeof(b+3));

printf(“%d\n”, sizeof(*(b+4)));

return 0 ;

}

答：在32位系统下（如WIN32），指针长度为32位。a是一个有30个元素的字符型数组；b是一个字符串指针；a[3]是字符型；b+3是指针；*(b+4)是字符型。

因此输出： 30、4、1、4、1

21. C++中，关键字struct和class的区别仅仅在于：

struct定义的类的缺省成员为公有的，而class定义的类的缺省成员为私有的;

22. 头文件的作用是什么?

答：1）通过头文件来调用库功能。2）头文件能加强类型安全检查。

23. C++函数中值的传递方式有哪几种?

答：C++函数的三种传递方式为：值传递、指针传递和引用传递。

24. 内存的分配方式的分配方式有几种?

答：1）从静态存储区域分配。内存在程序编译的时候就已经分配好，这块内存在程序的整个运行期间都存在。例如全局变量。

2）在栈上创建。在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。

3）从堆上分配，亦称动态内存分配。程序在运行的时候用malloc或new申请任意多少的内存，程序员自己负责在何时用free或delete释放内存。动态内存的生存期由我们决定，使用非常灵活，但问题也最多。

25. 设计函数intatoi(char *s)。

答：intatoi (char *s)

{

int i = 0,sum = 0,sign; //输入的数前面可能还有空格或制表符应加判断

while(*s==”||*s==’\t’)

{

i++;

}

sign = (*s==’-')?-1:1;

if(*s==’-'|| *s==’+')

{

i++;

}

while(*s!=’\0′)

{

sum = *s-’0′+sum*10;

i++;

}

return sign*sum;

}

26. 编写strcat函数(6分)

已知strcat函数的原型是char *strcat (char *strDest, const char *strSrc);

其中strDest是目的字符串，strSrc是源字符串。

（1）不调用C++/C 的字符串库函数，请编写函数strcat

答：

char * __cdeclstrcat(char * dst, const char * src)

{

char * cp = dst;

while( *cp )

cp++; /* find end of dst */

while( *cp++ = *src++ ) ; /* Copy src to end of dst */

return(dst ); /* return dst */

}

（2）strcat能把strSrc的内容连接到strDest，为什么还要char * 类型的返回值？

答：方便赋值给其他变量。

27. MFC中CString是类型安全类么？

答：不是，其它数据类型转换到CString可以使用CString的成员函数Format来转换

28.函数模板与类模板有什么区别？

答：函数模板的实例化是由编译程序在处理函数调用时自动完成的，而类模板的实例化必须由程序员在程序中显式地指定。

29. 写一个“标准”宏MIN，这个宏输入两个参数并返回较小的一个。

答：#define MIN(A,B) ((A) <= (B) ? (A) : (B)) 宏的副作用（与某些函数的混淆）：least = MIN(*p++, b)。宏定义#define MIN(A,B) ((A) <= (B) ? (A) : (B))对MIN(*p++, b)的作用结果是：

((*p++) <= (b) ? (*p++) : (*p++))

30. 嵌入式系统中经常要用到无限循环，你怎么样用C编写死循环呢？

答：while(1){}或者for(;;)

31. 用变量a给出下面的定义

a) 一个整型数（An integer）

b) 一个指向整型数的指针（A pointer to an integer）

c) 一个指向指针的的指针，它指向的指针是指向一个整型数（A pointer to a pointer to an integer）

d) 一个有10个整型数的数组（An array of 10 integers）

e) 一个有10个指针的数组，该指针是指向一个整型数的（An array of 10 pointers to integers）

f) 一个指向有10个整型数数组的指针（A pointer to an array of 10 integers）

g) 一个指向函数的指针，该函数有一个整型参数并返回一个整型数（A pointer to a function that takes an integer as an argument and returns an integer）

h) 一个有10个指针的数组，该指针指向一个函数，该函数有一个整型参数并返回一个整型数（ An array of ten pointers to functions that take an integer argument and return an integer ）

答案是：

a) int a; // An integer

b) int *a; // A pointer to an integer

c) int **a; // A pointer to a pointer to an integer

d) int a[10]; // An array of 10 integers

e) int *a[10]; // An array of 10 pointers to integers

f) int (*a)[10]; // A pointer to an array of 10 integers

g) int (*a)(int); // A pointer to a function a that takes an integer argument and returns an integer

h) int (*a[10])(int); // An array of 10 pointers to functions that take an integer argument and return an integer

32. 1）关键字static的作用是什么？答：（1）用于全局变量；（2）用于局部变量；（3）用于函数。

2）关键字const有什么含意？答：表示常量不可以修改的变量。

33. 如何判断一段程序是由C 编译程序还是由C++编译程序编译的？

答案：#ifdef __cplusplus

cout<<"c++";

#else

cout<<"c";

#endif

34. 数组a[N]，存放了1至N-1个数，其中某个数重复一次。写一个函数，找出被重复的数字.时间复杂度必须为o（N）函数原型：intdo_dup(int a[],int N)

答案：如果数就是1－N-1,那么求出a[N]的和，然后减去1－N-1就行了。(确定数字1-N)

S = N * (N-1) / 2;

int i;

int s = 0;

for(i=0;i {

s += a[i];

}

int res = s – S;

35. 程序由多个模块组成，所有模块都使用一组标准的包含文件和相同的编译选项。在这种情况下，可以将所有包含文件预编译为一个预编译头。

char * const p;

charconst * p

const char *p

上述三个有什么区别？

答：char * const p; //常量指针，p的值不可以修改

char const * p；//指向常量的指针，指向的常量值不可以改

const char *p； //和char const *p

36. 有1,2,….一直到n的无序数组,求排序算法,并且要求时间复杂度为O(n),空间复杂度O(1),使用交换,而且一次只能交换两个数。

#include

int main()

{

int a[] = {10,6,9,5,2,8,4,7,1,3};

intlen = sizeof(a) / sizeof(int);

int temp;

for(int i = 0; i {

temp = a[a[i] – 1];

a[a[i] – 1] = a[i];

a[i] = temp;

if ( a[i] == i + 1)

i++;

}

for (int j = 0; j cout< return 0;

}

37. 写一个函数比较两个字符串str1和str2的大小，若相等返回0，若str1大于str2返回1，若str1小于str2返回－1

intstrcmp ( const char * src,const char * dst)

{

int ret = 0 ;

while( ! (ret = *(unsigned char *)src – *(unsigned char *)dst) && *dst)//字符之差为整型

{

++src;

++dst;

}

if ( ret < 0 ) ret = -1 ; else if ( ret > 0 )

ret = 1 ;

return( ret );

}

38. 用预处理指令#define 声明一个常数，用以表明1年中有多少秒（忽略闰年问题）

答： #define SECONDS_PER_YEAR (60 * 60 * 24 * 365)UL

39.Typedef在C语言中频繁用以声明一个已经存在的数据类型的同义字。也可以用预处理器做类似的事。例如，思考一下下面的例子：

#definedPSstruct s *

typedefstruct s * tPS;

以上两种情况的意图都是要定义dPS和tPS作为一个指向结构s指针。哪种方法更好呢？（如果有的话）为什么？

答：typedef更好。思考下面的例子：

dPS p1,p2;tPS p3,p4;

第一个扩展为：struct s * p1, p2;

上面的代码定义p1为一个指向结构的指，p2为一个实际的结构，这也许不是你想要的。第二个例子正确地定义了p3 和p4 两个指针。

40. C语言同意一些令人震惊的结构,下面的结构是合法的吗，如果是它做些什么？

int a = 5, b = 7, c;

c = a+++b;

答：上面的代码被处理成：c = a++ + b;因此, 这段代码持行后a = 6, b = 7, c = 12。

41. char* ss = “0123456789″;

sizeof(ss) 结果 4 //ss是指向字符串常量的字符指针

sizeof(*ss) 结果 1 //*ss是第一个字符

char ss[] = “0123456789″;

sizeof(ss) 结果 11 //ss是数组，计算到\0位置，因此是10＋1

sizeof(*ss) 结果 1 //*ss是第一个字符

char ss[100] = “0123456789″;

sizeof(ss) 结果是100 //ss表示在内存中的大小 100×1

intss[100] = “0123456789″;

sizeof(ss) 结果 400 //ss表示再内存中的大小 100×4

char q[]=”abc”;

char p[]=”a\n”;

sizeof(q),sizeof(p),strlen(q),strlen(p); 结果是 4 3 3 2

42.冒泡法：//从小到大排序，比较n次，每次拿一个从头比到尾

void bubble_sort(int array[],int n)

{

inti,j,temp;

for(i = 0; i < n-1; i++)

{

for(j = 0; j < n-1-i; j++) { if(array[j] > array[j+1])

{ temp = array[j]; array[j] = array[j+1]; array[j+1] = temp; }

}

printf(“%d “, array[j]);

}

return;

}

选择排序法：

main()

{

int a[10];

inti,j,t,k;

for ( i = 0; i < 10; i ++ )

scanf(“%d”,&a[ i ]); //输入10个数

for ( i = 0; i < 9; i ++ )

{

k = i;

for ( j = i + 1; j < 10; j ++) if ( a[ k ] > a[ j ] )

k = j; //前进

if （k！=i）

{ t = a[ i ]; a[ i ] = a[ k ]; a[ k ] = t; }/* t 发放奖品*/

}

for( i = 9; i >= 0; i –)

printf(“%4d”,a[ i ]); /*显示排序后的结果*/

}

发现有个学习的网址我觉得可以学习编程网站，资料免费分享！

网址：;tdsourcetag=s_pcqq_aiomsg

复制网址打开游览器搜索一下吧