C++经典口试题

副标题#e#

1.是不是一个父类写了一个virtual 函数，假如子类包围它的函数不加virtual ,也能实现多态?

virtual修饰符会被隐形担任的。

private 也被集成，只事派生类没有会见权限罢了

virtual可加可不加

子类的空间里有父类的所有变量(static除外)

同一个函数只存在一个实体(inline除外)

子类包围它的函数不加virtual ,也能实现多态。

在子类的空间里，有父类的私有变量。私有变量不能直接会见。

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

2.输入一个字符串，将其逆序后输出。（利用C++，不发起用伪码）

#include <iostream>
using namespace std;
void main()
{
　char a[50];memset(a,0,sizeof(a));
　int i=0,j;
　char t;
　cin.getline(a,50,'n');
　for(i=0,j=strlen(a)-1;i<strlen(a)/2;i++,j--)
　{
　 t=a[i];
　　　a[i]=a[j];
　 a[j]=t;
　}
　cout<<a<<endl;
}

//第二种

string str;
cin>>str;
str.replace;
cout<<str;

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

#p#副标题#e#

3.请简朴描写Windows内存打点的要领。

内存打点是操纵系统中的重要部门，两三句话恐怕谁也说不清楚吧～～

我先说个或许，但愿可以或许抛砖引玉吧

当 措施运行时需要从内存中读出这段措施的代码。代码的位置必需在物理内存中才气被运行，由于此刻的操纵系统中有很是多的措施运行着，内存中不可以或许完全放下， 所以引出了虚拟内存的观念。把哪些不常用的措施片段就放入虚拟内存，当需要用到它的时候在load入主存（物理内存）中。这个就是内存打点所要做的事。内 存打点尚有别的一件事需要做：计较措施片断在主存中的物理位置，以便CPU调治。

内存打点有块式打点，页式打点，段式和段页式打点。此刻常用段页式打点

块式打点：把主存分为一大块、一大块的，当所需的措施片段不在主存时就分派一块主存空间，把程 序片段load入主存，就算所需的措施片度只有几个字节也只能把这一块分派给它。这样会造成很大的挥霍，平均挥霍了50％的内存空间，但时易于打点。

页式打点：把主存分为一页一页的，每一页的空间要比一块一块的空间小许多，显然这种要领的空间操作率要比块式打点高许多。

段式打点：把主存分为一段一段的，每一段的空间又要比一页一页的空间小许多，这种要领在空间操作率上又比页式打点高许多，可是也有别的一个缺点。一个措施片段大概会被分为几十段，这样许多时间就会被挥霍在计较每一段的物理地点上（计较机最耗时间的各人都知道是I/O吧）。

段页式打点：团结了段式打点和页式打点的利益。把主存分为若干页，每一页又分为若干段。长处就很明明，不消我多说了吧。

各类内存打点都有它本身的要领来计较出措施片段在主存中的物理地点，其实都很相似。

这只是一个或许罢了，不敷以说明内存打点的皮毛。无论哪一本操纵系统书上都有具体的讲授

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

4.

#include "stdafx.h"
#define SQR(X) X*X
int main(int argc, char* argv[])
{
int a = 10;
int k = 2;
int m = 1;
a /= SQR(k+m)/SQR(k+m);
printf("%dn",a);
return 0;
}这道题目标功效是什么啊?

define 只是界说罢了，在编择时只是简朴代换X*X罢了，并不颠末算术法例的

a /= (k+m)*(k+m)/(k+m)*(k+m);
=>a /= (k+m)*1*(k+m);
=>a = a/9;
=>a = 1;

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

#p#副标题#e#

5.const 标记常量；

(1)const char *p

(2)char const *p

(3)char * const p

说明上面三种描写的区别；

假如const位于星号的左侧，则const就是用来修饰指针所指向的变量，即指针指向为常量；

假如const位于星号的右侧，const就是修饰指针自己，即指针自己是常量。

(1)const char *p

一个指向char范例的const工具指针，p不是常量,我们可以修改p的值，使其指向差异的char，可是不能改变它指向非char工具，如：
const char *p;
char c1='a';
char c2='b';
p=&c1;//ok
p=&c2;//ok
*p=c1;//error

(2)char const *p

(3)char * const p

这两个好象是一样的，此时*p可以修改，而p不能修改。

(4)const char * const p

