C语言面试题大汇总

上一篇 / 下一篇  2006-06-19 13:51:28 / 天气: Array / 个人分类:其他

4. static有什么用途?(请至少说明两种)木铎校园 BBS 社区'drx;v$K7o}T
1.限制变量的作用域
({ y'rj0|i NrbBS02.设置变量的存储域
rK ~*POs07. 引用与指针有什么区别?木铎校园 BBS 社区!c6f;l}bfbR:a z#at
1) 引用必须被初始化,指针不必。木铎校园 BBS 社区1q3}0O:eSww%I
2) 引用初始化以后不能被改变,指针可以改变所指的对象。木铎校园 BBS 社区&g LP Tmb8}r0t
2) 不存在指向空值的引用,但是存在指向空值的指针。
R&X M,A$X&r-P0
T0F `/J7[{#K{kc08. 描述实时系统的基本特性
\7\o7`p2Ih9Rz0在特定时间内完成特定的任务,实时性与可靠性
:by e/x*~y5`,oD09. 全局变量和局部变量在内存中是否有区别?如果有,是什么区别?木铎校园 BBS 社区+JN xs;[K.s
全局变量储存在静态数据库,局部变量在堆栈木铎校园 BBS 社区V2_\5hUVZ`bK
10. 什么是平衡二叉树?
BZ/zk(z@ o0左右子树都是平衡二叉树 且左右子树的深度差值的绝对值不大于1木铎校园 BBS 社区9{4y9`.xNkta
11. 堆栈溢出一般是由什么原因导致的?木铎校园 BBS 社区 [y)?2a9N&N8toN
没有回收垃圾资源
P`pU3k3yeXC012. 什么函数不能声明为虚函数?木铎校园 BBS 社区LI4ig[&Q }
constructor
$Y%M4aP_G4J.};\x013. 冒泡排序算法的时间复杂度是什么?
M.Z$k.j,c?bA$m#q0O(n^2)木铎校园 BBS 社区.@q v8WU-t
14. 写出float x 与“零值”比较的if语句。木铎校园 BBS 社区;k4Ef$cH~-K
if(x>0.000001&&x<-0.000001)
+`*ca9]9q!B:F016. Internet采用哪种网络协议?该协议的主要层次结构?木铎校园 BBS 社区nZ"}{2h6[V'L
tcp/ip 应用层/传输层/网络层/数据链路层/物理层木铎校园 BBS 社区6Y%S3XQC`H;WD.V
17. Internet物理地址和IP地址转换采用什么协议?
)p0vf&X(E0ARP (Address Resolution Protocol)(地址解析協議)
2S R1l7n|018.IP地址的编码分为哪俩部分?
La9U:U0Uw0IP地址由两部分组成,网络号和主机号。不过是要和“子网掩码”按位与上之后才能区分哪些是网络位哪些是主机位。木铎校园 BBS 社区"FyoH:gT \
木铎校园 BBS 社区PUH+V wW!`
木铎校园 BBS 社区6H{b*P-^&B Z
2.用户输入M,N值,从1至N开始顺序循环数数,每数到M输出该数值,直至全部输出。写出C程序。木铎校园 BBS 社区4q%rE/B4`f&R_'}C"a
循环链表,用取余操作做
6U)u~}8F1dU A03.不能做switch()的参数类型是:
:H[$[ {!tfp*u"Y%C0switch的参数不能为实型。木铎校园 BBS 社区g@,E z"J2~ZX

Fc'qL+W0華為
/{#hK y{)u*AF/S,T01、局部变量能否和全局变量重名?木铎校园 BBS 社区4A6~-Z$xw8Ay&\C$v'O
答:能,局部会屏蔽全局。要用全局变量,需要使用"::"
FsbyC0yGG"Y0局部变量可以与全局变量同名,在函数内引用这个变量时,会用到同名的局部变量,而不会用到全局变量。对于有些编译器而言,在同一个函数内可以定义多个同名的局部变量,比如在两个循环体内都定义一个同名的局部变量,而那个局部变量的作用域就在那个循环体内
m&N2oDzSO lO2`,Q02、如何引用一个已经定义过的全局变量?
s6PVYo\t;L:g0答:extern
d!w&Fy R T0可以用引用头文件的方式,也可以用extern关键字,如果用引用头文件方式来引用某个在头文件中声明的全局变理,假定你将那个变写错了,那么在编译期间会报错,如果你用extern方式引用时,假定你犯了同样的错误,那么在编译期间不会报错,而在连接期间报错
~ rd3`Ff ]tW03、全局变量可不可以定义在可被多个.C文件包含的头文件中?为什么?
E%zS6o Xen/K0答:可以,在不同的C文件中以static形式来声明同名全局变量。
7C3g.K'r6k5p bz}0可以在不同的C文件中声明同名的全局变量,前提是其中只能有一个C文件中对此变量赋初值,此时连接不会出错木铎校园 BBS 社区]Kr8z H9D[
4、语句for( ;1 ;)有什么问题?它是什么意思?
fJ y|@%}@ e7U0答:和while(1)相同。木铎校园 BBS 社区.?6O `Qp-an#ih,k
5、do……while和while……do有什么区别?
Df^0hz Y0答:前一个循环一遍再判断,后一个判断以后再循环木铎校园 BBS 社区eX&^^.d#d:e
6、请写出下列代码的输出内容
%R N'@lB[p0#include
Z8tr"]z:Y)A,S ~:HC0main()
$~3E8ni)]8p6b?0{木铎校园 BBS 社区q(]$n"eLv%Zdh4lT
int a,b,c,d;
S0E D-Z$@"zuh0a=10;
0TJ3UC P0[QQl3Q0b=a++;木铎校园 BBS 社区"OVIp%FzAzc
c=++a;
2I'l l3h6_:e!qE dq0d=10*a++;木铎校园 BBS 社区'Z1C;L w3c8W{n S
printf("b,c,d:%d,%d,%d",b,c,d);
^)mG'eg3KM0return 0;
uStO6onQ9C0}木铎校园 BBS 社区*[o;cNt9ib
答:10,12,120木铎校园 BBS 社区(?5e j^0S}

h'y+d2sL9P,xIX01、static全局变量与普通的全局变量有什么区别?static局部变量和普通局部变量有什么区别?static函数与普通函数有什么区别?木铎校园 BBS 社区/A|e8{-Vo` gl5y_s
全局变量(外部变量)的说明之前再冠以static 就构成了静态的全局变量。全局变量本身就是静态存储方式, 静态全局变量当然也是静态存储方式。这两者在存储方式上并无不同。这两者的区别虽在于非静态全局变量的作用域是整个源程序,当一个源程序由多个源文件组成时,非静态的全局变量在各个源文件中都是有效的。 而静态全局变量则限制了其作用域, 即只在定义该变量的源文件内有效,在同一源程序的其它源文件中不能使用它。由于静态全局变量的作用域局限于一个源文件内,只能为该源文件内的函数公用,因此可以避免在其它源文件中引起错误。木铎校园 BBS 社区] y/Qw:[9GD6{w
从以上分析可以看出, 把局部变量改变为静态变量后是改变了它的存储方式即改变了它的生存期。把全局变量改变为静态变量后是改变了它的作用域, 限制了它的使用范围。
~,p}c@7aUn r3R0static函数与普通函数作用域不同。仅在本文件。只在当前源文件中使用的函数应该说明为内部函数(static),内部函数应该在当前源文件中说明和定义。对于可在当前源文件以外使用的函数,应该在一个头文件中说明,要使用这些函数的源文件要包含这个头文件木铎校园 BBS 社区snw;qM@
木铎校园 BBS 社区 J v&gDS!?(p
static全局变量与普通的全局变量有什么区别:static全局变量只初使化一次,防止在其他文件单元中被引用;木铎校园 BBS 社区!j^y$wuPZLw}G
static局部变量和普通局部变量有什么区别:static局部变量只被初始化一次,下一次依据上一次结果值;
)Q S nT#YL-Du jyS7H0static函数与普通函数有什么区别:static函数在内存中只有一份,普通函数在每个被调用中维持一份拷贝木铎校园 BBS 社区3w(lX8V"r qD
2、程序的局部变量存在于(堆栈)中,全局变量存在于(静态区 )中,动态申请数据存在于( 堆)中。木铎校园 BBS 社区 ]'|:r-H+DI:D i
3、设有以下说明和定义:木铎校园 BBS 社区2|-|kI?_-Q(@
typedef union {long i; int k[5]; char c;} DATE;
;Sf1J+}a0struct data { int cat; DATE cow; double dog;} too;木铎校园 BBS 社区1@%@&}?[p%q
DATE max;
f2~%v\E7T{0则语句 printf("%d",sizeof(struct date)+sizeof(max));的执行结果是:___52____木铎校园 BBS 社区5ra$h!`z)ir*Q
答:DATE是一个union, 变量公用空间. 里面最大的变量类型是int[5], 占用20个字节. 所以它的大小是20木铎校园 BBS 社区r1k2Y'rPE$L L
data是一个struct, 每个变量分开占用空间. 依次为int4 + DATE20 + double8 = 32.木铎校园 BBS 社区U+O8P7F/Y;z,a)F
所以结果是 20 + 32 = 52.
!Tj"n8h`0当然...在某些16位编辑器下, int可能是2字节,那么结果是 int2 + DATE10 + double8 = 20
LC%M8tX}@04、队列和栈有什么区别?木铎校园 BBS 社区q[AQkk
队列先进先出,栈后进先出木铎校园 BBS 社区~"pI&^PB$?
5、写出下列代码的输出内容木铎校园 BBS 社区Rrz Op+kc
#include木铎校园 BBS 社区^0n\5Ape0IYcj
int inc(int a)木铎校园 BBS 社区hSaXx `$o+U4L:Y
{
#o3m mnY7G1ne)f0return(++a);
}?"\!b'q;a%X/T?B0}木铎校园 BBS 社区FB6ai tX
int multi(int*a,int*b,int*c)木铎校园 BBS 社区 dS2BQ_.|]
{木铎校园 BBS 社区%z(Ec HPnL a!x(ZZ;ld
return(*c=*a**b);
3b(]~'W]w9S]0}
U;CF L#q+M0typedef int(FUNC1)(int in);
HL%x6\*Yc2pdv8t0typedef int(FUNC2) (int*,int*,int*);
#eEY9B|0
!IR M'NLU c`/l0void show(FUNC2 fun,int arg1, int*arg2)木铎校园 BBS 社区8q(TP"R4W)Spr ?
{木铎校园 BBS 社区;V Fv5fpnrn
INCp=&inc;木铎校园 BBS 社区X1TOwgU\ PIp
int temp =p(arg1);木铎校园 BBS 社区5m@y6}["F"K't
fun(&temp,&arg1, arg2);木铎校园 BBS 社区 jc3t bP6_dmq
printf("%d\n",*arg2);木铎校园 BBS 社区N!I ROf
}
^g4u0bO5p0
"AV;XDq@1Fz@qV0main()木铎校园 BBS 社区 Iw%[e Q w$@3t
{木铎校园 BBS 社区,Z6do7P3z]5ZMd pg
int a;木铎校园 BBS 社区1R$@W+@1S)X4v
show(multi,10,&a);木铎校园 BBS 社区A'a2X HT,c
return 0;
'J Z;tu2Z2aq'Q1a0}木铎校园 BBS 社区U.s"e)Gp{
答:110木铎校园 BBS 社区~(yjL9n'd o-S4yf'V\
7、请找出下面代码中的所以错误木铎校园 BBS 社区'W} K}}
说明:以下代码是把一个字符串倒序,如“abcd”倒序后变为“dcba”
7e?B(sG0
9L(MtX'|X1w01、#include"string.h"木铎校园 BBS 社区7FGN$Y:P/y
2、main()
lh(m#I+^"yB03、{
X m6|*k8D04、 char*src="hello,world";
3@O:I2vfq05、 char* dest=NULL;
&b2q]#C[%m0@06、 int len=strlen(src);木铎校园 BBS 社区 iz-U,M(t!} fSb
7、 dest=(char*)malloc(len);
2\} [4Zu*?I08、 char* d=dest;木铎校园 BBS 社区8HRCK0b'N6V4~0}
9、 char* s=src[len];
ne%{"V,I6H:Y!\010、 while(len--!=0)木铎校园 BBS 社区6Ks}m6uR%Y }_
11、 d++=s--;木铎校园 BBS 社区(FQ8Wd is$z5C
12、 printf("%s",dest);
_/s!Q;v[6lwl013、 return 0;
!h b&\QQ{ B+~014、}木铎校园 BBS 社区+?9`%yM0tb pD k;U
答:木铎校园 BBS 社区,|h+i!wjm'?!G%~+h&T!J(a
方法1:木铎校园 BBS 社区+tS!nT5ob ` \!c
int main(){
B\u k R:V0char* src = "hello,world";
lJ)}:a6eC0int len = strlen(src);
RY-Gk;W'M-wJ0char* dest = (char*)malloc(len+1);//要为\0分配一个空间
iBQ3up0Q0char* d = dest;木铎校园 BBS 社区-j$oG.@m1au)^"WLp
char* s = &src[len-1];//指向最后一个字符木铎校园 BBS 社区2e&lPD;?
while( len-- != 0 )
y8y{P3Q4?Lf0*d++=*s--;木铎校园 BBS 社区;K$T \8JD
*d = 0;//尾部要加\0木铎校园 BBS 社区"YG VOa {6F&i
printf("%s\n",dest);
&z8uB3]&A|T0free(dest);// 使用完,应当释放空间,以免造成内存汇泄露木铎校园 BBS 社区(L,Y-h Y$] x3? Lm6qb&j
return 0;
'Tz&d]6]3U0}木铎校园 BBS 社区iC Ebk6C`u&yO
方法2:木铎校园 BBS 社区0D%J$o+KVNW
#include木铎校园 BBS 社区6N8sF,xcLDr
#include
z+t(jN;N4Hb|0main()
l:IAT-`~0{
3j ]2K$@~%v)H0char str[]="hello,world";
+W_ K.q6C/n U0int len=strlen(str);
Ln0V$^ x W(a!K0char t;木铎校园 BBS 社区'Zx1F-TC0mfsn4J
for(int i=0; i木铎校园 BBS 社区@]hW Kzy]$P,_
{
'|)D3s$US0t=str[i];
&p+x|'LQF0str[i]=str[len-i-1]; str[len-i-1]=t;
bJh ]w,p0q0}
n-Yy fU(t{0printf("%s",str);木铎校园 BBS 社区:X[.G.v0^/UQ/pBN5I8y
return 0;木铎校园 BBS 社区V/\I'[U Z(H3X
}
nd;J)JHyr'_01.-1,2,7,28,,126请问28和126中间那个数是什么?为什么?
z:}:w0];l6q h0第一题的答案应该是4^3-1=63木铎校园 BBS 社区$CJ6SC,{K+pN
规律是n^3-1(当n为偶数0,2,4)木铎校园 BBS 社区lP8Q\`
n^3+1(当n为奇数1,3,5)木铎校园 BBS 社区uq'g_4IiO,rJ0|q
答案:63木铎校园 BBS 社区!u9|'p\%HK8{2bq?
2.用两个栈实现一个队列的功能?要求给出算法和思路!木铎校园 BBS 社区4^ yx`4X:je)h O
设2个栈为A,B, 一开始均为空.木铎校园 BBS 社区}5p)v5chu
木铎校园 BBS 社区O6AU$R&s%a1p'~P9W
入队:木铎校园 BBS 社区AN+qxw&q;H
将新元素push入栈A;木铎校园 BBS 社区&g4wb9B3b#i
木铎校园 BBS 社区~%pFM8uL&]#J4R
出队:木铎校园 BBS 社区,{.p!jE4Cv+J
(1)判断栈B是否为空;
b$m1EllFN;e]0(2)如果不为空,则将栈A中所有元素依次pop出并push到栈B;木铎校园 BBS 社区:g:ktV.a@(X3I4Z
(3)将栈B的栈顶元素pop出;
TWv{K{Jt)QE!p0
Q_/Zl$UbFC0这样实现的队列入队和出队的平摊复杂度都还是O(1), 比上面的几种方法要好。3.在c语言库函数中将一个字符转换成整型的函数是atool()吗,这个函数的原型是什么?木铎校园 BBS 社区io.]H)O
函数名: atol
$ID_5w2w7ZM!G0功 能: 把字符串转换成长整型数
j#}7Ww!f9^)r)l0用 法: long atol(const char *nptr);木铎校园 BBS 社区tp T"On4d
程序例:木铎校园 BBS 社区)|;Z(?9ZT`
#include
o2@ xn5p0c/WU0#include木铎校园 BBS 社区 @AC(\J-P
int main(void)木铎校园 BBS 社区@(gR[t(g(j(Xa
{木铎校园 BBS 社区K.\8f*mq;X6p
long l;木铎校园 BBS 社区qy/g!m)Y!pZ
char *str = "98765432";
q0Y\ Y)t }&F7\0木铎校园 BBS 社区$ed3_ |+O
l = atol(lstr);
M*z6I)M6T*a9hK0printf("string = %s integer = %ld\n", str, l);木铎校园 BBS 社区#p ?5S'h#s2v#|w;z U
return(0);
x+c'?Eh3{ }K+DB0}木铎校园 BBS 社区&RM*z0_)ER
2.对于一个频繁使用的短小函数,在C语言中应用什么实现,在C++中应用什么实现?木铎校园 BBS 社区/^l~8z,?cM
c用宏定义,c++用inline
,d"A;g3ng,^3S03.直接链接两个信令点的一组链路称作什么?
X6^9}C(R0PPP点到点连接木铎校园 BBS 社区 c.s.}'X3c)y,rm
4.接入网用的是什么接口?
*y ?f XK2E\aM[9Fu05.voip都用了那些协议?
KR%B9Fl ];G6[E,r06.软件测试都有那些种类?
,j2j8}z u0p [Bj0黑盒:针对系统功能的测试 白合:测试函数功能,各函数接口木铎校园 BBS 社区\ _V?R!lO
7.确定模块的功能和模块的接口是在软件设计的那个队段完成的?木铎校园 BBS 社区BD"xz8YZT5H
概要设计阶段木铎校园 BBS 社区XDfeG[1Fu\
8.enum string
|6P7l-H+d"y.m \'_0{
'z2k7f"@4A/|'nz0T1E0x1,木铎校园 BBS 社区pl1c-@L_
x2,木铎校园 BBS 社区?(H I e:j
x3=10,
gO5?6{-y } K9zs[0x4,木铎校园 BBS 社区ORv6e AGy.A
x5,木铎校园 BBS 社区5pP:abO~y_1F
}x;
8b/z4[ Q Ew|D0问x= 0x801005,0x8010f4 ;木铎校园 BBS 社区k&K/{^+j
9.unsigned char *p1;
4G;G)S ?1Eh1vik0unsigned long *p2;
[(S5Y4Ns.Y"\/lo0p1=(unsigned char *)0x801000;
OvZ2iz0p2=(unsigned long *)0x810000;
4b bgz/^8a&g P0请问p1+5= ;
{C(b.f(dA$@0p2+5= ;木铎校园 BBS 社区GV dEJbQ m
三.选择题:
w8\#a#F/Kr?+U01.Ethternet链接到Internet用到以下那个协议?
q#ON9g&WER0A.HDLC;B.ARP;C.UDP;D.TCP;E.ID
o[#ihPc!h)P*o02.属于网络层协议的是:
};l JSj bg(X0A.TCP;B.IP;C.ICMP;D.X.25
1x9Q.N,p3N03.Windows消息调度机制是:
O6T t7_$Qtu0A.指令队列;B.指令堆栈;C.消息队列;D.消息堆栈;
b#B4j8oV|,Y U04.unsigned short hash(unsigned short key)木铎校园 BBS 社区7~;a5mOI z^F~|
{木铎校园 BBS 社区?)RT \"\Gg-W
return (key>>)%256木铎校园 BBS 社区)^g-sQL7R
}
(c&k&W&j@(v1rJ+F0请问hash(16),hash(256)的值分别是:
&VK*y-}0|"g?0O4N0A.1.16;B.8.32;C.4.16;D.1.32
*smO,E{0四.找错题:
2}R"U6RjU01.请问下面程序有什么错误?
Yl_:MW0int a[60][250][1000],i,j,k;
/Dac5U%J,M6B?*}2Kz D0for(k=0;k<=1000;k++)木铎校园 BBS 社区nx8Xq6\N1T
for(j=0;j<250;j++)木铎校园 BBS 社区%u8m~;u$Nu:l
for(i=0;i<60;i++)
T?6?8U/C-|/q$mw0a[i][j][k]=0;木铎校园 BBS 社区 dWtoz)|8Vmu
把循环语句内外换一下木铎校园 BBS 社区;~J9Re:}f}j/H#b
2.#define Max_CB 500木铎校园 BBS 社区E.R8hU3A
void LmiQueryCSmd(Struct MSgCB * pmsg)
G[%f8ig V/A2m;r0{
T$N$A4k.R?i0unsigned char ucCmdNum;
O8YNk Ji3~K0......
BFUSH"U F z0木铎校园 BBS 社区;_5I/hFm{
for(ucCmdNum=0;ucCmdNum木铎校园 BBS 社区 l(S:_FE#j)t ['j+Qg
{
0Aw|u2vvs$Px0......;
5rJz/cdp(v\0}木铎校园 BBS 社区 X1~4O\$` sw
死循环木铎校园 BBS 社区y#EJ"F_XZ@
3.以下是求一个数的平方的程序,请找出错误:木铎校园 BBS 社区&kd)r-Y?
#define SQUARE(a)((a)*(a))木铎校园 BBS 社区#x GW7H m;T!^T6t{
int a=5;
)zyJ E5Ym0int b;木铎校园 BBS 社区&lp[}ecm%C*l7~
b=SQUARE(a++);木铎校园 BBS 社区8Pn[|%P^lK7c#k c
4.typedef unsigned char BYTE木铎校园 BBS 社区:^inuv p`
int examply_fun(BYTE gt_len; BYTE *gt_code)木铎校园 BBS 社区U!c-Y%g!YNb7CH$_J'A
{木铎校园 BBS 社区 k%Z;wn(P
BYTE *gt_buf;木铎校园 BBS 社区)Ai4nH?K-gN
gt_buf=(BYTE *)MALLOC(Max_GT_Length);木铎校园 BBS 社区I-WH&?2S
......木铎校园 BBS 社区h lL B3rX
if(gt_len>Max_GT_Length)
7@uY)muPJ6m0{木铎校园 BBS 社区m*tBc;C/g^2y7T YlQ
return GT_Length_ERROR;
] tJbg)IE%\#s1h0}
y2?R;I ~9xpC0.......
U9Zd]W/{o0}木铎校园 BBS 社区[%i!D8C[^
五.问答题:木铎校园 BBS 社区ycF&T%a,Nv
1.IP Phone的原理是什么?
U'U,t#a+R0IPV6木铎校园 BBS 社区D)tB5O*tm7E
2.TCP/IP通信建立的过程怎样,端口有什么作用?
/w&x`9S B0三次握手,确定是哪个应用程序使用该协议木铎校园 BBS 社区 t|P'L$?1qK
3.1号信令和7号信令有什么区别,我国某前广泛使用的是那一种?木铎校园 BBS 社区,K?4p:Q1|:u
4.列举5种以上的电话新业务?
Da/gT6g Cu/l0木铎校园 BBS 社区 WU'c%T(U @`l~+m"z$fO
微软亚洲技术中心的面试题!!!
;T {o4XORcoIg01.进程和线程的差别。
Qdu2oU3x0线程是指进程内的一个执行单元,也是进程内的可调度实体.木铎校园 BBS 社区\9w{3e9dDOx
与进程的区别:
R(T5s;o jEC[W4eL0(1)调度:线程作为调度和分配的基本单位,进程作为拥有资源的基本单位
C-r9FC8d@Wn0(2)并发性:不仅进程之间可以并发执行,同一个进程的多个线程之间也可并发执行
j)rxm&b*J,~0(3)拥有资源:进程是拥有资源的一个独立单位,线程不拥有系统资源,但可以访问隶属于进程的资源.木铎校园 BBS 社区 Tk(m(UwLV#t
(4)系统开销:在创建或撤消进程时,由于系统都要为之分配和回收资源,导致系统的开销明显大于创建或撤消线程时的开销。木铎校园 BBS 社区A'cJ?(f"e%E4A
2.测试方法木铎校园 BBS 社区'a:p7Zx4Wc
人工测试:个人复查、抽查和会审
.It#}0X6W0机器测试:黑盒测试和白盒测试木铎校园 BBS 社区 zA%B%NbV

,r6TUt]3|m02.Heap与stack的差别。木铎校园 BBS 社区;?)Oyp [%oh XU%^
Heap是堆,stack是栈。木铎校园 BBS 社区s&So zE Bha8@
Stack的空间由操作系统自动分配/释放,Heap上的空间手动分配/释放。
h'O*Ge3k~0Stack空间有限,Heap是很大的自由存储区木铎校园 BBS 社区8}i E3V2qC:q
C中的malloc函数分配的内存空间即在堆上,C++中对应的是new操作符。木铎校园 BBS 社区,i'G7]`2d
程序在编译期对变量和函数分配内存都在栈上进行,且程序运行过程中函数调用时参数的传递也在栈上进行
B8Y4Jj:f?03.Windows下的内存是如何管理的?
4hy9RjB jzT*J3J04.介绍.Net和.Net的安全性。木铎校园 BBS 社区L(nTx)qvAW
5.客户端如何访问.Net组件实现Web Service?木铎校园 BBS 社区+P PA^:J
6.C/C++编译器中虚表是如何完成的?木铎校园 BBS 社区N6pQ @1A%v Gj VO
7.谈谈COM的线程模型。然后讨论进程内/外组件的差别。
t T b)xx Un E}D08.谈谈IA32下的分页机制
%P{){/X PMVj0小页(4K)两级分页模式,大页(4M)一级
%S f v_2d,L09.给两个变量,如何找出一个带环单链表中是什么地方出现环的?木铎校园 BBS 社区DW^hII&A*u
一个递增一,一个递增二,他们指向同一个接点时就是环出现的地方
Ia2})f8i*J)W9R/R^V010.在IA32中一共有多少种办法从用户态跳到内核态?木铎校园 BBS 社区5Q[_.n#{ hP
通过调用门,从ring3到ring0,中断从ring3到ring0,进入vm86等等
Xe%^UjdJD/s0Y011.如果只想让程序有一个实例运行,不能运行两个。像winamp一样,只能开一个窗口,怎样实现?
Y1V/p+Y bB$GaAM!p0用内存映射或全局原子(互斥变量)、查找窗口句柄..
T2[v~U`MV0FindWindow,互斥,写标志到文件或注册表,共享内存。. 
zmh] QNly012.如何截取键盘的响应,让所有的‘a’变成‘b’?木铎校园 BBS 社区 eK4\Ms6KH*J
键盘钩子SetWindowsHookEx
9|/Ppni.|hn%Wf!w0 13.Apartment在COM中有什么用?为什么要引入?
1OW{%p'o8Pqel qBa0 14.存储过程是什么?有什么用?有什么优点?木铎校园 BBS 社区"p+m&R ?&m)nc5z!r
我的理解就是一堆sql的集合,可以建立非常复杂的查询,编译运行,所以运行一次后,以后再运行速度比单独执行SQL快很多
O^)r$d#T4n0 15.Template有什么特点?什么时候用?木铎校园 BBS 社区*~pG,A.szd-l8QJ
16.谈谈Windows DNA结构的特点和优点。木铎校园 BBS 社区Sy/E1lAw \
木铎校园 BBS 社区:giMQ^)~Uw

EP:^ k x0o WG0网络编程中设计并发服务器,使用多进程 与 多线程 ,请问有什么区别?木铎校园 BBS 社区Ds m.t_b
1,进程:子进程是父进程的复制品。子进程获得父进程数据空间、堆和栈的复制品。木铎校园 BBS 社区+ysZL:QAo
2,线程:相对与进程而言,线程是一个更加接近与执行体的概念,它可以与同进程的其他线程共享数据,但拥有自己的栈空间,拥有独立的执行序列。
T8GqE"tT/ea]0两者都可以提高程序的并发度,提高程序运行效率和响应时间。木铎校园 BBS 社区)L G:Xv6Y4xB:{
线程和进程在使用上各有优缺点:线程执行开销小,但不利于资源管理和保护;而进程正相反。同时,线程适合于在SMP机器上运行,而进程则可以跨机器迁移。木铎校园 BBS 社区GeZ2AX)\p6b
木铎校园 BBS 社区:[JmYtn~
思科木铎校园 BBS 社区K,O;u2TbL,h,H-r
1. 用宏定义写出swap(x,y)
1S!uU,_g U!c h'A0#define swap(x, y)\
k6J7H9`n6H:tr&_7z0x = x + y;\木铎校园 BBS 社区(^9v+HA&Q.Tg
y = x - y;\木铎校园 BBS 社区R/U P4?/Ev;a
x = x - y;
{ t ok$_02.数组a[N],存放了1至N-1个数,其中某个数重复一次。写一个函数,找出被重复的数字.时间复杂度必须为o(N)函数原型:
'knK"j TwE ^2FHkb0int do_dup(int a[],int N)木铎校园 BBS 社区!h"@0zF;pr
3 一语句实现x是否为2的若干次幂的判断木铎校园 BBS 社区#U:K$g]o-XBI-u
int i = 512;
(v:U?K'b{0cout<< boolalpha << ((i & (i - 1)) ? false : true) << endl;
#`p-sAD;hr2t\ O04.unsigned int intvert(unsigned int x,int p,int n)实现对x的进行转换,p为起始转化位,n为需要转换的长度,假设起始点在右边.如x=0b0001 0001,p=4,n=3转换后x=0b0110 0001木铎校园 BBS 社区y6aGxq
unsigned int intvert(unsigned int x,int p,int n){木铎校园 BBS 社区(`)cQn d
unsigned int _t = 0;
Y/v!SDW0pFp0unsigned int _a = 1;木铎校园 BBS 社区Yz(z)a3T8@ km
for(int i = 0; i< n; ++i){
j d1A/?-XO Ik0_t |= _a;
E-b*Eb+_;X8IH0_a = _a<< 1;木铎校园 BBS 社区_P{ I+zqQs
}木铎校园 BBS 社区Y_ycOL#s0s
_t = _t<< p;
?.~3b FW m3r0x ^= _t;
%b#Cd'vu0return x;
(z"v_*`Ii0}
0hw5c4R'eeGmi/G@0慧通:
m'|C.{L0什么是预编译木铎校园 BBS 社区4i8?o!XS`G
何时需要预编译:木铎校园 BBS 社区8?/g)H3D Vd6Y&d$K
1、总是使用不经常改动的大型代码体。
F4`pEq+v0jW4~02、程序由多个模块组成,所有模块都使用一组标准的包含文件和相同的编译选项。在这种情况下,可以将所有包含文件预编译为一个预编译头。
;`y)ngrIp0char * const p;
.\};`b5Y+h"G0char const * p木铎校园 BBS 社区,K,H` K\,kH
const char *p
q&GDRw6E0木铎校园 BBS 社区n-S%qu K7D
上述三个有什么区别?
-\D'AnN/F0char * const p; //常量指针,p的值不可以修改
wD9@&zjom4_;x&`0char const * p;//指向常量的指针,指向的常量值不可以改木铎校园 BBS 社区J!v)iY$\ d#@!x
const char *p; //和char const *p木铎校园 BBS 社区#mk+d(L2q H&w,l
木铎校园 BBS 社区#I0r#~W,d
char str1[] = "abc";木铎校园 BBS 社区/|#lYy+R$g
char str2[] = "abc";
x3l o;W OU?0
8qhd `;d+Qb0const char str3[] = "abc";木铎校园 BBS 社区#C.hGLA[
const char str4[] = "abc";木铎校园 BBS 社区U#h1|-h0nZ&id

R?yxI0const char *str5 = "abc";木铎校园 BBS 社区^DLi2_)R(Y e E
const char *str6 = "abc";
QD&F a;`7h'm0
b'I+|(w_%C c U1KbbG0char *str7 = "abc";
Y#j hJ'q2{ a0char *str8 = "abc";木铎校园 BBS 社区4{Q6bF9Je~ H

#`1\,][r0木铎校园 BBS 社区 }6ezE-|#d(|
cout<< ( str1 == str2 ) << endl;木铎校园 BBS 社区2@$Pyg0]/FYPi
cout<< ( str3 == str4 ) << endl;
5i%L!@V+B0cout<< ( str5 == str6 ) << endl;
F"u6bTEbA!X}u0cout<< ( str7 == str8 ) << endl;
pB/wHw7\F0
&G"U*ra:Z&H0结果是:0 0 1 1木铎校园 BBS 社区 `~V/hN
解答:str1,str2,str3,str4是数组变量,它们有各自的内存空间;
M&@l`*x7t8X#@0而str5,str6,str7,str8是指针,它们指向相同的常量区域。木铎校园 BBS 社区+I2yNT1Vk

$RYa;j'] xp0木铎校园 BBS 社区 C,? U)p t
12. 以下代码中的两个sizeof用法有问题吗?[C易]
q:tOM@:Wc0void UpperCase( char str[] ) // 将 str 中的小写字母转换成大写字母木铎校园 BBS 社区)ASf#q/\6r-d
{
b0LVno9\a Z H;~E0for( size_t i=0; i木铎校园 BBS 社区[r\zqe&bYz
if( 'a'<=str[i] && str[i]<='z' )木铎校园 BBS 社区/j |e+pVp
str[i] -= ('a'-'A' );木铎校园 BBS 社区%cR;[.a}XX
}木铎校园 BBS 社区O{h K!lMP_ m
char str[] = "aBcDe";木铎校园 BBS 社区*d$M P1r^;S*p
cout<< "str字符长度为: " << sizeof(str)/sizeof(str[0]) << endl;
q+i5KU*g O0UpperCase( str );
:K`L!VX$a\ z0cout<< str << endl;
"F c3Zk;g7|0木铎校园 BBS 社区6N tG r/G/W s4` U
答:函数内的sizeof有问题。根据语法,sizeof如用于数组,只能测出静态数组的大小,无法检测动态分配的或外部数组大小。函数外的str是一个静态定义的数组,因此其大小为6,函数内的str实际只是一个指向字符串的指针,没有任何额外的与数组相关的信息,因此sizeof作用于上只将其当指针看,一个指针为4个字节,因此返回4。木铎校园 BBS 社区F3W.awB2w
木铎校园 BBS 社区\C6t8X5y8ejN&S
一个32位的机器,该机器的指针是多少位
(r S$f+Z9s#AV9IJ0指针是多少位只要看地址总线的位数就行了。80386以后的机子都是32的数据总线。所以指针的位数就是4个字节了。
._DW/smK0木铎校园 BBS 社区+i(K{|P*I
main()
P)f0i{0m)g/e"Eo7T-S,r0{木铎校园 BBS 社区8Wjf Yr-o0D)JER%U9]
int a[5]={1,2,3,4,5};木铎校园 BBS 社区O$?e2N/@`c2gI:~
int *ptr=(int *)(&a+1);木铎校园 BBS 社区y Zk4B^9[8Gx(x

P}(~(DAGlIO0printf("%d,%d",*(a+1),*(ptr-1));
N0HSy;Q a5m"By+o0}
+OmM,ib-a,\j0输出:2,5
9[AhM;G0*(a+1)就是a[1],*(ptr-1)就是a[4],执行结果是2,5
n+}"SxB`Pg0&a+1不是首地址+1,系统会认为加一个a数组的偏移,是偏移了一个数组的大小(本例是5个int)
'~/W d XU6Za8n#S0int *ptr=(int *)(&a+1);木铎校园 BBS 社区SR/X}\L,F8u
则ptr实际是&(a[5]),也就是a+5木铎校园 BBS 社区"C,_gHYy|
原因如下:木铎校园 BBS 社区5eAF@r4?_5F
&a是数组指针,其类型为 int (*)[5];
T;RZMh0而指针加1要根据指针类型加上一定的值,
V$UQ9`N;~A0不同类型的指针+1之后增加的大小不同
udUx Lw0a是长度为5的int数组指针,所以要加 5*sizeof(int)木铎校园 BBS 社区 s)f~A$k3i\%B Y
所以ptr实际是a[5]
7JZ.{5T i vw K0但是prt与(&a+1)类型是不一样的(这点很重要)木铎校园 BBS 社区F^ t-ZK n+{J
所以prt-1只会减去sizeof(int*)木铎校园 BBS 社区 R0}s8J j)?)|@
a,&a的地址是一样的,但意思不一样,a是数组首地址,也就是a[0]的地址,&a是对象(数组)首地址,a+1是数组下一元素的地址,即a[1],&a+1是下一个对象的地址,即a[5].
X4y*Om0D#rg0
tR\.P.G+uy'm0
lSd8?\_-D;K$K01.请问以下代码有什么问题:木铎校园 BBS 社区[9MJ{u
int main()木铎校园 BBS 社区nk6v y4` uB
{木铎校园 BBS 社区~(u!B7y-t,I%w7`Y
char a;木铎校园 BBS 社区%d^%F9mzVr6xs
char *str=&a;
}7A @| kRq2~"?0strcpy(str,"hello");
8G z\M{0printf(str);
~2BwfJ]}0b$^0return 0;
5gXh7Kc rUr _ c0}
2I:pe:lj0没有为str分配内存空间,将会发生异常木铎校园 BBS 社区4G#Df tEl z J
问题出在将一个字符串复制进一个字符变量指针所指地址。虽然可以正确输出结果,但因为越界进行内在读写而导致程序崩溃。
jv:F6Sx7Y7ae p0木铎校园 BBS 社区-U'E m6C.d8U%De h6O^y
char* s="AAA";木铎校园 BBS 社区2V4A/wms l"{ j
printf("%s",s);
D(q J-z7\0s[0]='B';木铎校园 BBS 社区hV;o])gV)x${}A&Y-A:q&`
printf("%s",s);木铎校园 BBS 社区8PQC zp&d a
有什么错?
&NB&l\#c"DlgEw0"AAA"是字符串常量。s是指针,指向这个字符串常量,所以声明s的时候就有问题。木铎校园 BBS 社区:q`:SW%UmB
cosnt char* s="AAA";
+OT.I h)i&G9r|0然后又因为是常量,所以对是s[0]的赋值操作是不合法的。木铎校园 BBS 社区m#jb0iD6g{
1、写一个“标准”宏,这个宏输入两个参数并返回较小的一个。
bm(L^!?Y0.#define Min(X, Y) ((X)>(Y)?(Y):(X))//结尾没有;
7E"T,X'@4v(? w02、嵌入式系统中经常要用到无限循环,你怎么用C编写死循环。
zb~'r gajZ0while(1){}或者for(;;)
8J4jA$qX8i@]M03、关键字static的作用是什么?木铎校园 BBS 社区+M.P%rt)_:eG
定义静态变量木铎校园 BBS 社区N[b Jg_4Xc'H"|
4、关键字const有什么含意?
*jTBP;Lmo3B9Ha0表示常量不可以修改的变量。木铎校园 BBS 社区a yz3k0@ZO'|:X2K
5、关键字volatile有什么含意?并举出三个不同的例子?木铎校园 BBS 社区 M Hq Sl:T9}:a
提示编译器对象的值可能在编译器未监测到的情况下改变。木铎校园 BBS 社区{!H;w1QL
木铎校园 BBS 社区\3W.lS v0wc%W
木铎校园 BBS 社区|2~m?n2a
int (*s[10])(int) 表示的是什么啊
~|Z }/hC%N0int (*s[10])(int) 函数指针数组,每个指针指向一个int func(int param)的函数。
9@oN'I _p*Z*u0
Bzz;pqB+A)J6D'm0木铎校园 BBS 社区4Y,vM1P'~}gG
1.有以下表达式:
3za5W2Kx0int a=248; b=4;int const c=21;const int *d=&a;
J$c8s:Q+pJ Gzcf:g0int *const e=&b;int const *f const =&a;木铎校园 BBS 社区G1j^l0XY9R"?
请问下列表达式哪些会被编译器禁止?为什么?
o4Ka J:j0*c=32;d=&b;*d=43;e=34;e=&a;f=0x321f;
]B/WZep+d H0*c 这是个什么东东,禁止木铎校园 BBS 社区$[CM-U(o|(`C9A3v
*d 说了是const, 禁止
U7A%iq3Zy }0e = &a 说了是const 禁止木铎校园 BBS 社区&[n2}&m@+m8?
const *f const =&a; 禁止
].{:[1`*|a ]9R02.交换两个变量的值,不使用第三个变量。即a=3,b=5,交换之后a=5,b=3;
4{/^Ar.B#~2J0有两种解法, 一种用算术算法, 一种用^(异或)木铎校园 BBS 社区2d(d$iLA
a = a + b;木铎校园 BBS 社区D*UB{"Q&]:|5d
b = a - b;
X2iA2NR F^0a = a - b;木铎校园 BBS 社区3])E#K6|,O
or木铎校园 BBS 社区V*jA$Z5|$}L _B#o
a = a^b;// 只能对int,char..
&W#zW{0g"]0b = a^b;
eo@0i|.N0a = a^b;
bbJY{Mb0or
5aB|0YD!~0a ^= b ^= a;
x%yX+_(~]03.c和c++中的struct有什么不同?木铎校园 BBS 社区T%L6a ds_d|
c和c++中struct的主要区别是c中的struct不可以含有成员函数,而c++中的struct可以。c++中struct和class的主要区别在于默认的存取权限不同,struct默认为public,而class默认为private
%WH9]5DR2EA\:c04.#include木铎校园 BBS 社区Rd?O2h u.B0A
#include木铎校园 BBS 社区?+QId&L{k
void getmemory(char *p)木铎校园 BBS 社区v TH z"qa!z1K)`
{
@5N1fe5n:Kc*M0p=(char *) malloc(100);木铎校园 BBS 社区8}Zc!l#Gf O"af
strcpy(p,"hello world");木铎校园 BBS 社区 ` It~[%I `
}
N:SF)D&l x qO0int main( )木铎校园 BBS 社区xR"gX G*ag
{木铎校园 BBS 社区q u2[| r[o+@?8m
char *str=NULL;木铎校园 BBS 社区*P+k6?!Yb(}V
getmemory(str);木铎校园 BBS 社区*[Iv H8|q }.T!O#e
printf("%s/n",str);木铎校园 BBS 社区_0VZ'Q h
free(str);木铎校园 BBS 社区Ukc&H&\T
return 0;
C wH_4a"t:Ej\0}木铎校园 BBS 社区[ GgO?#g!{!bc`
程序崩溃,getmemory中的malloc 不能返回动态内存, free()对str操作很危险木铎校园 BBS 社区,Oa8D\~-y wh
5.char szstr[10];
Ja` F&m Z}0strcpy(szstr,"0123456789");
(W)n-]zBA0产生什么结果?为什么?木铎校园 BBS 社区L]/qoKMr
长度不一样,会造成非法的OS木铎校园 BBS 社区s.A$\4G&o$}sN
6.列举几种进程的同步机制,并比较其优缺点。木铎校园 BBS 社区?7n~-o A^4P3J
原子操作
1@2a$OB-SxB)]QO0信号量机制
NG^q [0自旋锁
#mb/yD#S!t^aX0管程,会合,分布式系统木铎校园 BBS 社区1pzq;k2M
木铎校园 BBS 社区h X0c4y`:e4A5NV
7.进程之间通信的途径木铎校园 BBS 社区j7fS,U4h'h'C8K
共享存储系统木铎校园 BBS 社区H3[3_kou8\1g7@hr
消息传递系统木铎校园 BBS 社区){b%Q`pTT
管道:以文件系统为基础木铎校园 BBS 社区 J%L$]p'ag-v'A
11.进程死锁的原因
-S%F4YQa]L0资源竞争及进程推进顺序非法
Zq;q0e6J ~012.死锁的4个必要条件
7vZ@D$|0互斥、请求保持、不可剥夺、环路木铎校园 BBS 社区"p'pUDx
13.死锁的处理木铎校园 BBS 社区p8Api~
鸵鸟策略、预防策略、避免策略、检测与解除死锁木铎校园 BBS 社区W7A&X)N/R8K0Y8s
15. 操作系统中进程调度策略有哪几种?
Qt b |"e0FCFS(先来先服务),优先级,时间片轮转,多级反馈
8P4VU7_2H$^p;Eq08.类的静态成员和非静态成员有何区别?
O1LPkNE!O kT0类的静态成员每个类只有一个,非静态成员每个对象一个
1w\B\` G"n~09.纯虚函数如何定义?使用时应注意什么?木铎校园 BBS 社区2}$hk'i,D.K
virtual void f()=0;
8]9v3Q%X6\2Wp0是接口,子类必须要实现木铎校园 BBS 社区9_F%c!`&w
10.数组和链表的区别木铎校园 BBS 社区0W6?XO(g+cAW
数组:数据顺序存储,固定大小木铎校园 BBS 社区C S0G-C k3yZo Em
连表:数据可以随机存储,大小可动态改变
bU s;_lcMn0木铎校园 BBS 社区q-T|E9U5p YXu
12.ISO的七层模型是什么?tcp/udp是属于哪一层?tcp/udp有何优缺点?木铎校园 BBS 社区1s"?W,p+\)A
应用层
]:~4Ij,F!F|6L0表示层木铎校园 BBS 社区E`"n5O^ \2v2G&c
会话层木铎校园 BBS 社区s`#M-F,J"]jGb
运输层木铎校园 BBS 社区!?!l3R nn0m
网络层
\`#F^/b)ZPh[0物理链路层木铎校园 BBS 社区eYVvR6Z
物理层
~g@2Z!V1i0tcp /udp属于运输层
2l t5es6x1`0TCP 服务提供了数据流传输、可靠性、有效流控制、全双工操作和多路复用技术等。
"ZX/Qy7f-@~0与 TCP 不同, UDP 并不提供对 IP 协议的可靠机制、流控制以及错误恢复功能等。由于 UDP 比较简单, UDP 头包含很少的字节,比 TCP 负载消耗少。
pi$|g|a4j0tcp: 提供稳定的传输服务,有流量控制,缺点是包头大,冗余性不好木铎校园 BBS 社区L6X7}D7V2w X0K4A$B
udp: 不提供稳定的服务,包头小,开销小
1p^:@Ic0木铎校园 BBS 社区:G oEAQ
木铎校园 BBS 社区1{EH_)T
1:(void *)ptr 和 (*(void**))ptr的结果是否相同?其中ptr为同一个指针
QRgH']/brt9Q0.(void *)ptr 和 (*(void**))ptr值是相同的木铎校园 BBS 社区7gH r,{(P0Xz
2:int main()
(MEkN"Myp0{木铎校园 BBS 社区q)T2{V9hb
int x=3;
$D9u'l c:D |Z0printf("%d",x);木铎校园 BBS 社区h|7s _k/|0PW
return 1;
WJ5]&R(w'Bp{ SQw#u$T0木铎校园 BBS 社区 B.{1F l4\
}
-IN;Sz M0问函数既然不会被其它函数调用,为什么要返回1?木铎校园 BBS 社区jfRUyO&Qk
mian中,c标准认为0表示成功,非0表示错误。具体的值是某中具体出错信息
Y;Op q*ojiQ0
*?&q(D w.M v0木铎校园 BBS 社区)}&@"\PE
1,要对绝对地址0x100000赋值,我们可以用
hRoZ,i5aS0(unsigned int*)0x100000 = 1234;
Wl/y,I'uC'A!^4m0那么要是想让程序跳转到绝对地址是0x100000去执行,应该怎么做?
`?xt Irp!b9A&B0*((void (*)( ))0x100000 ) ( );
3l?7s,P$y"|,^{B0首先要将0x100000强制转换成函数指针,即:
4Sc7T"P"v |[(q0(void (*)())0x100000
(j4^;l6PHv!^b0TviL0然后再调用它:
3tP1tZ)zIn%R2^O0*((void (*)())0x100000)();木铎校园 BBS 社区auP"r E x
用typedef可以看得更直观些:木铎校园 BBS 社区 @H:@[8p'J O5S
typedef void(*)() voidFuncPtr;
r M@zg:S3v0*((voidFuncPtr)0x100000)();木铎校园 BBS 社区k!F5XO*q'\9n
2,已知一个数组table,用一个宏定义,求出数据的元素个数
m"mN(O$u0#define NTBL木铎校园 BBS 社区b2`D%P2z`
#define NTBL (sizeof(table)/sizeof(table[0]))
R0XvE7i0木铎校园 BBS 社区;?/?(e@|.h v%L
面试题: 线程与进程的区别和联系? 线程是否具有相同的堆栈? dll是否有独立的堆栈?
sv9j3Xf;e0进程是死的,只是一些资源的集合,真正的程序执行都是线程来完成的,程序启动的时候操作系统就帮你创建了一个主线程。
U?s,cr-Cj!{0
T#I4h Vh![Y0每个线程有自己的堆栈。
H%?g-i1?[0DLL 中有没有独立的堆栈,这个问题不好回答,或者说这个问题本身是否有问题。因为DLL中的代码是被某些线程所执行,只有线程拥有堆栈,如果DLL中的代码是 EXE中的线程所调用,那么这个时候是不是说这个DLL没有自己独立的堆栈?如果DLL中的代码是由DLL自己创建的线程所执行,那么是不是说DLL有独立的堆栈?
gop"w8^0
D;WA0S @D3c0以上讲的是堆栈,如果对于堆来说,每个DLL有自己的堆,所以如果是从DLL中动态分配的内存,最好是从DLL中删除,如果你从DLL中分配内存,然后在EXE中,或者另外一个DLL中删除,很有可能导致程序崩溃木铎校园 BBS 社区6V[?)]c_^
木铎校园 BBS 社区*@q2y6VR7| J f
木铎校园 BBS 社区Kh%hj+N0J-y"A
unsigned short A = 10;
6I9fa9fp0printf("~A = %u\n", ~A);木铎校园 BBS 社区rP%e2S@bb

vlEYw,u3Qr0char c=128;
}]e8yoBj0printf("c=%d\n",c);
0u8E1n6g#Jyo0木铎校园 BBS 社区`"hubL
输出多少?并分析过程
(S8hN'ld/Go uI![2h7c_k0第一题,~A =0xfffffff5,int值 为-11,但输出的是uint。所以输出4294967285
.r$o0|o(j3@R0第二题,c=0x10,输出的是int,最高位为1,是负数,所以它的值就是0x00的补码就是128,所以输出-128。木铎校园 BBS 社区a\:Lj"P!T$L
这两道题都是在考察二进制向int或uint转换时的最高位处理。
&tJ+j&{b!m&[[0木铎校园 BBS 社区G&B)|9v&`$a2u!d&r
分析下面的程序:
'v/r3Y C0T[#m~0void GetMemory(char **p,int num)
mO![NI8BZ*I3b G*g0{
+Kl%Kwl,X u.J7o]0*p=(char *)malloc(num);
;ZG:G/A4wySz0
V)YW_3k;rW0}
Rp8m$hMbv8Um0int main()
VHq4wHHH0{木铎校园 BBS 社区c}o W9_3q
char *str=NULL;木铎校园 BBS 社区` sXQ)Z*]U

kI0a_9H/m2y)Ik}Qc0GetMemory(&str,100);
FVt}e,w yD\2c'D0木铎校园 BBS 社区3lj m^LN&y/km
strcpy(str,"hello");木铎校园 BBS 社区+r+z_P1lr
木铎校园 BBS 社区Jx_nq
free(str);
2{'m+{gol/x0木铎校园 BBS 社区S)VBeF%[
if(str!=NULL)木铎校园 BBS 社区 g%K u1p!ML[d.L!R
{
:c9O0icJtk0^ }9u:m0strcpy(str,"world");
ek @~ F0}木铎校园 BBS 社区 eooZ,e

~&i3pr}u R mi0printf("\n str is %s",str);
Y+Mq@LY6K0getchar();
C7a)I-kxR0}木铎校园 BBS 社区[Pko)T&WR8]6w
问输出结果是什么?希望大家能说说原因,先谢谢了木铎校园 BBS 社区6ok QD9W2O*i/`Kg5J
输出str is world。
/kIHEJ c0free 只是释放的str指向的内存空间,它本身的值还是存在的.
z+L`PBjF0所以free之后,有一个好的习惯就是将str=NULL.
HG!d4E YW y0此时str指向空间的内存已被回收,如果输出语句之前还存在分配空间的操作的话,这段存储空间是可能被重新分配给其他变量的,
JW2ZV9G&\0尽管这段程序确实是存在大大的问题(上面各位已经说得很清楚了),但是通常会打印出world来。木铎校园 BBS 社区]$Qw-J/i r1F@/~ {`
这是因为,进程中的内存管理一般不是由操作系统完成的,而是由库函数自己完成的。
X{#x'c{3X pf([0当你malloc一块内存的时候,管理库向操作系统申请一块空间(可能会比你申请的大一些),然后在这块空间中记录一些管理信息(一般是在你申请的内存前面一点),并将可用内存的地址返回。但是释放内存的时候,管理库通常都不会将内存还给操作系统,因此你是可以继续访问这块地址的,只不过。。。。。。。。楼上都说过了,最好别这么干。
&SO?+?7D-I2I4p JQ0
6J)E6id)MhcV0char a[10],strlen(a)为什么等于15?运行的结果
$UyqiR\'tUN0
Zb1~,c9r2q-D%M0#include "stdio.h"木铎校园 BBS 社区R!qM i2W0b2}ugC.G
#include "string.h"木铎校园 BBS 社区 rlvL"fqt`:Q
木铎校园 BBS 社区a2I)WhY8Pm
void main()
2`/a#jX^Sb0{木铎校园 BBS 社区_+y8|7`M4~

