刚才把最后的10道题又看了下，也发上来吧。
下面给出试题，和我对题目的一些理解
前10道题地址
(各个公司面试原题)在线做了一套CC++综合测试题，也来测一下你的水平吧(一)
11.设已经有A,B,C,D4个类的定义，程序中A,B,C,D析构函数调用顺序为？
C c;
void main()
{
A*pa=new A();
B b;
static D d;
delete pa;
}
A. A B C D
B. A B D C
C. A C D B
D. A C B D
答案：B
c是全局变量，a、b是局部变量，d是静态的局部变量
先构造的后析构，静态的局部变量d在main函数结束时析构，全局变量c在程序结束时析构。
语句
delete pa;
使得a先于b析构
附图
12.
若char是一字节，int是4字节，指针类型是4字节，代码如下：
class CTest
{
public:
CTest():m_chData(‘\0’),m_nData(0)
{
}
virtual void mem_fun(){}
private:
char m_chData;
int m_nData;
static char s_chData;
};
char CTest::s_chData=’\0’;
问：
（1）若按4字节对齐sizeof(CTest)的值是多少？
（2）若按1字节对齐sizeof(CTest)的值是多少？
请选择正确的答案。
A. 16 4
B. 16 10
C. 12 9
D. 10 10
答案：C
首先，分析类 CTest中占存储空间的变量和函数
变量：char型变量占1个字节，int型变量占4个字节，sizeof(CTest)所求得的长度不包含static变量的字节数
函数：类的普通函数在实例化时才分配内存空间，虚函数(不论多少个)则维护一个指针指向的虚函数表，指针占4个字节
所以，
若4字节对齐，则 4(int)+4(长度为1字节的char)+4(指向虚函数表的指针)=12
若1字节对齐，则 4(int)+1(长度为1字节的char)+4(指向虚函数表的指针)=9
13.
在Java中，以下关于方法重载和方法重写描述正确的是？
A. 方法重载和方法的重写实现的功能相同
B. 方法重载出现在父子关系中，方法重写是在同一类中
C. 方法重载的返回值类型必须一致，参数项必须不同
D. 方法重写的返回值类型必须相同。（或是其子类）
答案：D
这题的关键是分清方法重载和方法重写的概念。
要注意的是，可重载的方法，需要以下条件
1.方法名相同
2.方法参数个数不同 || 方法参数个数相同但至少有一对对应参数的类型不同
3.与返回值无关
而可重写的方法都是继承过来的，为维护一致性，返回值类型必然需要相同
14.
下列给定程序中，函数fun的功能是:求ss所指字符串数组中长度最短的字符串所在的行下标，作为函数值返回，并把其串长放在形参n所指的变量中。ss所指字符串数数组中共有M个字符串，且串长小于N。
请在程序的下画线处填入正确的内容并将下画线删除，使程序得出正确的结果。
试题程序。
#define M 5
#define N 20
int fun(char(* ss)[N], int *n)
{
int i, k = 0, len = N;
for (i = 0; i < ______; i++)
{
len = strlen(ss[i]);
if (i == 0)
*n = len;
if (len ____ * n);
{
*n = len;
k = i;
}
}
return ( _____ );
}
main( )
{
char ss[M][N] = {"shanghai", "guangzhou", "beijing", "tianjing", "chongqing"};
int n, k, i;
printf("\nThe originalb stringsare:\n");
for (i = 0; i < M; i++)
puts(ss[i]);
k = fun(ss, &n);
printf("\nThe length of shortest string is: % d\n", n);
printf("\nThe shortest string is: % s\n", ss[k]);
}
A. N < k
B. N > k
C. M < k
D. M > k
答案：C
感觉比较水的一道题。。。。分析下代码就OK了
15.
写出下面程序的输出结果
class A
{
public:
void FuncA()
{
printf( "FuncA called\n" );
}
virtual void FuncB()
{
printf( "FuncB called\n" );
}
};
class B : public A
{
public:
void FuncA()
{
A::FuncA();
printf( "FuncAB called\n" );
}
virtual void FuncB()
{
printf( "FuncBB called\n" );
}
};
void main( void )
{
B b;
A *pa;
pa = &b;//pa为一个指向a对象的指针，这里，将其绑定在对象b上
A *pa2 = new A;//pa2为一个指向a对象的指针
pa->FuncA();//FuncA为普通函数，这里调用A类的FuncA函数
pa->FuncB();//FuncB为虚函数，根据继承性原理，子类有的调用子类，子类没有的，调用父类，这里，调用B类的FuncB函数
pa2->FuncA(); //这里调用A类的FuncA函数
pa2->FuncB();//因为pa2是一个指向A类的指针，所以，在A类中寻找FuncB函数，这里，调用A类的FuncB函数
delete pa2;
}
A. FuncA called FuncB called FuncA calledFuncB called
B. FuncA called FuncBB called FuncA calledFuncB called
C. FuncA called FuncBB called FuncAB calledFuncBB called
D. FuncAB called FuncBB called FuncA calledFuncB called
答案：B
详情见注释
16.
In the main() function,after ModifyString(text) is called, what’s the value of ‘text’?
int FindSubString( char* pch )
//这个函数是用来搜索回文字符串的，并且回文字符串的左右边上的字符要比回文串的开头结尾要大，
//比如BCDCB不行，但ABA可以
{
int count = 0;
char * p1 = pch;//注意，指针pch在函数FindSubString中并未改变指向
while ( *p1 != '\0' )
{
if ( *p1 == p1[1] - 1 )
{
p1++;
count++;
}
else
{
break;
}
}
int count2 = count;
while ( *p1 != '\0' )
{
if ( *p1 == p1[1] + 1 )
{
p1++;
count2--;
}
else
{
break;
}
}
if ( count2 == 0 )
return(count);
return(0);
}
void ModifyString( char* pText )
{
char * p1 = pText;
char * p2 = p1;
while ( *p1 != '\0' )
{
int count = FindSubString( p1 );//count为要跳过的字符数
if ( count > 0 )
{
*p2++ = *p1;
sprintf( p2, "%i", count );//把跳过的字符数量count覆盖在*p1+1的位置
while ( *p2 != '\0' )//这个while循环很重要，应该是，只有*p2指向'\0'时，缓冲放在缓冲区的count才会真的覆盖text串的值
{
p2++;
}
p1 += count + count + 1;//p1跳过回文字符串
}
else
{
*p2++ = *p1++;
}
}
}
void main( void )
{
char text[32] = "XYBCDCBABABA";
ModifyString( text );
printf( text );
}
A. XYBCDCBABABA
B. XYBCBCDAIBAA
C. XYBCDCBAIBAA
D. XYBCDDBAIBAB
答案：C
看注释吧，有些地方我也不太明白，就把看懂的注释了。
17.
下面程序的功能是输出数组的全排列。请填空。
void perm(int list[], int k, int m)
{
if ( )
{
copy(list,list+m,ostream_iterator<int>(cout," "));
cout<<endl;
return;
}
for (int i=k; i<=m; i++)
{
swap(&list[k],&list[i]);
( );
swap(&list[k],&list[i]);
}
}
A. k!=m和perm（list，k+1，m）
B. k==m和perm（list，k+1，m）
C. k!=m和perm（list，k，m）
D. k==m和perm（list，k，m）
答案：B
好吧(∩_∩)，是不是ACM时代见过？字符串全排列，用的是DFS
可参见NYOJ 32 组合数
18.
写出下列程序的运行结果。
#include "stdio.h"
int sum(int a)
{
auto int c = 0;
static int b = 3;
c += 1;
b += 2;
return (a + b + c);
}
int main()
{
int i;
int a = 2;
for (i = 0; i < 5; i++)
{
printf("%d,", sum(a));
}
}
A. 6，8，10，12，14，
B. 8，10，12，14，16，
C. 10，12，14，16，18
D. 12，14，16，18，20
答案：B
又道水题。。。static类型的变量初始化一次，存在于整个函数生存期
19.
#include<iostream>
using namespace std;
class MyClass
{
public:
MyClass(int i = 0)
{
cout << i;
}
MyClass(const MyClass &x)
{
cout << 2;
}
MyClass &operator=(const MyClass &x)
{
cout << 3;
return *this;
}
~MyClass()
{
cout << 4;
}
};
int main()
{
MyClass obj1(1), obj2(2);
MyClass obj3 = obj1;
return 0;
}
运行时的输出结果是（）
A. 11214444
B. 11314444
C. 122444
D. 123444
答案：C
主要是选C和选D的讨论，这涉及到浅复制和深复制
MyClass obj3= obj1;
这里进行的是浅复制，调用的是copy construction函数
若上边那行代码是如下形式
MyClass obj3; obj3= obj1;
则进行的是深复制，调用的是assignment operators函数
20.
如下代码输出结果是什么？
#include<stdio.h>
char *myString()
{
char buffer[6] = {0};//存放在栈上，在函数末尾将释放
char *s = "Hello World!";
for (int i = 0; i < sizeof(buffer) - 1; i++)
{
buffer[i] = *(s + i);
}
return buffer;//buffer的内存将释放，从而*buffer变成一个野指针
}
int main(int argc, char **argv)
{
printf("%s\n", myString());
return 0;
}
A. Hello
B. Hello World!
C. Well
D. 以上全部不正确
答案：D
详情见注释
总算完了。。。。继续调摄像头去了。。。。