这种是地点及指向工具都不能修改。

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

6.下面是C语言中两种if语句判定方法。请问哪种写法更好？为什么？

int n;

if (n == 10) // 第一种判定方法

if (10 == n) // 第二种判定方法

假如少了个=号,编译时就会报错,淘汰了堕落的大概行,可以检测出是否少了=

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

#p#副标题#e#

7.下面的代码有什么问题？

#p#分页标题#e#

void DoSomeThing(...)
{
char* p;
...
p = malloc(1024);　// 分派1K的空间
if (NULL == p)
　return;
...
p = realloc(p, 2048); // 空间不足，从头分派到2K
if (NULL == p)
　return;
...
}

A:

p = malloc(1024);　　 应该写成： p = (char *) malloc(1024);

没有释放p的空间，造成内存泄漏。

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

8.下面的代码有什么问题？并请给出正确的写法。

void DoSomeThing(char* p)
{
char str[16];
int n;
assert(NULL != p);
sscanf(p, "%s%d", str, n);
if (0 == strcmp(str, "something"))
{
　...
}
}

A:

sscanf(p, "%s%d", str, n);　 这句该写成： sscanf(p, "%s%d", str, &n);

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

9.下面代码有什么错误?

Void test1()
{
char string[10];
char *str1="0123456789";
strcpy(string, str1);
}

数组越界

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

#p#副标题#e#

10.下面代码有什么问题?

Void test2()
{
　char string[10], str1[10];
　for(i=0; i<10;i++)
　{
　　 str1[i] ='a';
　}
　strcpy(string, str1);
}

数组越界

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

11.下面代码有什么问题?

Void test3(char* str1)
{
　char string[10];
　if(strlen(str1)<=10)
　{
　　strcpy(string, str1);
　}
}

==数组越界

==strcpy拷贝的竣事符号是查找字符串中的 因此假如字符串中没有碰着的话 会一直复制，直到碰着,上面的123都因此发生越界的环境

发起利用 strncpy 和 memcpy

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

12.下面代码有什么问题?

#define MAX_SRM 256
DSN get_SRM_no()
{
　static int SRM_no; //是不是这里没赋初值？
　int I;
　for(I=0;I<MAX_SRM;I++,SRM_no++)
　{
　　SRM_no %= MAX_SRM;
　　if(MY_SRM.state==IDLE)
　　{
　　　break;
　　}
　}
　if(I>=MAX_SRM)
　　return (NULL_SRM);
　else
　　return SRM_no;
}

系统会初始化static int变量为0,但该值会一直生存,所谓的不行重入…

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

#p#副标题#e#

13.写出运行功效:

{// test1
　　char str[] = "world"; cout << sizeof(str) << ": ";
　　char *p　　= str;　　 cout << sizeof(p) << ": ";
　　char i　　 = 10;　　　cout << sizeof(i) << ": ";
　　void *pp　 = malloc(10);　cout << sizeof(p) << endl;
}

6：4：1：4

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

14.写出运行功效:

{// test2
　　union V {
struct X {
　unsigned char s1:2;
　unsigned char s2:3;
　unsigned char s3:3;
} x;
unsigned char c;
　　} v;
　　v.c = 100;
　　printf("%d", v.x.s3);
}

3

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

15.用C++写个措施，如何判定一个操纵系统是16位照旧32位的？不能用sizeof()函数

A1:

16位的系统下，
int i = 65536;
cout << i; // 输出0；
int i = 65535;
cout << i; // 输出-1；

32位的系统下，

int i = 65536;
cout << i; // 输出65536；
int i = 65535;
cout << i; // 输出65535；

A2:

int a = ~0;
if( a>65536 )
{
　　cout<<"32 bit"<<endl;
}
else
{
　　cout<<"16 bit"<<endl;
}

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

#p#副标题#e#

16.C和C++有什么差异?

从机制上：c是面向进程的（但c也可以编写面向工具的措施）；c++是面向工具的，提供了类。可是，

c++编写面向工具的措施比c容易

#p#分页标题#e#

从合用的偏向：c适合要求代码体积小的，效率高的场所，如嵌入式；c++适合更上层的，巨大的；　llinux焦点大部门是c写的，因为它是系统软件，效率要求极高。

从名称上也可以看出，c++比c多了+，说明c++是c的超集；那为什么不叫c+而叫c++呢，是因为c++比