4S*j y uM&C O0char aa[10];
Cx_@&x"S0printf("%d",strlen(aa));木铎校园 BBS 社区im,~!RAr%?B_l
}木铎校园 BBS 社区.g{Gv0~$X

3fy}1^,r/d'[_)A0sizeof()和初不初始化,没有关系;
"P s2y%A H:a p0strlen()和初始化有关。木铎校园 BBS 社区-NqE)g1l*Y
木铎校园 BBS 社区4d*?1mH6z k

$j CST Y1M0char (*str)[20];/*str是一个数组指针,即指向数组的指针.*/
+JB,s)z%nQP0char *str[20];/*str是一个指针数组,其元素为指针型数据.*/木铎校园 BBS 社区j2q"uK[*L9x
木铎校园 BBS 社区ilBO9] }QW@]
long a=0x801010;
Nwgv&a%}Z g:l0a+5=?木铎校园 BBS 社区N^;p.JP$wo|
0x801010用二进制表示为:“1000 0000 0001 0000 0001 0000”,十进制的值为8392720,再加上5就是8392725罗木铎校园 BBS 社区;h&\;IO} U6Sz
1)给定结构struct A
e1]f hqj;Gt0{
r/F$AI$t}0char t:4;木铎校园 BBS 社区G}Gv!P S+`Xv
char k:4;木铎校园 BBS 社区0Q&a#ITU
unsigned short i:8;
.Sh _!wCa0unsigned long m;木铎校园 BBS 社区-zWiZHNP.b/_QVz
};问sizeof(A) = ?木铎校园 BBS 社区/o*lT+Pa,{'{"QW
给定结构struct A木铎校园 BBS 社区jyc~e(x+ZR5d
{
,UTy1R*y0char t:4; 4位木铎校园 BBS 社区6lAh{JG3EL
char k:4; 4位木铎校园 BBS 社区}XZ!P FN"~|6S
unsigned short i:8; 8位
7I'I9cGi rgN0unsigned long m; // 偏移2字节保证4字节对齐
o w)v [VL0}; // 共8字节
3[j'b0o6R02)下面的函数实现在一个数上加一个数,有什么错误?请改正。
(Gb:x([ l9I#@k0int add_n ( int n )木铎校园 BBS 社区$ki%|!d/B|+D/W'i y
{
_ad-x!B/NWE [0static int i = 100;
n2F G%S:jX$k0i += n;木铎校园 BBS 社区x)q/~7u"w
return i;木铎校园 BBS 社区]W,T;C {&a*I
}
`] es$U&N`8U0当你第二次调用时得不到正确的结果,难道你写个函数就是为了调用一次?问题就出在 static上?
%],W fS-pdy'ak0
&V G7r4E3E%L0
V6v4T/r7F-N5Z(q0// 帮忙分析一下
5D[6ak c7}0#include
+T4SZC/~d?t0#include木铎校园 BBS 社区.N'Q0~h'P
#include木铎校园 BBS 社区1M2Wyb-e6jB r2x
#include
(sN1V)Cs Z9_!n(N/T0#include
^|!HK SC!b$b%_K0#include木铎校园 BBS 社区$w}n,Xoa!V@
typedef struct AA
L8V2F9c3t PDH/dDY0{木铎校园 BBS 社区kc ~#z O
int b1:5;木铎校园 BBS 社区K;Y d!j(xc yfDT
int b2:2;木铎校园 BBS 社区V\ @R1G9^
}AA;木铎校园 BBS 社区5MD]ks7S`
void main()
0KC'l ]'TlD7RDu0{木铎校园 BBS 社区 ql SZ-k fL-MV
AA aa;木铎校园 BBS 社区\)Z!{&ZMF:c
char cc[100];木铎校园 BBS 社区:`)In^+hR3a7N
strcpy(cc,"0123456789abcdefghijklmnopqrstuvwxyz");
(a ~b;LJVz9G!r*h-^0memcpy(&aa,cc,sizeof(AA));木铎校园 BBS 社区Y*eEz&@3Y
cout<< aa.b1 <木铎校园 BBS 社区jh`V&y Bl
cout<< aa.b2 <Z!L,d@6w7Y0}
?i|5r pdl|.G0答案是 -16和1
6]wV:V)a iH0首先sizeof(AA)的大小为4,b1和b2分别占5bit和2bit.
c7a-V/s^5Qb4? g0经过strcpy和memcpy后,aa的4个字节所存放的值是:
h GH`!LPo _00,1,2,3的ASC码,即00110000,00110001,00110010,00110011
_JG/q#O0所以,最后一步:显示的是这4个字节的前5位,和之后的2位
T|@!o B4MzO@u)w0分别为:10000,和01木铎校园 BBS 社区$g6Aq1ni^
因为int是有正负之分  所以:答案是-16和1
:?3f+T'd I3K[,@0木铎校园 BBS 社区~ju)v~g c
求函数返回值,输入x=9999;木铎校园 BBS 社区0U1b_y'o
int func ( x )
? vEl(h&Q7LCJ0{木铎校园 BBS 社区8Q`zqaHc
int countx = 0;木铎校园 BBS 社区{)s A4T+~PT$u
while ( x )
*p u7E1I$h-G?0{
^ P!KC6|-y-e[V0countx ++;
x2h5P2T[ l0x = x&(x-1);
h[1tv(r(L S0}
q0G {gx m4w0return countx;
4m T ue/Js s0}
#LNXraYb0结果呢?木铎校园 BBS 社区d0F G!y@:Cu%_l
知道了这是统计9999的二进制数值中有多少个1的函数,且有木铎校园 BBS 社区;FW bVbK4yi'x,L
9999=9×1024+512+256+15木铎校园 BBS 社区"El{!B.pp2\m
木铎校园 BBS 社区t9s3X'fj~
9×1024中含有1的个数为2;
]L qO] y$sL7U0512中含有1的个数为1;木铎校园 BBS 社区-])P2R&t*e&D~
256中含有1的个数为1;
Ww }$c$m015中含有1的个数为4;木铎校园 BBS 社区CS6l9jHE~ plS
故共有1的个数为8,结果为8。木铎校园 BBS 社区\)|%nDlc(^
1000 - 1 = 0111,正好是原数取反。这就是原理。
9L,}:W7oPM&H7Z f8n0用这种方法来求1的个数是很效率很高的。
&?!C%eS$L O0不必去一个一个地移位。循环次数最少。
3S9n S8[%?J1b$P0木铎校园 BBS 社区Q!g4_&pc
int a,b,c 请写函数实现C=a+b ,不可以改变数据类型,如将c改为long int,关键是如何处理溢出问题
2L O*](v `;m5O0bool add (int a, int b,int *c)
e4k)f;Qkr%B,lW)z0{木铎校园 BBS 社区L B9l2Z+S"jtZ
*c=a+b;木铎校园 BBS 社区 N j\n"| ?*t
return (a>0 && b>0 &&(*ca || *c>b)));木铎校园 BBS 社区,H2q3z)kgXg|1J
}
!Oc ~M{3`,qB TvOH0
lkej(KT7_*A)i0木铎校园 BBS 社区]&xb;}M0hb
分析:木铎校园 BBS 社区4Hd_O&s7Y*a%t
struct bit
G4s'A/T0^ r4[0{ int a:3;木铎校园 BBS 社区X(WJ el9J%m
int b:2;木铎校园 BBS 社区sAH"i^ Rt
int c:3;木铎校园 BBS 社区8d"Z`"p?4ymJ
};
#J2E9];I$Gx8f0int main()
y"v0Q A#j-g7PX0kr*eY i0{
z-m0V0TCe!|@O0bit s;木铎校园 BBS 社区y VF6\GO8I#D'e2\
char *c=(char*)&s;
,o4K%D${S&j0cout<(JuI@5K_8qA0*c=0x99;
zF;Mqdfdy0cout<< s.a <木铎校园 BBS 社区X LY|q
int a=-1;
v3m#F:ow/ML0printf("%x",a);木铎校园 BBS 社区'g T&m}+| `X"x
return 0;木铎校园 BBS 社区/yFmV9xl,]_ _
}木铎校园 BBS 社区KcS:{1}9`;Z+J2Z
输出为什么是木铎校园 BBS 社区g5i7@rb%U
4
gy-L*Z X-@4W01
'{&b y)AF7\O2}0-1
8j1y\+^j*e^0-4
9Dn/{-uMC0ffffffff
6CV)n0t!u0E0因为0x99在内存中表示为 100 11 001 , a = 001, b = 11, c = 100
Tt^KK?0当c为有符合数时, c = 100, 最高1为表示c为负数,负数在计算机用补码表示,所以c = -4;同理
XN!C9s*{"z _O0b = -1;木铎校园 BBS 社区eW8\*|:i2Z GnD
当c为有符合数时, c = 100,即 c = 4,同理 b = 3
/K2Wy_.P6fca0
C Wn}4[~(s5ai0木铎校园 BBS 社区o'z(H)Z&Y
位域 :
V5_7D7{2qLlK%Y0有些信息在存储时,并不需要占用一个完整的字节, 而只需占几个或一个二进制位。例如在存放一个开关量时,只有0和1 两种状态,用一位二进位即可。为了节省存储空间,并使处理简便,C语言又提供了一种数据结构,称为“位域”或“位段”。所谓“位域”是把一个字节中的二进位划分为几个不同的区域, 并说明每个区域的位数。每个域有一个域名,允许在程序中按域名进行操作。这样就可以把几个不同的对象用一个字节的二进制位域来表示。一、位域的定义和位域变量的说明位域定义与结构定义相仿,其形式为:
#V'j1zcEs4`0struct 位域结构名木铎校园 BBS 社区qc]8~^[
{ 位域列表 };木铎校园 BBS 社区ha;@?'T p%^
其中位域列表的形式为: 类型说明符 位域名:位域长度木铎校园 BBS 社区L1h_c8p%dW }ZJ
例如:
V?,_3QZ]{Od0struct bs
BI4A&J0sp{ x0{
3K4|"nv(LJ iHg0int a:8;
-RzQaz|7V}0int b:2;
+F z"w8td3KG+U0int c:6;
jp%Y ^eR3a`0};
o2ik o1r v0O:^0位域变量的说明与结构变量说明的方式相同。 可采用先定义后说明,同时定义说明或者直接说明这三种方式。例如:
yF4n~9n e7PXA#m0struct bs木铎校园 BBS 社区J]'^N JU{N
{
G#i)b,M:~#~U.E0int a:8;
\8\]$U9eL])k0int b:2;木铎校园 BBS 社区 ~;N |"u7M.LL2g
int c:6;木铎校园 BBS 社区j:A6]%bx'b;@t7W"k$PDF
}data;
-?Iz%H%r^#KR0说明data为bs变量,共占两个字节。其中位域a占8位,位域b占2位,位域c占6位。对于位域的定义尚有以下几点说明:
}@U1ur#i;ya0
4A `zg`3U Mb01. 一个位域必须存储在同一个字节中,不能跨两个字节。如一个字节所剩空间不够存放另一位域时,应从下一单元起存放该位域。也可以有意使某位域从下一单元开始。例如:
Hl5g8vK0struct bs
i~m.Jx"@q3K0{
9n$f%v-vyO$Kx0unsigned a:4木铎校园 BBS 社区2In$d%O"N\t
unsigned :0 /*空域*/木铎校园 BBS 社区 d.li2u'G1eKW
unsigned b:4 /*从下一单元开始存放*/
&Y*t,b1I&D{"E)D0L0unsigned c:4木铎校园 BBS 社区@`tiK(N
}木铎校园 BBS 社区$U4M(mHjr p#k"z
在这个位域定义中,a占第一字节的4位,后4位填0表示不使用,b从第二字节开始,占用4位,c占用4位。
;rC%qC m$BW0木铎校园 BBS 社区8G-xs-WL`+V6uI
2. 由于位域不允许跨两个字节,因此位域的长度不能大于一个字节的长度,也就是说不能超过8位二进位。
\R$~uGnF0
Z&SH%^{ P.s(u03. 位域可以无位域名,这时它只用来作填充或调整位置。无名的位域是不能使用的。例如:木铎校园 BBS 社区3pi"L Gvo6D
struct k
-ZM@3R6Lg0{
[hbqL`0int a:1木铎校园 BBS 社区${ gKT(X_a3~
int :2 /*该2位不能使用*/木铎校园 BBS 社区Yc9CF/K)O
int b:3
:J&PU p g0int c:2木铎校园 BBS 社区2i#e]4I3fK
};木铎校园 BBS 社区HZ4}%G,BK
从以上分析可以看出,位域在本质上就是一种结构类型, 不过其成员是按二进位分配的。
&`$L~;^0Li4D6y&Q0木铎校园 BBS 社区;LfG Sb II
二、位域的使用位域的使用和结构成员的使用相同,其一般形式为: 位域变量名•位域名 位域允许用各种格式输出。木铎校园 BBS 社区-i c!dU)tH7l
main(){木铎校园 BBS 社区#p?U5z7S#V-};zod
struct bs
|V&w3p'? ]#mQ(ISp0{木铎校园 BBS 社区y*cbG!v)N
unsigned a:1;木铎校园 BBS 社区 _v2U s?;J
unsigned b:3;
|Es9a%RK0unsigned c:4;
%vXW8zT ZX0} bit,*pbit;木铎校园 BBS 社区_ ZO7V u%z1H6?O
bit.a=1;木铎校园 BBS 社区 g0UT;@0kv3pc
bit.b=7;
0@b~]"^3y(iQ uW7?0bit.c=15;木铎校园 BBS 社区f)x w4r9c{
pri木铎校园 BBS 社区?@!hltB*I H h
木铎校园 BBS 社区;_DY:?j'}*q8p
改错:木铎校园 BBS 社区e(n O+rP7[M
#include
\2cy8O8u6B%la0木铎校园 BBS 社区|T*H#i6M lwFhl
int main(void) {木铎校园 BBS 社区}l+OA0j-k

O:IhfM0int **p;
8fd"W)xWER5{8O0int arr[100];
lM Es8_R0木铎校园 BBS 社区&V`e7vj
p = &arr;
(l+] fF u WK`%tvE\0木铎校园 BBS 社区Uo\(f,{HB"p,|#y?\
return 0;木铎校园 BBS 社区1uD@-}SN"_
}木铎校园 BBS 社区_yJO_ e(H
解答:木铎校园 BBS 社区j4r1GD.|1A/n2|
搞错了,是指针类型不同,木铎校园 BBS 社区4Y#_{jc?[G
int **p; //二级指针
_-@\w4C"~ k0&arr; //得到的是指向第一维为100的数组的指针木铎校园 BBS 社区nW/x'e5DY-XKC
#include木铎校园 BBS 社区5E#Y&u i Y"g|
int main(void) {木铎校园 BBS 社区(|J-k2F)Q
int **p, *q;
v Mn k7ASp$hr0int arr[100];
#Qav.?O5s6] v0q = arr;
G"Q5Im {p0p = &q;木铎校园 BBS 社区j8EkZ&Tj|&GT
return 0;木铎校园 BBS 社区%}-j*u0E6fk2X,p&~ v
}木铎校园 BBS 社区 yw(Z?*J0h'Se*HJ

p v7Gj^S0木铎校园 BBS 社区h6`a}K
下面这个程序执行后会有什么错误或者效果:
U to,L`BtQ}1P,{0#define MAX 255
x+Ro(x$PV+Fry0int main()
:p%b&}"j\7PHQ0{
*PJ? | t b.B${(^)r0unsigned char A[MAX],i;//i被定义为unsigned char
)C#K\Rxs-O&N0for (i=0;i<=MAX;i++)木铎校园 BBS 社区X8['O1@Sw*U
A[i]=i;
%sy5U[*K*uU,PB0}木铎校园 BBS 社区0Q/g!l:~\G
解答:死循环加数组越界访问(C/C++不进行数组越界检查)木铎校园 BBS 社区D^ Nh3sA/XVMo;i|;q
MAX=255木铎校园 BBS 社区oi+_XvF)@a
数组A的下标范围为:0..MAX-1,这是其一..
ob$ul8_ N0其二.当i循环到255时,循环内执行:
(^3d7`.i[8I/x0]0A[255]=255;
GJ&~9Z,eX0这句本身没有问题..但是返回for (i=0;i<=MAX;i++)语句时,木铎校园 BBS 社区:[_Z5e2t%I X`bN
由于unsigned char的取值范围在(0..255),i++以后i又为0了..无限循环下去.木铎校园 BBS 社区4z)U@ x+cE'J
木铎校园 BBS 社区&{Ph(c{ a l]
struct name1{木铎校园 BBS 社区QI tJ])o
char str;
.y}5v%d;wR%a#D F0short x;木铎校园 BBS 社区C'?h`}5U.U
int num;木铎校园 BBS 社区,cP|g:X t3Q"t
}
&lM9Mn2R x0木铎校园 BBS 社区 U^(PY d$kT3l
struct name2{
3~%oFV ^1|b0char str;木铎校园 BBS 社区g5Q,_(B0h+V
int num;
PV)Ml$q0short x;木铎校园 BBS 社区O:v4|.[LH6R"kV
}
dO9?P.^y;}0
6fuj @l&fY0sizeof(struct name1)=8,sizeof(struct name2)=12木铎校园 BBS 社区LCCMu*T d&R ? mu
在第二个结构中,为保证num按四个字节对齐,char后必须留出3字节的空间;同时为保证整个结构的自然对齐(这里是4字节对齐),在x后还要补齐2个字节,这样就是12字节。
[fV e5s9sQ |h0
{!X1s7Tb!JT J0intel:木铎校园 BBS 社区T ^@%yH
A.c 和B.c两个c文件中使用了两个相同名字的static变量,编译的时候会不会有问题?这两个static变量会保存到哪里(栈还是堆或者其他的)?
Y;Db#p&Qx&@0static的全局变量,表明这个变量仅在本模块中有意义,不会影响其他模块。木铎校园 BBS 社区(^[$Pg"{^Q
他们都放在数据区,但是编译器对他们的命名是不同的。
K@+XvA8M'wN0如果要使变量在其他模块也有意义的话,需要使用extern关键字。木铎校园 BBS 社区kIN|z jRg

&I/th wjpR_0struct s1木铎校园 BBS 社区e,~q'~%e(~#M,N
{
6KHP2n8Ii#fBD ~%R7a0int i: 8;
3{:HC ^lE"qNX%G(c0int j: 4;木铎校园 BBS 社区ce s1`O7@f,@WRH)V
int a: 3;木铎校园 BBS 社区A/hBMx1o*r
double b;
xqLn HK~0};
fo%E:m5D1ANm dN0
gY6q t5q}^l9N0struct s2
F&V5F9^%c.sI(V0{木铎校园 BBS 社区A&A fy'g+VB
int i: 8;
#gg lqG(vY0int j: 4;
qFy6s#j-_;U0double b;
\5^ [6l{i}5H;|3^7n0int a:3;木铎校园 BBS 社区 zJop7B fx.b\&v o3jIA
};
bgm;]}2\|z8F0木铎校园 BBS 社区q })EZF jP[V9z
printf("sizeof(s1)= %d\n", sizeof(s1));
0[1\5R| B0printf("sizeof(s2)= %d\n", sizeof(s2));
!bC+cg$P!|Il` f\8m`8x0result: 16, 24
j:b;}Q [{0第一个struct s1木铎校园 BBS 社区 @+s(UD8L3GBD Y:]
{
n&I#n'tU0int i: 8;
vAq-Q g4i0int j: 4;木铎校园 BBS 社区"s,y!F3y/{XK1EX
int a: 3;木铎校园 BBS 社区+f{}K2@6i8Z N.X
double b;木铎校园 BBS 社区Y5Jv2jSn
};木铎校园 BBS 社区'Y-] kyX9d@
理论上是这样的,首先是i在相对0的位置,占8位一个字节,然后,j就在相对一个字节的位置,由于一个位置的字节数是4位的倍数,因此不用对齐,就放在那里了,然后是a,要在3位的倍数关系的位置上,因此要移一位,在15位的位置上放下,目前总共是18位,折算过来是2字节2位的样子,由于double是8 字节的,因此要在相对0要是8个字节的位置上放下,因此从18位开始到8个字节之间的位置被忽略,直接放在8字节的位置了,因此,总共是16字节。木铎校园 BBS 社区N?W~3Yb] a
木铎校园 BBS 社区0NQ@$bJ*n
第二个最后会对照是不是结构体内最大数据的倍数,不是的话,会补成是最大数据的倍数
U+jM*fj|01)读文件file1.txt的内容(例如):
y?Q"F#H012
^6x;U e R!]t#A034
3U;vG?'q.Y:?1z056
)~$z&~d8iAs(a0输出到file2.txt:
"{#tycW/\Z&FH056木铎校园 BBS 社区d!m)A:l5\Br#{G5W
34
F9@!W2W(G#m h O$C012木铎校园 BBS 社区%r8WZSfk9k-n B
(逆序)
o+? i)q-Frd*x3o02)输出和为一个给定整数的所有组合木铎校园 BBS 社区as-Q+fFu o
例如n=5
jH H[B C-B I05=1+4;5=2+3(相加的数不能重复)木铎校园 BBS 社区mb]K3q
则输出木铎校园 BBS 社区~"p*RY/LH
1,4;2,3。木铎校园 BBS 社区z3R_ F2\BO|Md8TIi
望高手赐教!!
0E,USGez\-s0木铎校园 BBS 社区jpbG }D_K.K
第一题,注意可增长数组的应用.木铎校园 BBS 社区5i7l(P2j{)gu
#include
#j"`f URO3wSl"d-[0#include木铎校园 BBS 社区@Z$Yu2}7w7Qug5p
木铎校园 BBS 社区v;i-it#Y
int main(void)
8\ V^j2U+Xv0{
i1Uq Mk0int MAX = 10;木铎校园 BBS 社区&fv\,LNBHn6\W
int *a = (int *)malloc(MAX * sizeof(int));
YzuZU.oF5e0int *b;
N)W L4?6n0
N Mt4R.H\ay q0FILE *fp1;
:v |yq1wY%AW0FILE *fp2;
%o.y]$R oV![L4q0
2D L_ em@'R0fp1 = fopen("a.txt","r");木铎校园 BBS 社区'l+G W0hZ5E.W
if(fp1 == NULL)
VRIW5KrpN0{printf("error1");木铎校园 BBS 社区&}*Y/Xl0D5t
exit(-1);
,Vd;`nYX}0}木铎校园 BBS 社区+f f([!{0R"c:u
木铎校园 BBS 社区2q['I%E0n`^8?
fp2 = fopen("b.txt","w");
4DP ?Hm-l3pLw0if(fp2 == NULL)木铎校园 BBS 社区/VkaP&@Ri,?
{printf("error2");
Kx?u2XErR0exit(-1);木铎校园 BBS 社区 Z4\?+K7i I9R]
}木铎校园 BBS 社区n9j5N#] [{)mY q g
木铎校园 BBS 社区;J"J2hB.U
int i = 0;木铎校园 BBS 社区 v g2cb]d(qSs Q s
int j = 0;
D%H$e1Qb0Z cKu]0
o2z"z \*m,E%Ih0while(fscanf(fp1,"%d",&a[i]) != EOF)
#W@:fGU1M#}-Y0{木铎校园 BBS 社区`o%i \ePeP
i++;木铎校园 BBS 社区 LW8G9E v3Q,y
j++;
HT2N@#T0if(i >= MAX)木铎校园 BBS 社区5f"~ RQj
{
M*l,D%_'l0MAX = 2 * MAX;木铎校园 BBS 社区rn8v:s,K[5B
b = (int*)realloc(a,MAX * sizeof(int));
ql3d4B:U0y0if(b == NULL)木铎校园 BBS 社区/Z8r1QR!{5~
{
/u|zgQ4w0printf("error3");木铎校园 BBS 社区&] Tv6PQ$V
exit(-1);木铎校园 BBS 社区j1W XD+^b(A
}
}6@U4_0h7B0@0a = b;木铎校园 BBS 社区JX3[}K
}木铎校园 BBS 社区j uX)kZ
}
Z KE6x3[0木铎校园 BBS 社区#B.j+zaM/q%vl
for(;--j >= 0;)木铎校园 BBS 社区:GH#Z {;] i'Y
fprintf(fp2,"%d\n",a[j]);木铎校园 BBS 社区4bxe-l#]&xdr

D3C ~N h7U0fclose(fp1);木铎校园 BBS 社区FcJ/ss3h
fclose(fp2);
YI1tY$h-~ e0
sbk @.]4]aO r:O0return 0;木铎校园 BBS 社区-R6O9V U3W\;M

