刚才把最后的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(cout," "));
cout< 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
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
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
详情见凝视
总算完了。
。
。。继续调摄像头去了。。。。