c来说扩充的对象太多了，所以就在c后头放上两个+；于是就成了c++

C语言是布局化编程语言，C++是面向工具编程语言。

C++偏重于工具而不是进程，偏重于类的设计而不是逻辑的设计。

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

17.在不消第三方参数的环境下，互换两个参数的值

#include <stdio.h>
void main()
{
　　　　int i=60;
　　　　int j=50;
　　　　i=i+j;
　　　　j=i-j;
　　　　i=i-j;
　　　　printf("i=%dn",i);
　　　　printf("j=%dn",j);
}

要领二：

i^=j;

j^=i;

i^=j;

要领三：

// 用加减实现，并且不会溢出

a = a+b-(b=a)

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

18.有关位域的口试题（为什么输出的是一个奇怪的字符）

a.t = ‘b’;结果相当于 a.t= ‘b’ & 0xf;

‘b’ –> 01100010

‘b’ & 0xf –>>00000010

所以输出Ascii码为2的非凡字符

char t:4;就是4bit的字符变量，同样

unsigned short i:8;就是8bit的无标记短整形变量

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

19.int i=10, j=10, k=3; k*=i+j; k最后的值是?

60

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

#p#副标题#e#

20.历程间通信的方法有?

历程间通信的方法有 共享内存， 管道 ，Socket ，动静行列 , DDE等

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

21.

struct A
{
char t:4;
char k:4;
unsigned short i:8;
unsigned long m;
}
sizeof(A)=?（不思量界线对齐）

7

struct CELL　　　　　　 // Declare CELL bit field
{
　 unsigned character　: 8;　// 00000000 ????????
　 unsigned foreground : 3;　// 00000??? 00000000
　 unsigned intensity　: 1;　// 0000?000 00000000
　 unsigned background : 3;　// 0???0000 00000000
　 unsigned blink　　　: 1;　// ?0000000 00000000
} screen[25][80];　　　 // Array of bit fields

二、位布局

位布局是一种非凡的布局, 在需按位会见一个字节或字的多个位时, 位布局

比按位运算符越发利便。

位布局界说的一般形式为:

struct位布局名{
　　　　　数据范例 变量名: 整型常数;
　　　　　数据范例 变量名: 整型常数;
　　 } 位布局变量;

个中: 数据范例必需是int(unsigned或signed)。 整型常数必需长短负的整

数, 范畴是0~15, 暗示二进制位的个数, 即暗示有几多位。

变量名是选择项, 可以不定名, 这样划定是为了分列需要。

譬喻: 下面界说了一个位布局。

struct{
　　　　　unsigned incon: 8;　/*incon占用低字节的0~7共8位*/
　　　　　unsigned txcolor: 4;/*txcolor占用高字节的0~3位共4位*/
　　　　　unsigned bgcolor: 3;/*bgcolor占用高字节的4~6位共3位*/
　　　　　unsigned blink: 1;　/*blink占用高字节的第7位*/
　　 }ch;

位布局成员的会见与布局成员的会见沟通。

譬喻: 会见上例位布局中的bgcolor成员可写成:

ch.bgcolor

#p#副标题#e#

留意:

1. 位布局中的成员可以界说为unsigned, 也可界说为signed,　但当成员长度为1时, 会被认为是unsigned范例。因为单个位不行能具有标记。

2. 位布局中的成员不能利用数组和指针, 但位布局变量可以是数组和指针,

假如是指针, 其成员会见方法同布局指针。

3. 位布局总长度(位数), 是各个位成员界说的位数之和,　可以高出两个字

节。

4. 位布局成员可以与其它布局成员一起利用。

譬喻:

struct info{
　　　　　char name[8];
　　　　　int age;
　　　　　struct addr address;
　　　　　float pay;
　　　　　unsigned state: 1;
　　　　　unsigned pay: 1;
　　　　　}workers;

上例的布局界说了关于一个工人的信息。个中有两个位布局成员, 每个位结

组成员只有一位, 因此只占一个字节但生存了两个信息, 该字节中第一位暗示工

人的状态, 第二位暗示人为是否已发放。由此可见利用位布局可以节减存贮空间。

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

22.下面的函数实此刻一个牢靠的数上加上一个数，有什么错误，纠正

int add_n(int n)
{
　static int i=100;
　i+=n;
　return i;
}