I` Hvz,I*ti0
S3Yu5FB0}木铎校园 BBS 社区c4q/N5P3g3d(C
木铎校园 BBS 社区2D ]aj"eZNc
第二题.
Z-G!\-E1Z-L.U0#include
g)?]B2F$_-v0木铎校园 BBS 社区 O/YV8fkC9f(W9V
int main(void)木铎校园 BBS 社区;}+eHd aT
{木铎校园 BBS 社区%OJ;j%@&f1x YkIu
unsigned long int i,j,k;
8g:{-i3U7G0
V/bVSO4eZe0printf("please input the number\n");木铎校园 BBS 社区m XL7L9Af
scanf("%d",&i);木铎校园 BBS 社区ej2G-[$zxssY
if( i % 2 == 0)
G9Rcg"u;u$v}"{d\0j = i / 2;木铎校园 BBS 社区!Mu)C\s8Ki
else木铎校园 BBS 社区&A/x[J3l JG/\r
j = i / 2 + 1;木铎校园 BBS 社区S,lp;~6bK9g

X4X/N AY?0printf("The result is \n");木铎校园 BBS 社区e$S xZ"fH
for(k = 0; k< j; k++)木铎校园 BBS 社区:NLcrL)o7~er
printf("%d = %d + %d\n",i,k,i - k);
#Z2`2U3F;S0return 0;
?;OZ6A"w,fqOSIf0}
Fq @ p G^w/}0
'YgC `Y0#include木铎校园 BBS 社区F3m`k-niU
void main()
h H2u i"W[%M@0{
jE1R!\r[0unsigned long int a,i=1;
1o-d9ViV,~)Z0scanf("%d",&a);木铎校园 BBS 社区$y A@5L` d@nk}A
if(a%2==0)木铎校园 BBS 社区?M+E~Av
{木铎校园 BBS 社区W];]orw h)Q
for(i=1;i
木铎校园 BBS 社区i)O j2jC
printf("%d",a,a-i);
&N^dj?isA]/zR,Qc0}木铎校园 BBS 社区Dp Ko-@/{
else
Kzj`cevf0for(i=1;i<=a/2;i++)木铎校园 BBS 社区| },Q&~\&ev
printf(" %d, %d",i,a-i);木铎校园 BBS 社区 L)K/BouRF
}
a,|`-TOCF$f3~ G0
Y3D-LN1Dc0兄弟,这样的题目若是做不出来实在是有些不应该, 给你一个递规反向输出字符串的例子,可谓是反序的经典例程.
2~iy/xM9Lp0
bw$js L o0void inverse(char *p)木铎校园 BBS 社区~~$}8UE e
{
&B2H$m)Ti%R7G0if( *p = = '\0' )
7l,_]&{VNv M0return;木铎校园 BBS 社区1f0Mji8L$m)O?yG W
inverse( p+1 );木铎校园 BBS 社区;lds+~s
printf( "%c", *p );木铎校园 BBS 社区w)^c.@%N4A6GI
}
9w-H!@!L4R0w~Wn0木铎校园 BBS 社区T7\+V'[&}Y
int main(int argc, char *argv[])
Rk%VcI:^1r^ThN0{
I&z4|WZ&A:V,@0inverse("abc\0");
3Wi%]rAc0vxj W0
)`}0l/J1b:l+cq0return 0;木铎校园 BBS 社区M rm qG {Cq0x4YZR
}木铎校园 BBS 社区[.a[K0K r}1^
木铎校园 BBS 社区Pw7X#l2Id_{].g
借签了楼上的“递规反向输出”木铎校园 BBS 社区"OgJ.u*t]H,u
#include木铎校园 BBS 社区P7A%F,v%G:\)L `
void test(FILE *fread, FILE *fwrite)木铎校园 BBS 社区q1B&f,]B$Yz w
{木铎校园 BBS 社区 F^!Jds"h
char buf[1024] = {0};
#~L ReN:` C0if (!fgets(buf, sizeof(buf), fread))
e2Q| g0b'_3[0return;木铎校园 BBS 社区O'C7mH;|X)\
test( fread, fwrite );
3Y Q)ENkP8C(quq]6D0fputs(buf, fwrite);
(u*c3Z C-]0W0}
~'Nhrp7w"m6D$sP0int main(int argc, char *argv[])
&[S.J,{6H |.B+i!s,tf0{
;B3a zC"W W!c)b0FILE *fr = NULL;木铎校园 BBS 社区"]^_,O7n E*M3G
FILE *fw = NULL;木铎校园 BBS 社区(gE-sTvr
fr = fopen("data", "rb");木铎校园 BBS 社区 Q,SYg sk,ZO
fw = fopen("dataout", "wb");木铎校园 BBS 社区m9G{ ^O-z0p
test(fr, fw);木铎校园 BBS 社区u$FW5{/f!t.t
fclose(fr);木铎校园 BBS 社区H%t;I}0H:h(~5l
fclose(fw);
"I m [*K"T4Yv)?0return 0;木铎校园 BBS 社区5fh_E WaN;eSg
}木铎校园 BBS 社区{s5?%[.@%n
木铎校园 BBS 社区}^ e9muY
在对齐为4的情况下
Ta6D4`'eY4[0struct BBB木铎校园 BBS 社区%Bb)XdTbVj"e-e
{木铎校园 BBS 社区$X[ QDR
long num;
e'U(||-aj*o(mE0char *name;木铎校园 BBS 社区QIqKe'`6P3\b,S
short int data;木铎校园 BBS 社区 \;jaLaM%G6~
char ha;木铎校园 BBS 社区3_*Za6I)H8cXS
short ba[5];
.J aqANl0}*p;
Va R7]-]0p=0x1000000;木铎校园 BBS 社区Ghj}EL;s
p+0x200=____;
jb C w4f#}h+]0(Ulong)p+0x200=____;
g:M n.FG0(char*)p+0x200=____;木铎校园 BBS 社区0e+Ed.k.Y%W:W2c
希望各位达人给出答案和原因,谢谢拉
*['q4p&`8o&re0解答:假设在32位CPU上,木铎校园 BBS 社区E$\Q.M3`*z-BLwX9B
sizeof(long) = 4 bytes木铎校园 BBS 社区d8ug+I wwQ
sizeof(char *) = 4 bytes
@ K]9A-\#ep0sizeof(short int) = sizeof(short) = 2 bytes
i-KbcH0dV#a.~0sizeof(char) = 1 bytes
#p9wP9w.{Q8](g0
}/IM hJ(y#s0由于是4字节对齐,木铎校园 BBS 社区+@ }/FB*C,p'VK
sizeof(struct BBB) = sizeof(*p)木铎校园 BBS 社区m4u vw"sC/L
= 4 + 4 + 2 + 1 + 1/*补齐*/ + 2*5 + 2/*补齐*/ = 24 bytes (经Dev-C++验证)
'M ~5u2K*e[0
OCE:a*M*p*g#Wp }0p=0x1000000;
M5|q$X+j[7p-D*F0p+0x200=____;
"j(d#z_G xt&y0= 0x1000000 + 0x200*24木铎校园 BBS 社区/c?ys m3d!Q D

1obF'\$D7h'V)T0(Ulong)p+0x200=____;木铎校园 BBS 社区%ec4e5i ZY x#O
= 0x1000000 + 0x200
"y[6@P,fl1GcR {;h0E5b0
b&{F{w)a+V;pf0(char*)p+0x200=____;
Td/ioBxI?MFM0= 0x1000000 + 0x200*4木铎校园 BBS 社区[6@ K6Q `'kFf
木铎校园 BBS 社区D5`BG Z DF,r'V^]
你可以参考一下指针运算的细节
#rau0jG L7X Vn0
1? M-togS7`6pe~4L0木铎校园 BBS 社区 X A%[M.Ks@$^~;`
写一段程序,找出数组中第k大小的数,输出数所在的位置。例如{2,4,3,4,7}中,第一大的数是7,位置在4。第二大、第三大的数都是4,位置在1、 3随便输出哪一个均可。函数接口为:int find_orderk(const int* narry,const int n,const int k)
;O4~"q.| s+e5h0要求算法复杂度不能是O(n^2)木铎校园 BBS 社区@f)HY zj3D'd4E&U
谢谢!
6m*]0P'f%C0可以先用快速排序进行排序,其中用另外一个进行地址查找
9S2\r s;Tv2\8~L0[g%K0代码如下,在VC++6.0运行通过。给分吧^-^木铎校园 BBS 社区e+X9I#V b7x6P V

4O/R b1qX#{nm0//快速排序木铎校园 BBS 社区 EX9e*t*_3N1Q

FBDZ)L$a M0#include木铎校园 BBS 社区} ZE!UAK
木铎校园 BBS 社区0?2{@ X_y
usingnamespacestd;木铎校园 BBS 社区$FiLwc ^d;Q
木铎校园 BBS 社区&gD p9@ C@i2~ ^
intPartition (int*L,intlow,int high)木铎校园 BBS 社区8h:HZP Y
{木铎校园 BBS 社区PZtc-wR@hr*@
inttemp = L[low];木铎校园 BBS 社区#R z\.M I)k5d[4Rn
intpt = L[low];木铎校园 BBS 社区1q#N5_ s:FE:z:_vB
木铎校园 BBS 社区9b'qHm:v"@u#`!b
while (low< high)木铎校园 BBS 社区6~E0M*[5M[c
{木铎校园 BBS 社区k oReG'~
while (low< high && L[high] >= pt)木铎校园 BBS 社区t%QH ~8zKF
--high;木铎校园 BBS 社区|.C.tMtb
L[low] = L[high];
'fU],\/i t N0while (low< high && L[low] <= pt)木铎校园 BBS 社区FO4k:y u tB
++low;
$vm [p#m'C5Sc0L[low] = temp;
0_4L[c$I0}
8a$q2p8I*J'X$G!c0L[low] = temp;木铎校园 BBS 社区vsh] \3k%W

'g.c5v(C }5ce Ga O0returnlow;
)FMMF[0}
8kmLsX KUI%v0
#\NV V1Z ~x+Wj/t0voidQSort (int*L,intlow,int high)
|u1w6v IC:mB0{
r lPv%L N8`0if (low< high)
C$YK{:`!z0{木铎校园 BBS 社区'tR `3k#sM/s
intpl = Partition (L,low,high);
eug'@K0
!{ a@&w-kfv0QSort (L,low,pl - 1);
0d{$L(aX0QSort (L,pl + 1,high);木铎校园 BBS 社区G$e:AT;^Ht
}木铎校园 BBS 社区#Mn o!Q!h X0ps-d;r
}木铎校园 BBS 社区"epJ+@X&| R

5`3c gQ(CA!o1DZ0intmain ()
g9E9GOd7r3ep0{
wS8Qqc y H)lp'J |Hx0intnarry[100],addr[100];木铎校园 BBS 社区*GW!J,xlX Gr-g
intsum = 1,t;木铎校园 BBS 社区XP2} KNb9x0i~U
木铎校园 BBS 社区&d"J*hFn5nR s5H8} {
cout<< "Input number:" << endl;
G!P!K8g` Z.P0cin >> t;木铎校园 BBS 社区I,NT%v K?
木铎校园 BBS 社区I~Ti(|*Oh Y:p
while (t != -1)
eSWTKA!Zp@~w0{木铎校园 BBS 社区7fVN*BC }t
narry[sum] = t;
?@J c$cD2dh0addr[sum - 1] = t;
&Y@.J[? O0sum++;
hXEo1N.Jr!m ~2vf0木铎校园 BBS 社区#FHewl TW x
cin >> t;木铎校园 BBS 社区"rc/H'v Nu@6s/q p
}
1}?.c%i#Z%FY @:[0木铎校园 BBS 社区!Z~s"loh,B&Y
sum -= 1;木铎校园 BBS 社区U8y9X(P`
QSort (narry,1,sum);木铎校园 BBS 社区 s+s1sfD0y F:vg

dP#TXNQO;z0for (int i = 1; i<= sum;i++)
yHy:|s/f XX0cout<< narry[i] << '\t';
5`B&H8g6s0cout<< endl;木铎校园 BBS 社区CN(k T.F*`k

}-ral P3d"q0intk;
0fwum3c$R*f0cout<< "Please input place you want:" << endl;
~)U!Y5?Xg*B0cin >> k;木铎校园 BBS 社区F6EmUG%B E0j

l#m NcY4`Y0intaa = 1;
H$UV m sAj%l4x:a0intkk = 0;木铎校园 BBS 社区O"QmK$bq
for (;;)木铎校园 BBS 社区1`2c%h)WGT#Z1_y,Q
{木铎校园 BBS 社区 x8R,l(dS3J)V8z
if (aa == k)
cx \Rb~Kb$^%R0break;木铎校园 BBS 社区.AGl8wJP/z)|
if (narry[kk] != narry[kk + 1])木铎校园 BBS 社区-g$`.rkfN
{木铎校园 BBS 社区Pe$b({uiga/J.Z4s
aa += 1;
B VnVL3S g#c'o0kk++;木铎校园 BBS 社区VUqc(w,o
}木铎校园 BBS 社区&t8WC cw

#Nfl4Q]M8]0}
r Ml)IR0
t W+~0w4A#@G3SB-S0cout<< "The NO." << k << "number is:" << narry[sum - kk] << endl;木铎校园 BBS 社区[,n.l;d4[
cout<< "And it's place is:" ;
Q:pZ:^_'~ C;l0for (i = 0;i< sum;i++)木铎校园 BBS 社区9S3_8Jr.I3w"a
{
M?1k1s7O5ml |H0if (addr[i] == narry[sum - kk])
-]i%i}_9g(}-{0cout<< i << '\t';木铎校园 BBS 社区E(F.j M4Q$G)Y&l u
}
U(eiv"C9i'nF0木铎校园 BBS 社区H M+x'uo C

/SOGk&a!tr'V0return0;木铎校园 BBS 社区c S.IJ[B v'~/e2R
}木铎校园 BBS 社区z'_X Arq
木铎校园 BBS 社区}6C]n:\4xr
1、找错木铎校园 BBS 社区+A3c5q1`&\F1P(o9fP
Void test1()
w@ i(YU'n[h1P0{
L.VW1y)D0char string[10];木铎校园 BBS 社区7hht r5c&j
char* str1="0123456789";
o+H I E~ ]0strcpy(string, str1);// 溢出,应该包括一个存放'\0'的字符string[11]
,`4I^rE0}
z+~(e1l*QQ(sf0木铎校园 BBS 社区;] U(A*|Q it

7n e.~g'T0Void test2()木铎校园 BBS 社区@1}I1BS_KI
{木铎校园 BBS 社区-f7n)kRF$JjO
char string[10], str1[10];
$G*D ?3{2]!r'kY0for(I=0; I<10;I++)木铎校园 BBS 社区2MAF:N6u1u:k2h4`
{木铎校园 BBS 社区;O(D2tE^S3a
str1[i] ='a';木铎校园 BBS 社区q(~`uO N0u j S})D
}
%Hk7y2hf9Tq0strcpy(string, str1);// I,i没有声明。
Ht1K3vw T0}
:fpCx0Jg:w/z-`0
F G`'oP*[m {0Void test3(char* str1)
Vm&J!N!k4b~O^!nd|0{
4{L$oofr$GMq:u0char string[10];
4J4{!A!~8\^0if(strlen(str1)<=10)// 改成<10,字符溢出,将strlen改为sizeof也可以木铎校园 BBS 社区'j^ChYk
{
s DfsW&D0strcpy(string, str1);
O@B5C!F1XM0}木铎校园 BBS 社区X,tIO+p:A
}
c(VH/]i d,S0木铎校园 BBS 社区z![(F(w Qm|}d,t
2.
[ xuax0void g(int**);木铎校园 BBS 社区i/@8`_.X n0M \#hM W
int main()木铎校园 BBS 社区gb"J7C6di"Q
{
\ U7aN9d0int line[10],i;
1n0z k fA Wi7h_h0int *p=line; //p是地址的地址木铎校园 BBS 社区R]vL5@w1I@aa
for (i=0;i<10;i++)木铎校园 BBS 社区w7[+W)Q%Yd*^(ie
{
] d+w+C6H0*p=i;木铎校园 BBS 社区_B Sr}Cvl6^Y
g(&p);//数组对应的值加1木铎校园 BBS 社区$Lu q9l ][\2S
}木铎校园 BBS 社区#@_Q;uJl
for(i=0;i<10;i++)木铎校园 BBS 社区?l.[*V1K%er V/i
printf("%d\n",line[i]);
3R{1x^ i x:x0return 0;
:O3^#S%q6G4R]r0}木铎校园 BBS 社区 Qa8Vc:K8UE%YDQC

Us5g t[X0void g(int**p)木铎校园 BBS 社区 I.u7Q_2{0T
{
+Sv$PH(r)v KH0(**p)++;
$Y`0_*F:jW0(*p)++;// 无效
V1~R@ G aT0}木铎校园 BBS 社区ozM VY#]
输出:木铎校园 BBS 社区|*@5ht]'S
1木铎校园 BBS 社区u2N ev,Y`\
2木铎校园 BBS 社区A#}}?v9u)G6|
3
|kjX6GW1w%~(m04
0U5Z~X[F0GlK:d#Q05木铎校园 BBS 社区Bi\0eXh|#@_
6
1`8y zy:eW3jL5V'p~07
e*W%B6tws V#G3|08木铎校园 BBS 社区#gG|ei/m m%^!H
9木铎校园 BBS 社区jC-_IK[m1D
10木铎校园 BBS 社区ODJ^o6x@/l
3. 写出程序运行结果
Nq0bh:m:KY F0
!X8} e7l8N5g,?wFi S0int sum(int a)
&K0C&b$pPS0{
f-Vs?j9F1w0auto int c=0;木铎校园 BBS 社区 @eKBYg6wg
static int b=3;木铎校园 BBS 社区ocbvgq P
c+=1;木铎校园 BBS 社区+M;w1XW*A_+]
b+=2;木铎校园 BBS 社区 F"X LB cb-FB
return(a+b+c);木铎校园 BBS 社区7`eCS:QR
}
5[N'C&R!|/K-]"ao0
~}&\#u:i5v!e3r|RL0void main()
[]q)j x,@0{木铎校园 BBS 社区Aye"Ic(C-\U2`;p
int I;
$I#m"euH0int a=2;木铎校园 BBS 社区A;KCy EF
for(I=0;I<5;I++)
-tv}K-zd0{
3mIy.L!cB$O~i0printf("%d,", sum(a));木铎校园 BBS 社区 P {|1`Uc
}木铎校园 BBS 社区;Za7k/Zt!k5xr$N;R
}木铎校园 BBS 社区 lYs_]? t#{)~pJi!|T
// static会保存上次结果,记住这一点,剩下的自己写
0x/@'Tid*u!^Q-j0输出:8,10,12,14,16,木铎校园 BBS 社区xQ(P$q5NwEA

bX f$rN)K0
-\n*n4K4?mpg1F j04.木铎校园 BBS 社区%I9lA2\+Dn"N
木铎校园 BBS 社区RZg JpZ K
int func(int a)
(v2YR0[L1Zu0{木铎校园 BBS 社区me lU(mJ1D)| WK` N
int b;木铎校园 BBS 社区L7}:kN7mxyH
switch(a)
m+~:zY*VX.u[V/}0{
ZP(MW)M'AG@q0case 1: 30;木铎校园 BBS 社区|$E8h5wiw
case 2: 20;
a0qb5R#k }v1m)i0case 3: 16;
5~(PR;h0|x"z%i0default: 0木铎校园 BBS 社区W~,Q4U L Z{
}
O4dIx*w j6d2a0return b;木铎校园 BBS 社区w8c/C3P0Ht1C@
}
q"dZ"L"w*e9Q+kb0则func(1)=?
sn/n%Q)Z;z1{2^0// b定义后就没有赋值。木铎校园 BBS 社区,y ~;q|1b:R
木铎校园 BBS 社区esq c4ZL
5:
_o)f&h8^'y QQ\0int a[3];
,b/v ^vxUky0a[0]=0; a[1]=1; a[2]=2;
Gm&ac^][Q:E0int *p, *q;木铎校园 BBS 社区"SN%J!S|*FN
p=a;
pcX L/JN0q=&a[2];
K[0Q^P8ox Fp2A0则a[q-p]=a[2]
f`J3G@ ^Wn"s0解释:指针一次移动一个int但计数为1木铎校园 BBS 社区6O k'IfwL e

[W.J`J2D*Crk0今天早上的面试题9道,比较难,向牛人请教,国内的一牛公司,坐落在北京北四环某大厦:木铎校园 BBS 社区T,U|n1dpM7uc7H
1、线形表a、b为两个有序升序的线形表,编写一程序,使两个有序线形表合并成一个有序升序线形表h;木铎校园 BBS 社区zQ C[ A6H
答案在 请化大学 严锐敏《数据结构第二版》第二章例题,数据结构当中,这个叫做:两路归并排序木铎校园 BBS 社区?-La5} Le9m$o
Linklist *unio(Linklist *p,Linklist *q){木铎校园 BBS 社区qk|5g?!K*w
linklist *R,*pa,*qa,*ra;木铎校园 BBS 社区R} o8PNYA z B"b
pa=p;
"Um-a3vHP0qa=q;木铎校园 BBS 社区d6@N9x'J
R=ra=p;木铎校园 BBS 社区.jz7p7vL\S+B Q
while(pa->next!=NULL&&qa->next!=NULL){
Huc9s;A!f0if(pa->data>qa->data){木铎校园 BBS 社区v x6V K@6C@8F6T`
ra->next=qa;
*Il9Z/J-^R!vB.k+s0qa=qa->next;木铎校园 BBS 社区W@2X"rD(P{u] q
}
3?!^!@4oxU%_P0else{
hX9D/m}0_0ra->next=pa;
].kkB:r7vub0pa=pa->next;木铎校园 BBS 社区s'Sr}L+{"n,U6vU
}
w#U9[.@^8~CX0}
\],i:{/I[3w2C0if(pa->next!=NULL)木铎校园 BBS 社区 i/[d i:t]E6bgW
ra->next=pa;木铎校园 BBS 社区/J#RO3~#P],ao
if(qa->next!=NULL)
"E~Gp IJ#D J0ra->next==qa;
6_0KfyQ\g0return R;木铎校园 BBS 社区x(W6b LcSZ
}木铎校园 BBS 社区rL]EuG#R[0}
2、运用四色定理,为N个局域举行配色,颜色为1、2、3、4四种,另有数组adj[][N],如adj[i][j]=1则表示i区域与j区域相邻,数组color[N],如color[i]=1,表示i区域的颜色为1号颜色。
#Atju$v`0四色填充
)rA&Dv-q2x4bG03、用递归算法判断数组a[N]是否为一个递增数组。木铎校园 BBS 社区A7qr*x|!`:F
递归的方法,记录当前最大的,并且判断当前的是否比这个还大,大则继续,否则返回false结束:
!h7|L.Y5e i9A4n)J0bool fun( int a[], int n )木铎校园 BBS 社区}?:TZ-PTyG
{
:S['}D)_ji V0if( n= =1 )木铎校园 BBS 社区5\_EUL
return true;木铎校园 BBS 社区)|6Ve4?5nw6ZF
if( n= =2 )
B0z#NJ*x UC;n Kr0return a[n-1] >= a[n-2];
)L4p$vYp;r'Pjug0return fun( a,n-1) && ( a[n-1] >= a[n-2] );木铎校园 BBS 社区SNL`!s'O
}木铎校园 BBS 社区'a`0^y'mS
4、编写算法,从10亿个浮点数当中,选出其中最大的10000个。
8h+XWnH W9IiF|0用外部排序,在《数据结构》书上有木铎校园 BBS 社区BA,P q:V1U^G|
《计算方法导论》在找到第n大的数的算法上加工木铎校园 BBS 社区Aay$b3\pYqg
5、编写一unix程序,防止僵尸进程的出现.
qIJ7f1` a$O0
$Ef:Dh@A.^(Z B0Top木铎校园 BBS 社区 c/F Y.[5HM j~
  回复人:free131(白日?做梦!) ( 一级(初级)) 信誉:100   2006-4-17 10:17:34   得分:0
.^,HDh`0?   木铎校园 BBS 社区1w4Y-T9r7k*bX
木铎校园 BBS 社区N\*gG#f`%P"X3EL6N
同学的4道面试题,应聘的职位是搜索引擎工程师,后两道超级难,(希望大家多给一些算发)
7j$J^$v;P*J9j8UB01.给两个数组和他们的大小,还有一动态开辟的内存,求交集,把交集放到动态内存dongtai,并且返回交集个数
;umj6A M,SB0long jiaoji(long* a[],long b[],long* alength,long blength,long* dongtai[])
1i.eM%I{ l!|_W02.单连表的建立,把'a'--'z'26个字母插入到连表中,并且倒叙,还要打印!木铎校园 BBS 社区5ymp([+aBU
方法1:
5h~$o%s9nf:cT0typedef struct val木铎校园 BBS 社区(Z)e4|8`zQ%|ZU
{ int date_1;木铎校园 BBS 社区-upPM-@pvi
struct val *next;木铎校园 BBS 社区[-rj| s|4ODw
}*p;木铎校园 BBS 社区qM'[9D%YLb

4oR}.Sw!c#q_0void main(void)
*NQJw0p5IY0{ char c;木铎校园 BBS 社区@9kyr?[[^S

(F;JPi,fr0for(c=122;c>=97;c--)
~+?;V2O;T#A,B0{ p.date=c;木铎校园 BBS 社区r4f sriu
p=p->next;木铎校园 BBS 社区 T?$Xh.W6F;B
}木铎校园 BBS 社区,WC[ T sn6a6n(N
木铎校园 BBS 社区I&CH|;Z8F
p.next=NULL;木铎校园 BBS 社区wuI.G]LNC!j
}木铎校园 BBS 社区8X`3L%W%f:K0Y+kY
}木铎校园 BBS 社区te5dy b-l8}/`
方法2:
?(X|/kY/z0node *p = NULL;木铎校园 BBS 社区+gk0ft0e$o'NxH
node *q = NULL;木铎校园 BBS 社区6G#bC_Bt4F:t*R
木铎校园 BBS 社区8jV'}:I:B
node *head = (node*)malloc(sizeof(node));木铎校园 BBS 社区-N0`#m(M9k
head->data = ' ';head->next=NULL;木铎校园 BBS 社区 j6Q;M,~r&\ az
木铎校园 BBS 社区}~4K;`6A
node *first = (node*)malloc(sizeof(node));
'dG7Gp\(A0Gj0first->data = 'a';first->next=NULL;head->next = first;木铎校园 BBS 社区8qG e6c$oR?R
p = first;木铎校园 BBS 社区^0YDa y.o+k[7O [8P

M)E"e[)}w%F1z0int longth = 'z' - 'b';
{^1e"s"y.A*d0int i=0;木铎校园 BBS 社区x`yHt8D%L5Lj
while ( i<=longth )
H p gT%q w"{E@0{
3v qPx"K$qSoeW0node *temp = (node*)malloc(sizeof(node));木铎校园 BBS 社区G^C*A6l)_
temp->data = 'b'+i;temp->next=NULL;q=temp;木铎校园 BBS 社区7k4uD;m9b`

I+]0l.[U v+tTS0head->next = temp; temp->next=p;p=q;木铎校园 BBS 社区7T)q` Bhy$~
i++;木铎校园 BBS 社区jLnu%EBG5P6Q
}木铎校园 BBS 社区KGKV.}?%t e&B(]

(Z OzMz4q2a:iH0print(head);木铎校园 BBS 社区WG(v)nZ*f
木铎校园 BBS 社区1TA R+{{f i
3.可怕的题目终于来了木铎校园 BBS 社区{p"GxO6C
象搜索的输入信息是一个字符串,统计300万输入信息中的最热门的前十条,我们每次输入的一个字符串为不超过255byte,内存使用只有1G,木铎校园 BBS 社区3gL H2qU
请描述思想,写出算发(c语言),空间和时间复杂度,
zX!EHrO]3Sj04.国内的一些帖吧,如baidu,有几十万个主题,假设每一个主题都有上亿的跟帖子,怎么样设计这个系统速度最好,请描述思想,写出算发(c语言),空间和时间复杂度,
p:oL.{ Qz@z^e%} S0木铎校园 BBS 社区 y9TKjdcck

/F,BH+D_cf0#include string.h
["b6G)J1}X*SOG0main(void)
4?#qo l a g#r*u0{ char *src="hello,world";木铎校园 BBS 社区5V5_ _X _l-aN0Of
char *dest=NULL;
U r1} O;JKt0dest=(char *)malloc(strlen(src));
~8p.LB:b@0int len=strlen(str);
q` N{5f0char *d=dest;
?+qId;}s-GQ0char *s=src[len];木铎校园 BBS 社区o4V1z\*Q6y r m6Y
while(len--!=0)
#IK6ZrV0d++=s--;木铎校园 BBS 社区[u/O b5UE|
printf("%s",dest);
;lT8Y[7|0}
B`}L5X2} J0找出错误!!木铎校园 BBS 社区'WC?L/v.An
#include "string.h"
dipba?2E0#include "stdio.h"木铎校园 BBS 社区 I"J$v {h#H#BU
#include "malloc.h"
N@Js%o$n0main(void)
)icSOy0{木铎校园 BBS 社区5D)RI I+}
char *src="hello,world";木铎校园 BBS 社区$Z!v yS!qt
char *dest=NULL;
*U!{lBy4J0dest=(char *)malloc(sizeof(char)*(strlen(src)+1));
a7E#x,l2M!uO0int len=strlen(src);
;s~t _3O0char *d=dest;木铎校园 BBS 社区@G w~X
char *s=src+len-1;木铎校园 BBS 社区 jja/Qh"X
while(len--!=0)
j1v+k.?qQ0*d++=*s--;
$y}D5_6Qlc0*d='\0';木铎校园 BBS 社区#@:ex+{y
printf("%s",dest);
N?h!}N^_0}
,]aub8E B0木铎校园 BBS 社区tL'W TEA } ?
1. 简述一个Linux驱动程序的主要流程与功能。木铎校园 BBS 社区1K'x{;h1i#U
木铎校园 BBS 社区9\4F| [%o&f
2. 请列举一个软件中时间换空间或者空间换时间的例子。木铎校园 BBS 社区4wYFn [qpx0~
void swap(int a,int b)木铎校园 BBS 社区7I0W8W)T.n
{
di pO:Hz3R0int c; c=a;a=b;b=a;
3g S&t8`f2j0}
(Y F.c:k,B{/{X%Hm!Bvg0--->空优木铎校园 BBS 社区 R`K2lZ}1{@
void swap(int a,int b)木铎校园 BBS 社区 Z:G'Ht!K1M5{9|:U
{
g"P%Wb8\R/H3S C#M0a=a+b;b=a-b;a=a-b;木铎校园 BBS 社区L'S6}Q$Z O
}
&f+z,S@W;H06. 请问一下程序将输出什么结果?
+oUB?I8?0char *RetMenory(void)
6FD9T;F;iL0{木铎校园 BBS 社区rwcbT
char p[] = “hellow world”;木铎校园 BBS 社区-p2j+]#nj ci
return p;
/f,r#O7D'Bs0}
-?)R;fwu0void Test(void)木铎校园 BBS 社区6NXhA{6e~)U
{木铎校园 BBS 社区!}*T,x,F0LA#P+Y'd^)]z
char *str = NULL;木铎校园 BBS 社区$uixQ qA#ry _!CA
str = RetMemory();木铎校园 BBS 社区?6E"|iaSJ_8Sf
printf(str);木铎校园 BBS 社区DQ{X;d E)\w p
}
dSLk(bo0RetMenory执行完毕,p资源被回收,指向未知地址。返回地址,str的内容应是不可预测的, 打印的应该是str的地址木铎校园 BBS 社区1O(fg] M,q9{

9oDeJ*_p&dVR0
"mpp"l1EK0写一个函数,它的原形是int continumax(char *outputstr,char *intputstr)木铎校园 BBS 社区kc [a)]@*d z
功能:
YN9A*]%ck0在字符串中找出连续最长的数字串,并把这个串的长度返回,并把这个最长数字串付给其中一个函数参数outputstr所指内存。例如:"abcd12345ed125ss123456789"的首地址传给intputstr后,函数将返回木铎校园 BBS 社区#w)\ ^G8Q;_z D
9,outputstr所指的值为123456789
;\ ?%D;oV-z+||\0int continumax(char *outputstr, char *inputstr)
T3`%j+fL+Y!lg0{
g QW,Z)E P0char *in = inputstr, *out = outputstr, *temp, *final;木铎校园 BBS 社区`'W_8d(vq K+C^
int count = 0, maxlen = 0;
)F#OdL%e(k(S0木铎校园 BBS 社区4t\*s@4J jzL
while( *in != '\0' )木铎校园 BBS 社区Bu%p7d2oc7C#y
{
/a tVe4l$Zz d p0if( *in > 47 && *in< 58 )
+X;dD K6hYoR0{木铎校园 BBS 社区!XX,\!RiUU:pz
for(temp = in; *in > 47 && *in< 58 ; in++ )木铎校园 BBS 社区(k {&B(bv
count++;木铎校园 BBS 社区|?9o t(I i:}-j[
}
&G~5U9qQE0else木铎校园 BBS 社区 S*];ZDK]B2X
in++;
zP'x(qdl0木铎校园 BBS 社区HR ybF"XQc
if( maxlen< count )
s!@,xF ?P V,O-t0{
5b7M4?6b@x} l0maxlen = count;
Z_jg5pt%i0count = 0;
ZY2M8D-v?;iZ2R U(j0final = temp;
}{)Ln:}1z[8x0}
+