答:

因为static使得i的值会保存上次的值。

去掉static就可了

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

#p#副标题#e#

23.下面的代码有什么问题?

class A

{
public:
　A() { p=this; }
　~A() { if(p!=NULL) { delete p; p=NULL; } }
　A* p;
};

答:

会引起无限递归

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

24.

#p#分页标题#e#

union a {
int a_int1;
double a_double;
int a_int2;
};
typedef struct
{
a a1;
char y;
} b;
class c
{
double c_double;
b b1;
a a2;
};

输出cout<<sizeof(c)<<endl;的功效?

答:

VC6情况下得出的功效是32

另:

我(sun)在VC6.0+win2k下做过试验:

short – 2

int-4

float-4

double-8

指针-4

sizeof(union)，以布局内里size最大的为union的size

#p#副标题#e#

理会C语言中的sizeof

一、sizeof的观念　

sizeof是C语言的一种单目操纵符，如C语言的其他操纵符++、–等。它并不是函数。sizeof操纵符以字节形式给出了其操纵数的存储巨细。操纵数可以是一个表达式或括在括号内的范例名。操纵数的存储巨细由操纵数的范例抉择。

二、sizeof的利用要领　

1、用于数据范例

sizeof利用形式：sizeof（type）

数据范例必需用括号括住。如sizeof（int）。

2、用于变量　

sizeof利用形式：sizeof（var_name）或sizeof　var_name　

变量名可以不消括号括住。如sizeof　(var_name)，sizeof　var_name等都是正确形式。带括号的用法更普遍，大大都措施员回收这种形式。

留意：sizeof操纵符不能用于函数范例，不完全范例或位字段。不完全范例指具有未知存储巨细的数据范例，如未知存储巨细的数组范例、未知内容的布局或连系范例、void范例等。

如sizeof(max)若此时变量max界说为int　max(),sizeof(char_v)　若此时char_v界说为char　char_v　[MAX]且MAX未知，sizeof(void)都不是正确形式。

三、sizeof的功效　

sizeof操纵符的功效范例是size_t，它在头文件

中typedef为unsigned　int范例。该范例担保能容纳实现所成立的最大工具的字节巨细。

1、若操纵数具有范例char、unsigned　char或signed　char，其功效便是1。

ANSI　C正式划定字符范例为1字节。

2、int、unsigned　int　、short　int、unsigned　short　、long　int　、unsigned　long　、 float、double、long　double范例的sizeof　在ANSI　C中没有详细划定，巨细依赖于实现，一般大概别离为2、2、2、2、 4、4、4、8、10。

3、当操纵数是指针时，sizeof依赖于编译器。譬喻Microsoft　C/C++7.0中，near类指针字节数为2，far、huge类指针字节数为4。一般Unix的指针字节数为4。

4、当操纵数具有数组范例时，其功效是数组的总字节数。

5、连系范例操纵数的sizeof是其最大字节成员的字节数。布局范例操纵数的sizeof是这种范例工具的总字节数，包罗任何垫补在内。

让我们看如下布局：　

struct　{char　b;　double　x;}　a;　

在某些呆板上sizeof（a）=12，而一般sizeof（char）+　sizeof（double）=9。

这是因为编译器在思量对齐问题时，在布局中插入空位以节制各成员工具的地点对齐。如double范例的布局成员x要放在被4整除的地点。

6、假如操纵数是函数中的数组形参或函数范例的形参，sizeof给出其指针的巨细。

#p#副标题#e#

四、sizeof与其他操纵符的干系　

sizeof的优先级为2级，比/、%等3级运算符优先级高。它可以与其他操纵符一起构成表达式。如i*sizeof（int）；个中i为int范例变量。

五、sizeof的主要用途

1、sizeof操纵符的一个主要用途是与存储分派和I/O系统那样的例程举办通信。譬喻：　

void　*malloc（size_t　size）,　
　　size_t　fread(void　*　ptr,size_t　size,size_t　nmemb,FILE　*　stream)。　

2、sizeof的另一个的主要用途是计较数组中元素的个数。譬喻：　

void　*　memset（void　*　s,int　c,sizeof(s)）。

六、发起　

由于操纵数的字节数在实现时大概呈现变革，发起在涉及到操纵数字节巨细时用sizeof来取代常量计较。

=============================================================

#p#分页标题#e#

本文主要包罗二个部门，第一部门重点先容在VC中，怎么样回收sizeof来求布局的巨细，以及容易呈现的问题，并给出办理问题的要领，第二部门总结出VC中sizeof的主要用法。

1、 sizeof应用在布局上的环境

请看下面的布局：

struct MyStruct
{
double dda1;
char dda;
int type
};

对布局MyStruct回收sizeof会呈现什么功效呢？sizeof(MyStruct)为几多呢？也许你会这样求：

sizeof(MyStruct)=sizeof(double)+sizeof(char)+sizeof(int)=13

可是当在VC中测试上面布局的巨细时，你会发明sizeof(MyStruct)为16。你知道为什么在VC中会得出这样一个功效吗？

其 实，这是VC对变量存储的一个非凡处理惩罚。为了提高CPU的存储速度，VC对一些变量的起始地点做了"对齐"处理惩罚。在默认环境下，VC划定各成员变量存放的 起始地点相对付布局的起始地点的偏移量必需为该变量的范例所占用的字节数的倍数。下面列出常用范例的对齐方法(vc6.0,32位系统)。

范例

对齐方法（变量存放的起始地点相对付布局的起始地点的偏移量）

Char

偏移量必需为sizeof(char)即1的倍数

int

偏移量必需为sizeof(int)即4的倍数

float

偏移量必需为sizeof(float)即4的倍数

double

偏移量必需为sizeof(double)即8的倍数

Short

偏移量必需为sizeof(short)即2的倍数

各 成员变量在存放的时候按照在布局中呈现的顺序依次申请空间，同时凭据上面的对齐方法调解位置，空白的字节VC会自动填充。同时VC为了确保布局的巨细为结 构的字节界线数（即该布局中占用最大空间的范例所占用的字节数）的倍数，所以在为最后一个成员变量申请空间后，还会按照需要自动填充空白的字节。

下面用前面的例子来说明VC到底怎么样来存放布局的。

struct MyStruct
{
double dda1;
char dda;
int type
}；

#p#副标题#e#

为上面的布局分派空间的时候，VC按照成员变量呈现的顺序和对齐方法，先为第一个成员dda1分派空间，其起始地点跟布局的起始地点沟通（恰好偏移量0恰好 为sizeof(double)的倍数），该成员变量占用sizeof(double)=8个字节；接下来为第二个成员dda分派空间，这时下一个可以分 配的地点对付布局的起始地点的偏移量为8，是sizeof(char)的倍数，所以把dda存放在偏移量为8的处所满意对齐方法，该成员变量占用 sizeof(char)=1个字节；接下来为第三个成员type分派空间，这时下一个可以分派的地点对付布局的起始地点的偏移量为9，不是sizeof (int)=4的倍数，为了满意对齐方法对偏移量的约束问题，VC自动填充3个字节（这三个字节没有放什么对象），这时下一个可以分派的地点对付布局的起 始地点的偏移量为12，恰好是sizeof(int)=4的倍数，所以把type存放在偏移量为12的处所，该成员变量占用sizeof(int)=4个 字节；这时整个布局的成员变量已经都分派了空间，总的占用的空间巨细为：8+1+3+4=16，恰好为布局的字节界线数（即布局中占用最大空间的范例所占 用的字节数sizeof(double)=8）的倍数，所以没有空白的字节需要填充。所以整个布局的巨细为：sizeof(MyStruct)=8+1+ 3+4=16，个中有3个字节是VC自动填充的，没有放任何有意义的对象。

下面再举个例子，互换一下上面的MyStruct的成员变量的位置，使它酿成下面的环境：

struct MyStruct
{
char dda;
double dda1;
int type
}；

这个布局占用的空间为多大呢？在VC6.0情况下，可以获得sizeof(MyStruc)为24。团结上面提到的分派空间的一些原则，阐明下VC怎么样为上面的布局分派空间的。（简朴说明）

struct MyStruct

{

char dda;//偏移量为0，满意对齐方法，dda占用1个字节；

double dda1;//下一个可用的地点的偏移量为1，不是sizeof(double)=8的倍数，需要补足7个字节才气使偏移量变为8（满意对齐方法），因此VC自动填充7个字节，dda1存放在偏移量为8的地点上，它占用8个字节。

int type；//下一个可用的地点的偏移量为16，是sizeof(int)=4的倍数，满意int的对齐方法，所以不需要VC自动填充，type存放在偏移量为16的地点上，它占用4个字节。

所有成员变量都分派了空间，空间总的巨细为1+7+8+4=20，不是布局的节界线数（即布局中占用最大空间的范例所占用的字节数sizeof(double)=8）的倍数，所以需要填充4个字节，以满意布局的巨细为sizeof(double)=8的倍数。

所以该布局总的巨细为：sizeof(MyStruc)为1+7+8+4+4=24。个中总的有7+4=11个字节是VC自动填充的，没有放任何有意义的对象。

#p#分页标题#e#

VC对布局的存储的非凡处理惩罚确实提高CPU存储变量的速度，可是有时候也带来了一些贫苦，我们也屏蔽掉变量默认的对齐方法，本身可以设定变量的对齐方法。

VC 中提供了#pragma pack(n)来设定变量以n字节对齐方法。n字节对齐就是说变量存放的起始地点的偏移量有两种环境：第一、假如n大于便是该变量所占用的字节数，那么偏 移量必需满意默认的对齐方法，第二、假如n小于该变量的范例所占用的字节数，那么偏移量为n的倍数，不消满意默认的对齐方法。布局的总巨细也有个约束条 件，分下面两种环境：假如n大于所有成员变量范例所占用的字节数，那么布局的总巨细必需为占用空间最大的变量占用的空间数的倍数；

不然必需为n的倍数。下面举例说明其用法。

#pragma pack(push) //生存对齐状态
#pragma pack(4)//设定为4字节对齐
struct test
{
　char m1;
　double m4;
　int　m3;
};

#pragma pack(pop)//规复对齐状态

以上布局的巨细为16，下面阐明其存储环境，首先为m1分派空间，其偏移量为0，满意我们本身设定的对齐方法（4字节对齐），m1占用1个字节。接着开始为 m4分派空间，这时其偏移量为1，需要补足3个字节，这样使偏移量满意为n=4的倍数（因为sizeof(double)大于n）,m4占用8个字节。接 着为m3分派空间，这时其偏移量为12，满意为4的倍数，m3占用4个字节。这时已经为所有成员变量分派了空间，共分派了16个字节，满意为n的倍数。如 果把上面的#pragma pack(4)改为#pragma pack(16)，那么我们可以获得布局的巨细为24。（请读者本身阐明）

2、 sizeof用法总结

在VC中，sizeof有着很多的用法，并且很容易引起一些错误。下面按照sizeof后头的参数对sizeof的用法做个总结。

A．　参数为数据范例可能为一般变量。譬喻sizeof(int),sizeof(long)等等。这种环境要留意的是差异系统系统可能差异编译器获得的功效大概是差异的。譬喻int范例在16位系统中占2个字节，在32位系统中占4个字节。

B．　参数为数组或指针。下面举例说明.

int a[50];　//sizeof(a)=4*50=200; 求数组所占的空间巨细

int *a=new int[50];// sizeof(a)=4; a为一个指针，sizeof(a)是求指针

//的巨细,在32位系统中，虽然是占4个字节。

C．　参数为布局或类。Sizeof应用在类和布局的处理惩罚环境是沟通的。但有两点需要留意，第一、布局可能类中的静态成员差池布局可能类的巨细发生影响，因为静态变量的存储位置与布局可能类的实例地点无关。

第二、没有成员变量的布局或类的巨细为1，因为必需担保布局或类的每一

个实例在内存中都有独一的地点。

下面举例说明，

Class Test{int a;static double c};//sizeof(Test)=4.

Test *s;//sizeof(s)=4,s为一个指针。

Class test1{ };//sizeof(test1)=1;

D．　参数为其他。下面举例说明。

int func(char s[5]);

{

cout<<sizeof(s);

这里将输出4，原来s为一个数组，但由于做为函数的参数在通报的时候系统处理惩罚为一个指针，所以sizeof(s)实际上为求指针的巨细。

return 1;

}

sizeof(func("1234"))=4

因为func的返回范例为int，所以相当于求sizeof(int).

以上为sizeof的根基用法，在实际的利用中要留意阐明VC的分派变量的分派计策，这样的话可以制止一些错误。

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

#p#副标题#e#

25.i最后便是几多?

int i = 1;
int j = i++;
if((i>j++) && (i++ == j)) i+=j;

答:

i = 5

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

26.

unsigned short array[]={1,2,3,4,5,6,7};
int i = 3;
*(array + i) = ?

答:

4

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

27.

class A

{
　virtual void func1()；
　void func2();
}
Class B: class A
{
　void func1(){cout << "fun1 in class B" << endl;}
　virtual void func2(){cout << "fun2 in class B" << endl;}
}A, A中的func1和B中的func2都是虚函数.

B, A中的func1和B中的func2都不是虚函数.

C, A中的func2是虚函数.，B中的func1不是虚函数.

D, A中的func2不是虚函数，B中的func1是虚函数.

答:

A

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

28.

数据库：抽出部分，平均人为，要求按部分的字符串顺序排序，不能含有"human resource"部分，

employee布局如下：employee_id, employee_name, depart_id,depart_name,wage

答:

select depart_name, avg(wage)
from employee
where depart_name <> 'human resource'
group by depart_name
order by depart_name

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

#p#副标题#e#

29.给定如下SQL数据库：Test(num INT(4)) 请用一条SQL语句返回num的最小值，但不许利用统计成果，如MIN，MAX等

答:

select top 1 num
from Test
order by num desc

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

30.

输出下面措施功效。

#p#分页标题#e#

#include <iostream.h>
class A
{
public:
virtual void print(void)
{
　　cout<<"A::print()"<<endl;
}
};
class B:public A
{
public:
virtual void print(void)
{
　 cout<<"B::print()"<<endl;
};
};
class C:public B
{
public:
virtual void print(void)
{
　cout<<"C::print()"<<endl;
}
};
void print(A a)
{
　 a.print();
}
void main(void)
{
　 A a, *pa,*pb,*pc;
　 B b;
　 C c;
　 pa=&a;
　 pb=&b;
　 pc=&c;
　 a.print();
　 b.print();
　 c.print();
　 pa->print();
　 pb->print();
　 pc->print();
　 print(a);
　 print(b);
　 print(c);
}

A:

A::print()
B::print()
C::print()
A::print()
B::print()
C::print()
A::print()
A::print()
A::print()

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

#p#副标题#e#

31.试编写函数判定计较机的字节存储顺序是开序(little endian)照旧降序(bigendian)

答:

bool IsBigendian()
{
unsigned short usData = 0x1122;
unsigned char　*pucData = (unsigned char*)&usData;
return (*pucData == 0x22);
}

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

32.简述Critical Section和Mutex的差异点

答:

对几种同步工具的总结

1.Critical Section

A.速度快

B.不能用于差异历程

C.不能举办资源统计(每次只可以有一个线程对共享资源举办存取)

2.Mutex

A.速度慢

B.可用于差异历程

C.不能举办资源统计

3.Semaphore

A.速度慢

B.可用于差异历程

C.可举办资源统计(可以让一个或高出一个线程对共享资源举办存取)

4.Event

A.速度慢

B.可用于差异历程

C.可举办资源统计

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

33.一个数据库中有两个表:

一张表为Customer，含字段ID,Name;

一张表为Order，含字段ID,CustomerID（连向Customer中ID的外键）,Revenue；

写出求每个Customer的Revenue总和的SQL语句。

建表

create table customer
(
ID int primary key,Name char(10)
)
go
create table [order]
(
ID int primary key,CustomerID　int foreign key references customer(id) , Revenue float
)
go

–查询

select Customer.ID, sum( isnull([Order].Revenue,0) )
from customer full join [order]
on( [order].customerid=customer.id )
group by customer.id

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

34.请指出下列措施中的错误而且修改

void GetMemory(char *p){
　p=(char *)malloc(100);
}
void Test(void){
　char *str=NULL;
　GetMemory=(str);
　strcpy(str,"hello world");
　printf(str);
}

A:错误–参数的值改变后，不会传回

GetMemory并不能通报动态内存，Test函数中的 str一直都是 NULL。

strcpy(str, "hello world");将使措施瓦解。

修改如下:

char *GetMemory(){
　char *p=(char *)malloc(100);
　return p;
}
void Test(void){
　char *str=NULL;
　str=GetMemory(){
　strcpy(str,"hello world");
　printf(str);
}

要领二:void GetMemory2(char **p)变为二级指针.

void GetMemory2(char **p, int num)
{
*p = (char *)malloc(sizeof(char) * num);
}

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

#p#副标题#e#

35.措施改错

#p#分页标题#e#

class mml
{
　private:
　　static unsigned int x;
　public:
　　mml(){ x++; }
　　mml(static unsigned int &) {x++;}
　　~mml{x--;}
　pulic:
　　virtual mon() {} = 0;
　　static unsigned int mmc(){return x;}
　　......
};
class nnl:public mml
{
　private:
　　static unsigned int y;
　public:
　　nnl(){ x++; }
　　nnl(static unsigned int &) {x++;}
　　~nnl{x--;}
　public:
　　virtual mon() {};
　　 static unsigned int nnc(){return y;}
　　......
};

代码片段:

mml* pp = new nnl;
..........
delete pp;

A:

基类的析构函数应该为虚函数

virtual ~mml{x–;}

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

36.101个硬币100真、1假，真假区别在于重量。请用无砝码天平称两次给出真币重照旧假币重的结论。

答:

101个先取出2堆,

33,33

第一次称,假如不相等,说明有一堆重或轻

那么把重的那堆拿下来,再放别的35其中的33

假如相等,说明假的重,假如不相等,新放上去的照旧重的话,说明假的轻(不行能新放上去的轻)

第一次称,假如相等的话，这66个必定都是真的,从这66其中取出35个来,与剩下的没称过的35个比

下面就不消说了

要领二:

第3题也可以拿A(50),B(50)比一下，一样的话拿剩下的一个和真的比一下。

假如纷歧样，就拿个中的一堆。好比A(50)再分成两堆25比一下，一样的话就在

B(50)中，纷歧样就在A(50)中，团结第一次的功效就知道了。

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

#p#副标题#e#

37.static变量和static 函数各有什么特点？

答:

static变量：在措施运行期内一直有效，假如界说在函数外，则在编译单位内可见，假如在函数内，在在界说的block内可见；

static函数：在编译单位内可见；

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

38.用C 写一个输入的整数,倒着输出整数的函数,要求用递归要领 ;

答:

void fun( int a )
{
printf( "%d", a%10 );
a /= 10;
if( a <=0 )return;
fun( a );
}

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

39.写出措施功效:

void Func(char str[100])
{
　printf("%dn", sizeof(str));
}

答:

4

阐明:

指针长度

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

40.int id[sizeof(unsigned long)];

这个对吗？为什么??

答:

对

这个 sizeof是编译时运算符，编译时就确定了

可以当作和呆板有关的常量。

本文主要包罗二个部门，第一部门重点先容在VC中，怎么样回收sizeof来求布局的巨细，以及容易呈现的问题，并给出办理问题的要领，第二部门总结出VC中sizeof的主要用法。

1、 sizeof应用在布局上的环境

请看下面的布局：

struct MyStruct
{
double dda1;
char dda;
int type
};

对布局MyStruct回收sizeof会呈现什么功效呢？sizeof(MyStruct)为几多呢？也许你会这样求：

sizeof(MyStruct)=sizeof(double)+sizeof(char)+sizeof(int)=13

可是当在VC中测试上面布局的巨细时，你会发明sizeof(MyStruct)为16。你知道为什么在VC中会得出这样一个功效吗？

其 实，这是VC对变量存储的一个非凡处理惩罚。为了提高CPU的存储速度，VC对一些变量的起始地点做了"对齐"处理惩罚。在默认环境下，VC划定各成员变量存放的 起始地点相对付布局的起始地点的偏移量必需为该变量的范例所占用的字节数的倍数。下面列出常用范例的对齐方法(vc6.0,32位系统)。

范例

对齐方法（变量存放的起始地点相对付布局的起始地点的偏移量）

Char

偏移量必需为sizeof(char)即1的倍数

int

偏移量必需为sizeof(int)即4的倍数

float

偏移量必需为sizeof(float)即4的倍数

double

偏移量必需为sizeof(double)即8的倍数

Short

偏移量必需为sizeof(short)即2的倍数

各成员变量在存放的时候按照在布局中呈现的顺序依次申请空间，同时凭据上面的对齐方法调解位置，空白的字节VC会自动填充。同时VC为了确保布局的巨细为布局的字节界线数（即该布局中占用最大空间的范例所占用的字节数）的倍?