C语言面试题大汇总

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

4. static有什么用途?(请至少说明两种)
,g#j5hLL^5q p z T0^01.限制变量的作用域
rii4{+uvq#`02.设置变量的存储域
Re ~$M#A?RM07. 引用与指针有什么区别?木铎校园 BBS 社区G#X!{!KBK
1) 引用必须被初始化,指针不必。木铎校园 BBS 社区zr%^"["g-A8}6~j
2) 引用初始化以后不能被改变,指针可以改变所指的对象。
A}5} w)^02) 不存在指向空值的引用,但是存在指向空值的指针。
@wJ S$S0
nU5BcK08. 描述实时系统的基本特性木铎校园 BBS 社区xLE-Zri{
在特定时间内完成特定的任务,实时性与可靠性
mn:h1q|;H%p,z3o$wd09. 全局变量和局部变量在内存中是否有区别?如果有,是什么区别?木铎校园 BBS 社区{ u!O L vinY P @
全局变量储存在静态数据库,局部变量在堆栈木铎校园 BBS 社区G:jjb)K3]$J
10. 什么是平衡二叉树?
.`8w7o.N^0左右子树都是平衡二叉树 且左右子树的深度差值的绝对值不大于1木铎校园 BBS 社区4Q*gJ[G"U
11. 堆栈溢出一般是由什么原因导致的?
7ar:X%@,H0没有回收垃圾资源
4cX;RY`&D012. 什么函数不能声明为虚函数?
4W{/?)r+A`r0constructor木铎校园 BBS 社区8Gh(N},ZJ[)U wbB$B%~
13. 冒泡排序算法的时间复杂度是什么?木铎校园 BBS 社区7Xx/}\&Z3R:V/?6D TK
O(n^2)木铎校园 BBS 社区r Y)H(bq5q
14. 写出float x 与“零值”比较的if语句。
2i:\7K#iCA:o.?2M0if(x>0.000001&&x<-0.000001)
a:V gl2h _016. Internet采用哪种网络协议?该协议的主要层次结构?木铎校园 BBS 社区;WR3T|*o?
tcp/ip 应用层/传输层/网络层/数据链路层/物理层木铎校园 BBS 社区\9k~,Ygj&z
17. Internet物理地址和IP地址转换采用什么协议?
u.Q{:uf ^ AAn"c0ARP (Address Resolution Protocol)(地址解析協議)
*q W#B-eZ Qo018.IP地址的编码分为哪俩部分?木铎校园 BBS 社区)W_Jwd!h5{ L
IP地址由两部分组成,网络号和主机号。不过是要和“子网掩码”按位与上之后才能区分哪些是网络位哪些是主机位。木铎校园 BBS 社区%ua#?yO'jT{N
木铎校园 BBS 社区0l(u\ aLpw
木铎校园 BBS 社区8?"F0b'[$P#E(B~\
2.用户输入M,N值,从1至N开始顺序循环数数,每数到M输出该数值,直至全部输出。写出C程序。
j'qlpHK5l z0循环链表,用取余操作做
]E(P2rHq[ ] s _6K:@03.不能做switch()的参数类型是:
JM1\0a)x2jH~ }0switch的参数不能为实型。木铎校园 BBS 社区a0@7E(y-_ D

6rQ8P@st0華為木铎校园 BBS 社区-n$N#Y `;uef*y4rX
1、局部变量能否和全局变量重名?
E9D\KK1l8g3j.^K A0答:能,局部会屏蔽全局。要用全局变量,需要使用"::"
:V)d#V p!y@0局部变量可以与全局变量同名,在函数内引用这个变量时,会用到同名的局部变量,而不会用到全局变量。对于有些编译器而言,在同一个函数内可以定义多个同名的局部变量,比如在两个循环体内都定义一个同名的局部变量,而那个局部变量的作用域就在那个循环体内
/SR[x3uDZ02、如何引用一个已经定义过的全局变量?木铎校园 BBS 社区 SQ:ya'y{;X%gv
答:extern
],Rp&`XT-i&J0可以用引用头文件的方式,也可以用extern关键字,如果用引用头文件方式来引用某个在头文件中声明的全局变理,假定你将那个变写错了,那么在编译期间会报错,如果你用extern方式引用时,假定你犯了同样的错误,那么在编译期间不会报错,而在连接期间报错
8iZb&V+G"@A'@03、全局变量可不可以定义在可被多个.C文件包含的头文件中?为什么?木铎校园 BBS 社区n J6s b[#Zq.z
答:可以,在不同的C文件中以static形式来声明同名全局变量。
)T2m+?] `A-[0可以在不同的C文件中声明同名的全局变量,前提是其中只能有一个C文件中对此变量赋初值,此时连接不会出错
LFP/ees}H D s04、语句for( ;1 ;)有什么问题?它是什么意思?木铎校园 BBS 社区/^ wq ]M)xQ E)Oih
答:和while(1)相同。木铎校园 BBS 社区K6r {aV
5、do……while和while……do有什么区别?
+e [G4b*^+Who,f0答:前一个循环一遍再判断,后一个判断以后再循环木铎校园 BBS 社区 Q/T!rHzmg6|
6、请写出下列代码的输出内容
HVG'_R7si0#include木铎校园 BBS 社区6i*L5Q W1}|
main()
&{nd%hM2l~0{木铎校园 BBS 社区n0h s/B4Ado
int a,b,c,d;木铎校园 BBS 社区,S5@ S I m\(N&J"L
a=10;木铎校园 BBS 社区-p.pF+Ape`
b=a++;木铎校园 BBS 社区[D9V_ d
c=++a;
~ig]4g8e0d=10*a++;
7SM _IP9q/`-s ty?9L0printf("b,c,d:%d,%d,%d",b,c,d);
r%Q ]n,Cd OIv EyC0return 0;木铎校园 BBS 社区6n)^9y { \ B t(axM*o
}
g t E,T7g*pU~x w0答:10,12,120木铎校园 BBS 社区?G/|QC:q

sBQG!OI1c5q01、static全局变量与普通的全局变量有什么区别?static局部变量和普通局部变量有什么区别?static函数与普通函数有什么区别?木铎校园 BBS 社区mshw"h'Ul
全局变量(外部变量)的说明之前再冠以static 就构成了静态的全局变量。全局变量本身就是静态存储方式, 静态全局变量当然也是静态存储方式。这两者在存储方式上并无不同。这两者的区别虽在于非静态全局变量的作用域是整个源程序,当一个源程序由多个源文件组成时,非静态的全局变量在各个源文件中都是有效的。 而静态全局变量则限制了其作用域, 即只在定义该变量的源文件内有效,在同一源程序的其它源文件中不能使用它。由于静态全局变量的作用域局限于一个源文件内,只能为该源文件内的函数公用,因此可以避免在其它源文件中引起错误。木铎校园 BBS 社区r+y#p~wAU
从以上分析可以看出, 把局部变量改变为静态变量后是改变了它的存储方式即改变了它的生存期。把全局变量改变为静态变量后是改变了它的作用域, 限制了它的使用范围。木铎校园 BBS 社区K]J7W N\@
static函数与普通函数作用域不同。仅在本文件。只在当前源文件中使用的函数应该说明为内部函数(static),内部函数应该在当前源文件中说明和定义。对于可在当前源文件以外使用的函数,应该在一个头文件中说明,要使用这些函数的源文件要包含这个头文件木铎校园 BBS 社区-o e.zG8^7v$Q7U#g

1ceVFY$I\0static全局变量与普通的全局变量有什么区别:static全局变量只初使化一次,防止在其他文件单元中被引用;
:|u1{$D0cf0y o Qb0static局部变量和普通局部变量有什么区别:static局部变量只被初始化一次,下一次依据上一次结果值;
0s m"c|Hr@0static函数与普通函数有什么区别:static函数在内存中只有一份,普通函数在每个被调用中维持一份拷贝
Bt |F)Vmf02、程序的局部变量存在于(堆栈)中,全局变量存在于(静态区 )中,动态申请数据存在于( 堆)中。
c*R l(o(xE.b03、设有以下说明和定义:木铎校园 BBS 社区^9\P)xgE K
typedef union {long i; int k[5]; char c;} DATE;
{jXj8f1z8F L!F"~1R0struct data { int cat; DATE cow; double dog;} too;
x'OTt d m B/?RU0DATE max;
A+tAj TxoT#B0则语句 printf("%d",sizeof(struct date)+sizeof(max));的执行结果是:___52____
T8r0tot0答:DATE是一个union, 变量公用空间. 里面最大的变量类型是int[5], 占用20个字节. 所以它的大小是20木铎校园 BBS 社区0Q2Xx%eN#lj^
data是一个struct, 每个变量分开占用空间. 依次为int4 + DATE20 + double8 = 32.木铎校园 BBS 社区x.Ej;U4YdhDx
所以结果是 20 + 32 = 52.木铎校园 BBS 社区(E8TUo3YB0C
当然...在某些16位编辑器下, int可能是2字节,那么结果是 int2 + DATE10 + double8 = 20
l*L ~4tn9b!b&{/B04、队列和栈有什么区别?木铎校园 BBS 社区\JY){"NN&Ah*qd
队列先进先出,栈后进先出木铎校园 BBS 社区0s$i J U2BIE'x wh
5、写出下列代码的输出内容木铎校园 BBS 社区)e!h6i4y Y
#include
!Jp`-y Hz(_0int inc(int a)
n m;gW4S Hp8`V0{木铎校园 BBS 社区 [{ n p` E
return(++a);
!`}(C8gu3W0}木铎校园 BBS 社区Ea \9O Cy j X8e
int multi(int*a,int*b,int*c)木铎校园 BBS 社区5k1v9kd6TM2{D QB
{木铎校园 BBS 社区/or-A[Jj'vUo
return(*c=*a**b);
BS+q1L&G9N3o~(lpc0}
2fC$U'rK#D9n0typedef int(FUNC1)(int in);木铎校园 BBS 社区p0O+t"a~ u
typedef int(FUNC2) (int*,int*,int*);
-u di8WP4S3b Jo't0木铎校园 BBS 社区0s-EU3tI8Sg VF
void show(FUNC2 fun,int arg1, int*arg2)木铎校园 BBS 社区:K:BsoG?w^p
{
#H5T5yt/aTQ;?'n{0INCp=&inc;
1rl%t)V$@6GD ed0int temp =p(arg1);
8{TT:W;N }0fun(&temp,&arg1, arg2);木铎校园 BBS 社区%Eg h&^/s~
printf("%d\n",*arg2);木铎校园 BBS 社区 }+^"PG4o2HgS-n
}木铎校园 BBS 社区E5zoER W#P]
木铎校园 BBS 社区&mP2AkNr_4k
main()木铎校园 BBS 社区M3T8c&Jzdl.vCc`
{
2f)h]2[*`0int a;木铎校园 BBS 社区3t@}w,R&p
show(multi,10,&a);木铎校园 BBS 社区Y&x&BkB5Aa;s
return 0;木铎校园 BBS 社区I[%W/j {zU e~o
}木铎校园 BBS 社区C^&m:mWry'UyD s
答:110
+E%DU GOFH*D3~ w8{:U%]07、请找出下面代码中的所以错误木铎校园 BBS 社区w)K c U y{2\gK~
说明:以下代码是把一个字符串倒序,如“abcd”倒序后变为“dcba”木铎校园 BBS 社区 l+Ji'Ap? F

H/I*lP*HTH\$I01、#include"string.h"
iM/z9a([f02、main()木铎校园 BBS 社区c#H~qn7q
3、{木铎校园 BBS 社区/S$hHo:s}:C0Nq
4、 char*src="hello,world";木铎校园 BBS 社区{)r5M Kd&x3|
5、 char* dest=NULL;木铎校园 BBS 社区 ^4y^%yQ!^u
6、 int len=strlen(src);
Q Xq&Z[6u07、 dest=(char*)malloc(len);
)s4H9f6F4Xrc4T ~08、 char* d=dest;
4h9k KE"]7d09、 char* s=src[len];木铎校园 BBS 社区%t3uy8FX&t*jz"|
10、 while(len--!=0)木铎校园 BBS 社区 a7cks7@
11、 d++=s--;
`oQ0GU+Y7B012、 printf("%s",dest);木铎校园 BBS 社区 bS8D$z K
13、 return 0;木铎校园 BBS 社区r'y'c+~6r|b!t
14、}
B#hq8n` | g}Z0答:木铎校园 BBS 社区G6|t.rC`j~&PM+w
方法1:
D })T8UML0int main(){木铎校园 BBS 社区2D C4Cv8Oi-\
char* src = "hello,world";木铎校园 BBS 社区.o&He o?
int len = strlen(src);
?&Y;B)J'c @2L0char* dest = (char*)malloc(len+1);//要为\0分配一个空间木铎校园 BBS 社区!cF6Op1SC
char* d = dest;
t&kZ$^:Y0char* s = &src[len-1];//指向最后一个字符木铎校园 BBS 社区b;|I&Z'x
while( len-- != 0 )木铎校园 BBS 社区&V5?/[3x"rEi
*d++=*s--;
C3}_?#uVxz.y0*d = 0;//尾部要加\0木铎校园 BBS 社区w$g9KT\"g$K C
printf("%s\n",dest);木铎校园 BBS 社区z#pq5NB#Q%c"Rj:nk6{
free(dest);// 使用完,应当释放空间,以免造成内存汇泄露木铎校园 BBS 社区t+H"zG ^2vj!Q
return 0;
/z Y|l.~&M;Z2TsY0}木铎校园 BBS 社区+F.]+H H dN2c!i
方法2:木铎校园 BBS 社区T7V m*N1i$s$c0[%^GoG
#include
4~K6AU:Y'BYBG0#include
+k'\$T/Qd;I0main()
sn`V/N%y FPW5G0{
,O!c9I.~8Ld3v5C0char str[]="hello,world";
~H[I/|eP kHGf!S0int len=strlen(str);木铎校园 BBS 社区kPoD2qP
char t;
w3i?+S9]0for(int i=0; i木铎校园 BBS 社区"nLcwA
{
;VM-jN$@0t=str[i];木铎校园 BBS 社区/OB,x*\ q2?
str[i]=str[len-i-1]; str[len-i-1]=t;木铎校园 BBS 社区&SPT/nK:od@
}木铎校园 BBS 社区2l f%?"u-N;p3N
printf("%s",str);
N?\"n[8b1tOo}0return 0;木铎校园 BBS 社区3cRA$S%\e
}
F"kO-sB01.-1,2,7,28,,126请问28和126中间那个数是什么?为什么?木铎校园 BBS 社区YT\)Y @a-ci m9@
第一题的答案应该是4^3-1=63
%kS;UE+F5nJ0规律是n^3-1(当n为偶数0,2,4)
#Z#h$gZynZ;G0n^3+1(当n为奇数1,3,5)
`9B&l)j|:`(P0答案:63
Y Z8Qb$@nZ02.用两个栈实现一个队列的功能?要求给出算法和思路!木铎校园 BBS 社区_7Av1{alVhX D L7T-e
设2个栈为A,B, 一开始均为空.
!aq#_TH7E4MC0
l GM6_5r.o;[VC w#J0入队:
7e"M T5j4S!oF0将新元素push入栈A;
+}5Y*oZb QS0
`7u-F O)T(~vK3Y0出队:
VC&n,t9o]%}0(1)判断栈B是否为空;
2z }4S%QZ0(2)如果不为空,则将栈A中所有元素依次pop出并push到栈B;木铎校园 BBS 社区(~1w9Q/sd
(3)将栈B的栈顶元素pop出;木铎校园 BBS 社区:t-Gfz#u {

s-JMp\$Re6_.A0这样实现的队列入队和出队的平摊复杂度都还是O(1), 比上面的几种方法要好。3.在c语言库函数中将一个字符转换成整型的函数是atool()吗,这个函数的原型是什么?木铎校园 BBS 社区A&?}5n5]8d]f
函数名: atol木铎校园 BBS 社区7~xC0S Zr"N
功 能: 把字符串转换成长整型数
#Mu;e@Y U m!Kk3j!R0用 法: long atol(const char *nptr);
oN0|Z|%j*R6e0程序例:木铎校园 BBS 社区7{ d`s0h/`0T
#include
K Wc:j!I4}8M0#include木铎校园 BBS 社区r2t4{.F5z9RY q
int main(void)
fnAj"K3u,T ?@0{木铎校园 BBS 社区 E1t/KE$Z6f ZG
long l;
5\5nbKC a3NO"q0char *str = "98765432";木铎校园 BBS 社区:bJU ?)@;a

~@)k mA1d0l = atol(lstr);木铎校园 BBS 社区 Z4m\2z0~V*@Md
printf("string = %s integer = %ld\n", str, l);
!w7PiIl6b~'~0return(0);木铎校园 BBS 社区"g%z#J:NM|w1sY
}木铎校园 BBS 社区,sB},RIt _ r
2.对于一个频繁使用的短小函数,在C语言中应用什么实现,在C++中应用什么实现?
&[6ZN%BK1R L0c用宏定义,c++用inline
7s@/fMJ\)f03.直接链接两个信令点的一组链路称作什么?木铎校园 BBS 社区o,G*h?"_jeh
PPP点到点连接木铎校园 BBS 社区L\~G0U0c9|6~4~
4.接入网用的是什么接口?木铎校园 BBS 社区#k'O9@kF!T
5.voip都用了那些协议?
h;N5wN*l06.软件测试都有那些种类?木铎校园 BBS 社区D$vIF"V{)B
黑盒:针对系统功能的测试 白合:测试函数功能,各函数接口
,vO-Yi \f4R$y07.确定模块的功能和模块的接口是在软件设计的那个队段完成的?
2JbRT:Fz8wXE0概要设计阶段木铎校园 BBS 社区(VT*x{n(K
8.enum string木铎校园 BBS 社区 ? n4`SW*wu
{木铎校园 BBS 社区M T'Flf!fOX7e1b
x1,木铎校园 BBS 社区6O| ~ u-P8h5v0|a
x2,木铎校园 BBS 社区&Iy`r:XIs8M!s
x3=10,木铎校园 BBS 社区+j0j7BU g&LOz:? f
x4,木铎校园 BBS 社区 So1N/WkX
x5,
*r9Kx\ _W w0}x;木铎校园 BBS 社区bRZ5kv8^-t h
问x= 0x801005,0x8010f4 ;木铎校园 BBS 社区 z3S2C8mi-]eE
9.unsigned char *p1;
V4HW4Z+g3x%B,P0unsigned long *p2;木铎校园 BBS 社区{tE7B4s,~!E
p1=(unsigned char *)0x801000;
$b$O!E iR!y)e0p2=(unsigned long *)0x810000;
5\z]1b'EfP| K:?0请问p1+5= ;
1}&I s m$^0em^0p2+5= ;
^&T@9jk5T6|6rn0三.选择题:木铎校园 BBS 社区z%] \;]&dm7q
1.Ethternet链接到Internet用到以下那个协议?
*DFJsv-o [0A.HDLC;B.ARP;C.UDP;D.TCP;E.ID木铎校园 BBS 社区2W l-]{j
2.属于网络层协议的是:木铎校园 BBS 社区7F-@[ C^`$Ax#CG3r
A.TCP;B.IP;C.ICMP;D.X.25
X0KeQ l&f03.Windows消息调度机制是:
X J \(P$A$Q+U*G0A.指令队列;B.指令堆栈;C.消息队列;D.消息堆栈;
U:yuPWlt04.unsigned short hash(unsigned short key)木铎校园 BBS 社区 I.L$t"w J U"P
{木铎校园 BBS 社区+\lDO,\ k]i
return (key>>)%256木铎校园 BBS 社区~ i ?)]HFxL0?
}木铎校园 BBS 社区G Gr:|/~/|4[
请问hash(16),hash(256)的值分别是:
{F? },~ \:f0A.1.16;B.8.32;C.4.16;D.1.32
!W/I0Z F?0四.找错题:木铎校园 BBS 社区 v4F J T f"@x
1.请问下面程序有什么错误?
1RdG{fs!H&gy5C0int a[60][250][1000],i,j,k;木铎校园 BBS 社区$i4|/M`x)@&fk
for(k=0;k<=1000;k++)木铎校园 BBS 社区O_5|&|[#Nm#t:\
for(j=0;j<250;j++)木铎校园 BBS 社区&[ex_a1q
for(i=0;i<60;i++)木铎校园 BBS 社区JbO p1y7P ],?
a[i][j][k]=0;木铎校园 BBS 社区EjQ|{Q,^e:s
把循环语句内外换一下木铎校园 BBS 社区,SB;bM&O4[ jX'G@x
2.#define Max_CB 500
1|D*U(P|1|g(u0void LmiQueryCSmd(Struct MSgCB * pmsg)
#s2~,n8d2Uj-o%T0{
7T RD+J k `vM5n _gb A0unsigned char ucCmdNum;
]e(^g HTA/MD!p2I0......木铎校园 BBS 社区 X:Sw?A"qgz
木铎校园 BBS 社区IZ8B)u1|(_`n
for(ucCmdNum=0;ucCmdNum,R&px+_%g#_@0{木铎校园 BBS 社区Eq%n ig
......;
1F7m]!{y2M(Ot0}木铎校园 BBS 社区 L4Bh{q$J/o(q
死循环
:K @Z4E-Y(G ^I03.以下是求一个数的平方的程序,请找出错误:木铎校园 BBS 社区"h+c5C#pN}"V
#define SQUARE(a)((a)*(a))
3Z7I"P~:Rlq0j0int a=5;木铎校园 BBS 社区1|Ymh3sA
int b;
&Hn$P4su.[5{0b=SQUARE(a++);木铎校园 BBS 社区7le~n8HX M1@@o,L#m
4.typedef unsigned char BYTE
QD~-d6rm0int examply_fun(BYTE gt_len; BYTE *gt_code)木铎校园 BBS 社区4o1M/b$c:kD;^
{
8T7Z9f}!^Dw"Zu0BYTE *gt_buf;木铎校园 BBS 社区[7xjtuh+P,v
gt_buf=(BYTE *)MALLOC(Max_GT_Length);木铎校园 BBS 社区3o_zElN
......木铎校园 BBS 社区%L7moh c(aW
if(gt_len>Max_GT_Length)木铎校园 BBS 社区i.x*Oa,mx(Ts%H x
{木铎校园 BBS 社区h mg emcq+hG/U C
return GT_Length_ERROR;木铎校园 BBS 社区;G9?^_\p,quR
}
T&w6k V$b7mG%W [~y0.......木铎校园 BBS 社区dX D2cVS `
}木铎校园 BBS 社区{)Dq#H(@0jb
五.问答题:
$J fwF oE01.IP Phone的原理是什么?
E2jTt1P o2@0IPV6木铎校园 BBS 社区z1k~I ]7oA
2.TCP/IP通信建立的过程怎样,端口有什么作用?
e1B2^ ye*p0三次握手,确定是哪个应用程序使用该协议木铎校园 BBS 社区%Y@LJ)NZJ0t
3.1号信令和7号信令有什么区别,我国某前广泛使用的是那一种?木铎校园 BBS 社区U`C(r-T"WS
4.列举5种以上的电话新业务?
7\z `{(n|jw Ui0木铎校园 BBS 社区L%T/Md BE/k
微软亚洲技术中心的面试题!!!
1iL mq H01.进程和线程的差别。木铎校园 BBS 社区0b!z;{%a*`7nk2~y(n
线程是指进程内的一个执行单元,也是进程内的可调度实体.木铎校园 BBS 社区"EWm`9X&`-`d
与进程的区别:木铎校园 BBS 社区9gz;e?&GB2v
(1)调度:线程作为调度和分配的基本单位,进程作为拥有资源的基本单位木铎校园 BBS 社区\v's0a.f*v
(2)并发性:不仅进程之间可以并发执行,同一个进程的多个线程之间也可并发执行木铎校园 BBS 社区(S|p.Lc
(3)拥有资源:进程是拥有资源的一个独立单位,线程不拥有系统资源,但可以访问隶属于进程的资源.
$us,~O3X4P0(4)系统开销:在创建或撤消进程时,由于系统都要为之分配和回收资源,导致系统的开销明显大于创建或撤消线程时的开销。木铎校园 BBS 社区KWPLk&p[9f
2.测试方法
ZZ:~_A7y#V0人工测试:个人复查、抽查和会审
B g9zL8d-I5W0机器测试:黑盒测试和白盒测试
I8K3v Y-H$n0木铎校园 BBS 社区f.p.e5VKBS
2.Heap与stack的差别。木铎校园 BBS 社区J'{ w-l/F'^k"]
Heap是堆,stack是栈。木铎校园 BBS 社区qYz+QS H/Y
Stack的空间由操作系统自动分配/释放,Heap上的空间手动分配/释放。
[1Xm$q5t9ROq f0Stack空间有限,Heap是很大的自由存储区
c7O:S6O5z`.Ol0C中的malloc函数分配的内存空间即在堆上,C++中对应的是new操作符。
wGi`8@2@0程序在编译期对变量和函数分配内存都在栈上进行,且程序运行过程中函数调用时参数的传递也在栈上进行
wzbR)i}/Zsc03.Windows下的内存是如何管理的?木铎校园 BBS 社区b Kg rW+X
4.介绍.Net和.Net的安全性。木铎校园 BBS 社区7f0T%^ i\g+~_L[1L
5.客户端如何访问.Net组件实现Web Service?木铎校园 BBS 社区:oq#x0K3Y-ks
6.C/C++编译器中虚表是如何完成的?
?mKI[07.谈谈COM的线程模型。然后讨论进程内/外组件的差别。
h]4Fyt3Mi5N08.谈谈IA32下的分页机制木铎校园 BBS 社区'vali5L!RW
小页(4K)两级分页模式,大页(4M)一级木铎校园 BBS 社区 k;Hm.Z8\ ]m&l+xF"v(d b%yc
9.给两个变量,如何找出一个带环单链表中是什么地方出现环的?
Fv4G+V Ut L0一个递增一,一个递增二,他们指向同一个接点时就是环出现的地方木铎校园 BBS 社区]SJ$A-j j
10.在IA32中一共有多少种办法从用户态跳到内核态?木铎校园 BBS 社区)q0z0r.w4Xx T*M(]
通过调用门,从ring3到ring0,中断从ring3到ring0,进入vm86等等
7eI|x/W iT*K011.如果只想让程序有一个实例运行,不能运行两个。像winamp一样,只能开一个窗口,怎样实现?木铎校园 BBS 社区6Bq O K(|,[
用内存映射或全局原子(互斥变量)、查找窗口句柄..木铎校园 BBS 社区'c/M.sS?M!K1O
FindWindow,互斥,写标志到文件或注册表,共享内存。. 
4l!~4~hG#Jcja012.如何截取键盘的响应,让所有的‘a’变成‘b’?木铎校园 BBS 社区9{$Q$|:l/y]
键盘钩子SetWindowsHookEx
s)_5aa|0u+P&Hw|4a0 13.Apartment在COM中有什么用?为什么要引入?木铎校园 BBS 社区{)Hg5E6tY(I&b/O1aJ
 14.存储过程是什么?有什么用?有什么优点?
4?]3[5q?nHz0我的理解就是一堆sql的集合,可以建立非常复杂的查询,编译运行,所以运行一次后,以后再运行速度比单独执行SQL快很多
r@5IX3a0 15.Template有什么特点?什么时候用?
6Nc.x/P}{ZYo ?016.谈谈Windows DNA结构的特点和优点。木铎校园 BBS 社区Y6wdC&wZ:z5B,l
木铎校园 BBS 社区]!S&}4q[*l,I-j"A W

2Y?3@ti.hm5\M0网络编程中设计并发服务器,使用多进程 与 多线程 ,请问有什么区别?木铎校园 BBS 社区7e+{R-b6RxQ
1,进程:子进程是父进程的复制品。子进程获得父进程数据空间、堆和栈的复制品。
5f:u$i c{02,线程:相对与进程而言,线程是一个更加接近与执行体的概念,它可以与同进程的其他线程共享数据,但拥有自己的栈空间,拥有独立的执行序列。木铎校园 BBS 社区2\dCf.w!I\4P
两者都可以提高程序的并发度,提高程序运行效率和响应时间。
S.g t*TO2p;HngK]i0线程和进程在使用上各有优缺点:线程执行开销小,但不利于资源管理和保护;而进程正相反。同时,线程适合于在SMP机器上运行,而进程则可以跨机器迁移。木铎校园 BBS 社区0A&Xqs/~7Z
木铎校园 BBS 社区7@_4A \H W
思科木铎校园 BBS 社区 _[NK E:n g$a
1. 用宏定义写出swap(x,y)木铎校园 BBS 社区1P oU^e8}:n5i
#define swap(x, y)\
0\m1Ana?4AziB_0x = x + y;\
~A^7dy3H$u(}+g0y = x - y;\木铎校园 BBS 社区W]7Kp Ad,[
x = x - y;
l6f R4f+c,[ |02.数组a[N],存放了1至N-1个数,其中某个数重复一次。写一个函数,找出被重复的数字.时间复杂度必须为o(N)函数原型:木铎校园 BBS 社区/J-P1eR-om%Bp$gd
int do_dup(int a[],int N)
k A;r}o03 一语句实现x是否为2的若干次幂的判断木铎校园 BBS 社区*|l} P/DLs
int i = 512;
-h6y0@7o,x*E;|;j0cout<< boolalpha << ((i & (i - 1)) ? false : true) << endl;木铎校园 BBS 社区jS@H"Q8K!S6E
4.unsigned int intvert(unsigned int x,int p,int n)实现对x的进行转换,p为起始转化位,n为需要转换的长度,假设起始点在右边.如x=0b0001 0001,p=4,n=3转换后x=0b0110 0001
Gv*om&h%} pj0unsigned int intvert(unsigned int x,int p,int n){木铎校园 BBS 社区/?^g Rty frB:g
unsigned int _t = 0;
ph"^%k2b`0unsigned int _a = 1;木铎校园 BBS 社区9P O i$iYEF.j
for(int i = 0; i< n; ++i){
5b6U\.Q V7Jm/]6q0_t |= _a;木铎校园 BBS 社区k(oP7{ [f
_a = _a<< 1;木铎校园 BBS 社区1x:I n0I6J#zL w4r]5^
}木铎校园 BBS 社区 Zw B%H0lb(d
_t = _t<< p;木铎校园 BBS 社区)K0_T%IAT7g
x ^= _t;
z7@)Z.aTez0return x;木铎校园 BBS 社区!t9J,i/|I3`P.v2|
}
mJ&|X.WRc0慧通:
/WmQ|9^#w9U0什么是预编译木铎校园 BBS 社区/@ p_x5gw]`E
何时需要预编译:木铎校园 BBS 社区4m4O#T!\'e)CS5YZ
1、总是使用不经常改动的大型代码体。木铎校园 BBS 社区J mWk}rqrF
2、程序由多个模块组成,所有模块都使用一组标准的包含文件和相同的编译选项。在这种情况下,可以将所有包含文件预编译为一个预编译头。木铎校园 BBS 社区$z"p7D6H!x EY
char * const p;
?L.[}0g&Qjq0char const * p
q_?wN M H"iHD0const char *p木铎校园 BBS 社区 oR;O*tH]N K{R
木铎校园 BBS 社区\|2B,^VXK*Y/F{
上述三个有什么区别?木铎校园 BBS 社区;r_5Q8E v{V5@!i
char * const p; //常量指针,p的值不可以修改木铎校园 BBS 社区1bs-rff#u
char const * p;//指向常量的指针,指向的常量值不可以改
@%CC*tv`Nf0const char *p; //和char const *p
hvnw G [+e0木铎校园 BBS 社区)MzG OZ1f}2}Tf
char str1[] = "abc";木铎校园 BBS 社区!L` j6RZ$X)D%K+D
char str2[] = "abc";
f*}/Db%AYl0木铎校园 BBS 社区J$M"jk/}-D
const char str3[] = "abc";
d e yu l3E0const char str4[] = "abc";
S_)e;t4y0
?7D-lj3vR6@+D0const char *str5 = "abc";木铎校园 BBS 社区.ZU(u%MI5@
const char *str6 = "abc";
v$c.vl]dz0木铎校园 BBS 社区7]`b b!J'f y
char *str7 = "abc";
| go$}du:a/w;^0Ce0char *str8 = "abc";木铎校园 BBS 社区c{8?0L |C9X3i
木铎校园 BBS 社区 |jGon*M4PCP*gv

[/z9c ||1b0cout<< ( str1 == str2 ) << endl;木铎校园 BBS 社区3ad7V:b wk
cout<< ( str3 == str4 ) << endl;
[9Lw!_.j V0cout<< ( str5 == str6 ) << endl;
D7GV(t\/Rl0cout<< ( str7 == str8 ) << endl;木铎校园 BBS 社区B `+@1z s"S

o"dHK+D z(Z0结果是:0 0 1 1
m8f/p*_n7}0解答:str1,str2,str3,str4是数组变量,它们有各自的内存空间;
R0qkU9s0而str5,str6,str7,str8是指针,它们指向相同的常量区域。
+tQ+~ktZ1O$\e?0木铎校园 BBS 社区QzJ Xp
木铎校园 BBS 社区z1f!|)b!Y-k2I
12. 以下代码中的两个sizeof用法有问题吗?[C易]
f aF'y.`0void UpperCase( char str[] ) // 将 str 中的小写字母转换成大写字母
-uX3o6SYK!F.@0{木铎校园 BBS 社区daK C0?WB
for( size_t i=0; i木铎校园 BBS 社区+N K/d7\sU$J6T6uM
if( 'a'<=str[i] && str[i]<='z' )
8[n:U| S"wz0str[i] -= ('a'-'A' );木铎校园 BBS 社区)C+u Smv5Wg
}木铎校园 BBS 社区&I7~U7uR BK
char str[] = "aBcDe";
.S)j(an Qk M0cout<< "str字符长度为: " << sizeof(str)/sizeof(str[0]) << endl;木铎校园 BBS 社区0Ma0@r&q'n
UpperCase( str );
$y9G3j8[ s7VC0cout<< str << endl;木铎校园 BBS 社区 [5ft1MHk

_(j;fB a0R[K0答:函数内的sizeof有问题。根据语法,sizeof如用于数组,只能测出静态数组的大小,无法检测动态分配的或外部数组大小。函数外的str是一个静态定义的数组,因此其大小为6,函数内的str实际只是一个指向字符串的指针,没有任何额外的与数组相关的信息,因此sizeof作用于上只将其当指针看,一个指针为4个字节,因此返回4。木铎校园 BBS 社区Vc`!g:M8A2`

_0O D;k|qX6g H/^0一个32位的机器,该机器的指针是多少位
;H K e&C&xg0指针是多少位只要看地址总线的位数就行了。80386以后的机子都是32的数据总线。所以指针的位数就是4个字节了。木铎校园 BBS 社区5jA(mw]n I
木铎校园 BBS 社区;G@ ['y r|8}1|/Y
main()木铎校园 BBS 社区C$x$G5R{J!c
{木铎校园 BBS 社区2Un B&? vq C-P1t
int a[5]={1,2,3,4,5};
F&?q v#QzLo3e^#~1x0int *ptr=(int *)(&a+1);
J7l'V1R7[*GP,C1JU0
*tc^,~ a \/g u%f0printf("%d,%d",*(a+1),*(ptr-1));木铎校园 BBS 社区C"VY.\+Rv
}
%G W8T5T2Hu?Q3T0输出:2,5
s p+|PFk0*(a+1)就是a[1],*(ptr-1)就是a[4],执行结果是2,5木铎校园 BBS 社区(j;N"s:S'ik)R#I.U
&a+1不是首地址+1,系统会认为加一个a数组的偏移,是偏移了一个数组的大小(本例是5个int)木铎校园 BBS 社区(b,W#a4X#oX
int *ptr=(int *)(&a+1);
n H0@h?a0则ptr实际是&(a[5]),也就是a+5
i3s/_GS!PD0原因如下:木铎校园 BBS 社区 Q3w1Iy vD
&a是数组指针,其类型为 int (*)[5];木铎校园 BBS 社区7P umb p'Y+i
而指针加1要根据指针类型加上一定的值,
'NEW2U"_ O~v;[0不同类型的指针+1之后增加的大小不同木铎校园 BBS 社区n:kO_@(w7mm^wF
a是长度为5的int数组指针,所以要加 5*sizeof(int)
Q G&TI0n_)Iq0所以ptr实际是a[5]木铎校园 BBS 社区+H!dC/G}O1Rj
但是prt与(&a+1)类型是不一样的(这点很重要)
r2fic R+v[;O0所以prt-1只会减去sizeof(int*)
/Z8W ZbO&V z0a,&a的地址是一样的,但意思不一样,a是数组首地址,也就是a[0]的地址,&a是对象(数组)首地址,a+1是数组下一元素的地址,即a[1],&a+1是下一个对象的地址,即a[5].木铎校园 BBS 社区Ua"C4iL.Y?*HTO e4d

.\ OQ x.|PdI5l0木铎校园 BBS 社区^z:L&brO#Y
1.请问以下代码有什么问题:木铎校园 BBS 社区`K2s$D5B
int main()木铎校园 BBS 社区3sHEq)_ p4R M
{木铎校园 BBS 社区;Y6uw7H ]x}.t"iLs^
char a;木铎校园 BBS 社区V1j.^P| P.r
char *str=&a;木铎校园 BBS 社区 ^&]9Cj1A@
strcpy(str,"hello");木铎校园 BBS 社区 n(q%b@(K5i
printf(str);
U["`'u;Gh tZ4UU0return 0;
%I4{f!cnx;g0}木铎校园 BBS 社区3}(~_^"ghr(Bi
没有为str分配内存空间,将会发生异常木铎校园 BBS 社区-D i1I:o x)Y4rA[]%gX
问题出在将一个字符串复制进一个字符变量指针所指地址。虽然可以正确输出结果,但因为越界进行内在读写而导致程序崩溃。
)^$s9NN8IM;A0
c/A:x iH#kj8U&\c _0char* s="AAA";
orR6R.n0printf("%s",s);
4GZ4R-~0Ua2D0s[0]='B';木铎校园 BBS 社区%b%Ww9[)IN/fm
printf("%s",s);木铎校园 BBS 社区pf?)R(NM
有什么错?
Hi9eA3Rx9w0"AAA"是字符串常量。s是指针,指向这个字符串常量,所以声明s的时候就有问题。
{ad6R%MCrp4N V/c.L0cosnt char* s="AAA";木铎校园 BBS 社区 wv9?O:k]U(~
然后又因为是常量,所以对是s[0]的赋值操作是不合法的。木铎校园 BBS 社区xV1KBxU2E
1、写一个“标准”宏,这个宏输入两个参数并返回较小的一个。
+{5B!|;p3fJL0.#define Min(X, Y) ((X)>(Y)?(Y):(X))//结尾没有;
#|_Z`a HiC02、嵌入式系统中经常要用到无限循环,你怎么用C编写死循环。
8?'i(G&c9Lx%I4u0while(1){}或者for(;;)木铎校园 BBS 社区X*e!M'PIo
3、关键字static的作用是什么?木铎校园 BBS 社区G#uy,Yw!J#s5^1~
定义静态变量木铎校园 BBS 社区(H,mb4D|
4、关键字const有什么含意?木铎校园 BBS 社区%kC[e^3]s9[h
表示常量不可以修改的变量。
2\!p"{\0xi/@)g05、关键字volatile有什么含意?并举出三个不同的例子?
?t.G3j @0提示编译器对象的值可能在编译器未监测到的情况下改变。
#lr)v#?$T+b2s_7T sL0木铎校园 BBS 社区)Q,?2j u:_J3^7LH
木铎校园 BBS 社区/y w0DPWE^O-tLO
int (*s[10])(int) 表示的是什么啊
x:r#o&A8JM9n0int (*s[10])(int) 函数指针数组,每个指针指向一个int func(int param)的函数。
,Mcw-Bd0木铎校园 BBS 社区2k-V5}dCU
木铎校园 BBS 社区j/Tam4},W,rp
1.有以下表达式:
t~H+Hv`]3n0int a=248; b=4;int const c=21;const int *d=&a;木铎校园 BBS 社区,RTRqkpb/Ou]
int *const e=&b;int const *f const =&a;
/OQd4~be0请问下列表达式哪些会被编译器禁止?为什么?木铎校园 BBS 社区+K~V(r t
*c=32;d=&b;*d=43;e=34;e=&a;f=0x321f;木铎校园 BBS 社区3c(vyc)q Lg'w{
*c 这是个什么东东,禁止
,}5~2uq bq,q(j0|0*d 说了是const, 禁止
Dh!Rh,x0e = &a 说了是const 禁止
6U!QS Y A|;HZ_U9c0const *f const =&a; 禁止
RT ~BL*f02.交换两个变量的值,不使用第三个变量。即a=3,b=5,交换之后a=5,b=3;
@HYZ8x#WK+@0有两种解法, 一种用算术算法, 一种用^(异或)木铎校园 BBS 社区tZgdlr O? j+R
a = a + b;木铎校园 BBS 社区#S%ba&mF2EgJO/e
b = a - b;
2q#mo6U|Y:{0a = a - b;
V`0b9MH+c0or
],f^-QK0a = a^b;// 只能对int,char..
yrT(Te O/rP0b = a^b;木铎校园 BBS 社区H!d)e~3p3k1h
a = a^b;木铎校园 BBS 社区+n9_u~ aV'_ I
or木铎校园 BBS 社区 cy_XyIzg
a ^= b ^= a;
%g:g H6Db-|03.c和c++中的struct有什么不同?
y4Z[2DGs+g.gV0c和c++中struct的主要区别是c中的struct不可以含有成员函数,而c++中的struct可以。c++中struct和class的主要区别在于默认的存取权限不同,struct默认为public,而class默认为private
~#M#j9t#O:lz9t04.#include木铎校园 BBS 社区k7_.M'\#tm5`o{N
#include
4k6d7?juUVQ0void getmemory(char *p)木铎校园 BBS 社区!Dp%YO,G;hnH
{木铎校园 BBS 社区7@lI+l*Q9Wn
p=(char *) malloc(100);
aE h_f ? p;u0strcpy(p,"hello world");木铎校园 BBS 社区8T4O4u*bU$lGi8Y ]m4K V
}
:TGt(MT}9o0int main( )
'q4r;v/A&Z$^*iO|7F0{
!Lr2{1\|,r*@0char *str=NULL;木铎校园 BBS 社区~F9K,Rj/E)U3[.D
getmemory(str);木铎校园 BBS 社区!l+rU{ N^?k
printf("%s/n",str);
U7khxbXS oe&Q0free(str);
%T7_tb.A%|?$@+JX0return 0;
U3[-s SD_wr0}
@Cd3oty O^0程序崩溃,getmemory中的malloc 不能返回动态内存, free()对str操作很危险
s&?n!v8Kn05.char szstr[10];
t]WL0e R!nx0u}0strcpy(szstr,"0123456789");
#WP5A-nm8~0产生什么结果?为什么?
+a^)@ ~ o;\r zt0长度不一样,会造成非法的OS
-lW;Wm2D$w0{06.列举几种进程的同步机制,并比较其优缺点。
A]A_#v9m.t g `7sr0原子操作木铎校园 BBS 社区X!hFu[
信号量机制木铎校园 BBS 社区S iGprs![G
自旋锁
P6upF(q0管程,会合,分布式系统木铎校园 BBS 社区dJ5I[6`;`3wvW;r

q$JW0L a kR#N)~07.进程之间通信的途径
6UzO^&m o2b"H d C0共享存储系统木铎校园 BBS 社区3s eC c9Gme.`3o
消息传递系统
6UTTv tk BT3tJG0管道:以文件系统为基础木铎校园 BBS 社区/ne {*m6d-]Z0h;rc;L
11.进程死锁的原因木铎校园 BBS 社区 ^2P;J4oov
资源竞争及进程推进顺序非法木铎校园 BBS 社区O5k+T*T8|SO
12.死锁的4个必要条件木铎校园 BBS 社区']6|zt-t"BND
互斥、请求保持、不可剥夺、环路
PL1dY8wo013.死锁的处理木铎校园 BBS 社区j5VH+Sj8E*I
鸵鸟策略、预防策略、避免策略、检测与解除死锁
dy]y3Y)L1i015. 操作系统中进程调度策略有哪几种?木铎校园 BBS 社区:BRoF&b
FCFS(先来先服务),优先级,时间片轮转,多级反馈木铎校园 BBS 社区O.{3TA%k
8.类的静态成员和非静态成员有何区别?
4r-qln^0类的静态成员每个类只有一个,非静态成员每个对象一个木铎校园 BBS 社区2B.O7f+W'f
9.纯虚函数如何定义?使用时应注意什么?
kApQ1|u0virtual void f()=0;
CSnlU!`S0是接口,子类必须要实现木铎校园 BBS 社区I ?u$|T,k;v v2K
10.数组和链表的区别木铎校园 BBS 社区x6Zz2SUrn8xoJt)z0\
数组:数据顺序存储,固定大小
m8}2AKI2K0n8wm0\0连表:数据可以随机存储,大小可动态改变木铎校园 BBS 社区`+Rw z0h#W5t}

$h`{(L)b5d_ Z&M,g.yuT012.ISO的七层模型是什么?tcp/udp是属于哪一层?tcp/udp有何优缺点?
A8t*p.em;z By5p0应用层木铎校园 BBS 社区6g*IZ_CO0V%K3Ey
表示层木铎校园 BBS 社区'K)A5Y9y'e!`
会话层木铎校园 BBS 社区&~v:{5r&g6OSC:A
运输层木铎校园 BBS 社区R+Z#pJM9C,E
网络层
q4l h7^O7x0物理链路层
MK L~1n_~0物理层木铎校园 BBS 社区$gK sL0Hd"]9@\g
tcp /udp属于运输层
f!}x%Q ^Jf R0TCP 服务提供了数据流传输、可靠性、有效流控制、全双工操作和多路复用技术等。木铎校园 BBS 社区,r9S/d"YC+B
与 TCP 不同, UDP 并不提供对 IP 协议的可靠机制、流控制以及错误恢复功能等。由于 UDP 比较简单, UDP 头包含很少的字节,比 TCP 负载消耗少。
+m!XS4N]8^'G$B0tcp: 提供稳定的传输服务,有流量控制,缺点是包头大,冗余性不好木铎校园 BBS 社区4wC{5{&A!q2Ob
udp: 不提供稳定的服务,包头小,开销小
CI v {2`C;l0
,RfP Du,HLK5K2]0
,pV4ynNu01:(void *)ptr 和 (*(void**))ptr的结果是否相同?其中ptr为同一个指针
5Fb w0F(Z5o0.(void *)ptr 和 (*(void**))ptr值是相同的木铎校园 BBS 社区W Ed#mym sY4F?D
2:int main()木铎校园 BBS 社区Jo{a#y2x@2z%~
{
Cuo4z ?0int x=3;木铎校园 BBS 社区!NT\ko.Jt9y|
printf("%d",x);
W;m)Mn:q7M~wz0return 1;木铎校园 BBS 社区we^*V?QO
木铎校园 BBS 社区a4j3}g;OgFU
}木铎校园 BBS 社区's7T/Wq,T~
问函数既然不会被其它函数调用,为什么要返回1?
0RaM8e`0mian中,c标准认为0表示成功,非0表示错误。具体的值是某中具体出错信息
-z/V[#Tj J0木铎校园 BBS 社区p:}2n D'Y-N'sQ]"SE

p%S%RfB@"d01,要对绝对地址0x100000赋值,我们可以用
,SGh!` M+}z(K*l0(unsigned int*)0x100000 = 1234;
:S)SO ~r-`pf0那么要是想让程序跳转到绝对地址是0x100000去执行,应该怎么做?木铎校园 BBS 社区)C{ U&nv4aN8QR
*((void (*)( ))0x100000 ) ( );木铎校园 BBS 社区:X];^ vKc_
首先要将0x100000强制转换成函数指针,即:
s jcy%^1aV}0(void (*)())0x100000木铎校园 BBS 社区w n:[y;dCy9T
然后再调用它:
H1a'{)Oxr2|0*((void (*)())0x100000)();木铎校园 BBS 社区Zcurp
用typedef可以看得更直观些:木铎校园 BBS 社区RGkI P~UtB&Y%j7x3^
typedef void(*)() voidFuncPtr;木铎校园 BBS 社区)Ai&wD9F(J
*((voidFuncPtr)0x100000)();
G/uN(N1WLS"J7xq02,已知一个数组table,用一个宏定义,求出数据的元素个数木铎校园 BBS 社区 D)bBKX%f+y
#define NTBL
;UTd.S:Fh1?u0#define NTBL (sizeof(table)/sizeof(table[0]))
V2nkO]k y0
Ub%bT8o u0面试题: 线程与进程的区别和联系? 线程是否具有相同的堆栈? dll是否有独立的堆栈?木铎校园 BBS 社区(X S"[s BlZ,Q@v
进程是死的,只是一些资源的集合,真正的程序执行都是线程来完成的,程序启动的时候操作系统就帮你创建了一个主线程。
h8|GCW;O/R^0木铎校园 BBS 社区$t$aK#w`,_!J9d
每个线程有自己的堆栈。
a!\Z9N _0htp0DLL 中有没有独立的堆栈,这个问题不好回答,或者说这个问题本身是否有问题。因为DLL中的代码是被某些线程所执行,只有线程拥有堆栈,如果DLL中的代码是 EXE中的线程所调用,那么这个时候是不是说这个DLL没有自己独立的堆栈?如果DLL中的代码是由DLL自己创建的线程所执行,那么是不是说DLL有独立的堆栈?
M9[(P o8@"|+N0木铎校园 BBS 社区~)G ^_R8u
以上讲的是堆栈,如果对于堆来说,每个DLL有自己的堆,所以如果是从DLL中动态分配的内存,最好是从DLL中删除,如果你从DLL中分配内存,然后在EXE中,或者另外一个DLL中删除,很有可能导致程序崩溃
^a0W~s W r0
6^-uE`U6N0木铎校园 BBS 社区(dL3\]~Jo
unsigned short A = 10;木铎校园 BBS 社区.Q`,Hx LW4pI$\
printf("~A = %u\n", ~A);
D5Rt&Zu#`0木铎校园 BBS 社区 l,Xx0tGj
char c=128;
.C&}:F"E Zl0printf("c=%d\n",c);木铎校园 BBS 社区A\ s1ZsA
木铎校园 BBS 社区 u.eEc d;d!t _X
输出多少?并分析过程木铎校园 BBS 社区UcI{ o
第一题,~A =0xfffffff5,int值 为-11,但输出的是uint。所以输出4294967285木铎校园 BBS 社区{z*oKI7aX
第二题,c=0x10,输出的是int,最高位为1,是负数,所以它的值就是0x00的补码就是128,所以输出-128。木铎校园 BBS 社区&E7R3I I0}|:W
这两道题都是在考察二进制向int或uint转换时的最高位处理。
vL-`D ^-[0
t*DTd4W,~:Vm;?\4um0分析下面的程序:木铎校园 BBS 社区k o&O`6} YpN&w8qL
void GetMemory(char **p,int num)
tB2Pg4V*h"N3m)eu0{木铎校园 BBS 社区d0oc)s7Y-? ]d
*p=(char *)malloc(num);木铎校园 BBS 社区s!G { ]7Ieg
木铎校园 BBS 社区1CAr&cL6L
}
;S(^{PG,?B0int main()
:inO gH*t0{
%~_g~`*U0char *str=NULL;
^!j,D5~c3t&j!m;m0木铎校园 BBS 社区!P`7tc` Py e
GetMemory(&str,100);木铎校园 BBS 社区hR9N.^+VuQ+W
木铎校园 BBS 社区,B$M6xlZ
strcpy(str,"hello");木铎校园 BBS 社区x$vJ4}{5O
木铎校园 BBS 社区{HU1f!c1|&d
free(str);木铎校园 BBS 社区 oy1?pw

x \ILlx2L`0if(str!=NULL)
f8C RdR*c0n0{木铎校园 BBS 社区yu,m B:o&|
strcpy(str,"world");木铎校园 BBS 社区Nykc\ Y
}木铎校园 BBS 社区\5VRW5v:X"f9~ B
木铎校园 BBS 社区/obv)W xB fu
printf("\n str is %s",str);木铎校园 BBS 社区%N2|v _ ]XR
getchar();
K JZ4H0AOe0}
%Jy@"~_f0问输出结果是什么?希望大家能说说原因,先谢谢了木铎校园 BBS 社区q(?2C7pv!E Y^
输出str is world。木铎校园 BBS 社区n5r0d-h4w Qt`
free 只是释放的str指向的内存空间,它本身的值还是存在的.
1i]3o3ZC)hP)f%ELk0所以free之后,有一个好的习惯就是将str=NULL.木铎校园 BBS 社区 xAO'TK(je2^!j s
此时str指向空间的内存已被回收,如果输出语句之前还存在分配空间的操作的话,这段存储空间是可能被重新分配给其他变量的,
BH"O!sw$]LT0尽管这段程序确实是存在大大的问题(上面各位已经说得很清楚了),但是通常会打印出world来。
I Z9Fr-mZtj0这是因为,进程中的内存管理一般不是由操作系统完成的,而是由库函数自己完成的。
d)I*w1JF$}'y0当你malloc一块内存的时候,管理库向操作系统申请一块空间(可能会比你申请的大一些),然后在这块空间中记录一些管理信息(一般是在你申请的内存前面一点),并将可用内存的地址返回。但是释放内存的时候,管理库通常都不会将内存还给操作系统,因此你是可以继续访问这块地址的,只不过。。。。。。。。楼上都说过了,最好别这么干。木铎校园 BBS 社区:A^*Bkn,W N4dx

:Sa{ K$u Ipf7e0char a[10],strlen(a)为什么等于15?运行的结果
y8yH1s)fb#~2~0木铎校园 BBS 社区+_X'V|!T*X0uIn
#include "stdio.h"木铎校园 BBS 社区!y0J _/NG\oV_ L;{
#include "string.h"
Cci!oM.j'CiS{0木铎校园 BBS 社区9y-Y)A!b8O_.[6_
void main()木铎校园 BBS 社区!{"YB-k`4R;`t N
{木铎校园 BBS 社区DY~Il
木铎校园 BBS 社区 Ws ^:Mkl,bFO
char aa[10];
AL7H1ft5W0printf("%d",strlen(aa));
U,wKAT_)V s0}木铎校园 BBS 社区!Z_6|!j6|-Q^
木铎校园 BBS 社区oW0\(V j0K:EE
sizeof()和初不初始化,没有关系;木铎校园 BBS 社区F [9O C @n
strlen()和初始化有关。木铎校园 BBS 社区rpT3f6XX:jP$GW.Cn8J
木铎校园 BBS 社区l8?-m|7r`$^{

$\0c~E AH0char (*str)[20];/*str是一个数组指针,即指向数组的指针.*/
+jM%t }7GVlA4`7l0char *str[20];/*str是一个指针数组,其元素为指针型数据.*/
/k-Kvh[)_ pe0木铎校园 BBS 社区^M)TM+z
long a=0x801010;
9~|9g\f\W0a+5=?木铎校园 BBS 社区'Az?-F[A
0x801010用二进制表示为:“1000 0000 0001 0000 0001 0000”,十进制的值为8392720,再加上5就是8392725罗
-~.]1S t Z01)给定结构struct A
G5CRg6ZE0{木铎校园 BBS 社区3` ^` QR)L[aB#A V
char t:4;
7LU|"JAm(Y(rIm[0char k:4;
jK6Q6G8syF0unsigned short i:8;
{H(ID J/W7u*t0unsigned long m;木铎校园 BBS 社区9TW']9a.egp\
};问sizeof(A) = ?木铎校园 BBS 社区{zC'YS8j
给定结构struct A木铎校园 BBS 社区(_~0Ouj] O"{
{
1V.E]!fg[0R)B0char t:4; 4位
U _B4f$P_;D7\}f b0char k:4; 4位木铎校园 BBS 社区P,K8l xk*YV
unsigned short i:8; 8位木铎校园 BBS 社区&Syd'b}.i
unsigned long m; // 偏移2字节保证4字节对齐木铎校园 BBS 社区lQ-XnO Z/x
}; // 共8字节木铎校园 BBS 社区Vt!ykH+h
2)下面的函数实现在一个数上加一个数,有什么错误?请改正。
Z2C1d:]J0int add_n ( int n )
_r`'N&a+H~x:K0{木铎校园 BBS 社区*Z^PR p/U'F-F{3I
static int i = 100;
!^ unZ{7mUU0i += n;
4X X@}#eS.U]bg0return i;
q({Lx(`l3f0}
l2}g9e L1V l7N0当你第二次调用时得不到正确的结果,难道你写个函数就是为了调用一次?问题就出在 static上?
3kB1T@M;X0木铎校园 BBS 社区pXJ]tG2`)d
木铎校园 BBS 社区wf&W!uZb
// 帮忙分析一下
A,U'B3s w)` {0#include木铎校园 BBS 社区 R'X1I*A+fp-|\
#include
~-KfR4]6J%t8UE0#include木铎校园 BBS 社区Eu7}~ | Dr m.kb"Wv
#include
6^e6l,}}}~Y0#include
8JS~ XI(B0#include木铎校园 BBS 社区1T,B4o3j$i:qMp3Q"p
typedef struct AA
m3_Spq e0{
;p+[,~\1Z*J ~8?:J;h KT0int b1:5;木铎校园 BBS 社区&?c.rR:~o(s
int b2:2;
JR2DQ v7g%j h(HR0}AA;木铎校园 BBS 社区_eEI:?,JX;G0Y
void main()
A(j f]Yi_0{木铎校园 BBS 社区9J9p N lJ G
AA aa;木铎校园 BBS 社区S.bRv,~
char cc[100];木铎校园 BBS 社区;@/Kz5t(i6I$A(QK
strcpy(cc,"0123456789abcdefghijklmnopqrstuvwxyz");木铎校园 BBS 社区9K b2Uk1WLv O&{
memcpy(&aa,cc,sizeof(AA));
5Z"R-K%zl(VlF*U0cout<< aa.b1 <0}b$[T0V/@`"Gs0cout<< aa.b2 <O3x7[,nyh8P N0}
(K~+_5Bl-`Gr0答案是 -16和1木铎校园 BBS 社区T T#D)jmJ[e1^?
首先sizeof(AA)的大小为4,b1和b2分别占5bit和2bit.木铎校园 BBS 社区CV}-R!wt'I9d#{
经过strcpy和memcpy后,aa的4个字节所存放的值是:
`IU)l k,LT)J3l.b00,1,2,3的ASC码,即00110000,00110001,00110010,00110011木铎校园 BBS 社区H+az~m$m
所以,最后一步:显示的是这4个字节的前5位,和之后的2位
(rmlO6iJ3z0分别为:10000,和01木铎校园 BBS 社区eb,L]:e:Z?(Qw
因为int是有正负之分  所以:答案是-16和1木铎校园 BBS 社区^0a&e X0Wp Up~!C~;h
木铎校园 BBS 社区^ ELL4O&^6F` \O
求函数返回值,输入x=9999;木铎校园 BBS 社区 D'lq ND5@.@
int func ( x )木铎校园 BBS 社区A5J3F6o1W
{
\Z#Jo.a"T @"Y Pa%}0int countx = 0;木铎校园 BBS 社区`8W&Z.W e7z(T~;q
while ( x )
*m L wHBC+QH5Wm0{木铎校园 BBS 社区T;e,j&g FW+d
countx ++;
3A-F1@U9w&Kc/}0x = x&(x-1);
#a ? t2x"l:aM v0}木铎校园 BBS 社区 abs2s(o%N0ch(n
return countx;
f{SJ)u8e;R5G:W1O;IDG0}
JJAy^x:G0结果呢?
-p C0T*m7^IM0知道了这是统计9999的二进制数值中有多少个1的函数,且有木铎校园 BBS 社区)x ?0fVcO @
9999=9×1024+512+256+15木铎校园 BBS 社区CL(@L pGNhC
木铎校园 BBS 社区r H({2['h?D @
9×1024中含有1的个数为2;
A"UB$lOX0512中含有1的个数为1;
@"L } L&h~}E(H F$q0256中含有1的个数为1;木铎校园 BBS 社区W"Ma xu9NBm
15中含有1的个数为4;
J2bOI/\)Bq0故共有1的个数为8,结果为8。木铎校园 BBS 社区W6ZU;y5cS
1000 - 1 = 0111,正好是原数取反。这就是原理。木铎校园 BBS 社区:OdTCG&k6U7b
用这种方法来求1的个数是很效率很高的。木铎校园 BBS 社区.@C m)?5U AKF2o
不必去一个一个地移位。循环次数最少。
+yZx7i(M&D?]w0木铎校园 BBS 社区D#qh S([-}N C_
int a,b,c 请写函数实现C=a+b ,不可以改变数据类型,如将c改为long int,关键是如何处理溢出问题木铎校园 BBS 社区f}-n0Y_:c#w
bool add (int a, int b,int *c)木铎校园 BBS 社区^;^~:l p.H%cs3_/tT:?0C
{
c!f\8m{ fk0*c=a+b;木铎校园 BBS 社区 _%eQDw.G
return (a>0 && b>0 &&(*ca || *c>b)));
gf0f3ru sPd%?g0}
r1i!a{ c~[0
l7LJ ?z6W;CJD)Wk0
)|]Hrq H7dF1\5X ^0分析:
'rKh~NF#a,S0struct bit
$\gpl|M;?}0{ int a:3;
O6hD ^i!u0int b:2;木铎校园 BBS 社区xhd j:G'\S
int c:3;
z7G6yd(j9J0};
_)m1@ erpL)p0int main()木铎校园 BBS 社区V3ZD IjEd8EPQ
{木铎校园 BBS 社区$y2deq;W-U
bit s;木铎校园 BBS 社区-@%Mw(H(U
char *c=(char*)&s;
7b$r'e1jj%v0cout<0T-}Bu6@k~0*c=0x99;
,qW}8mWA \v%r0cout<< s.a </B-l,DN,O:]V/x2H0int a=-1;木铎校园 BBS 社区6zC N[7pD v3[lC
printf("%x",a);木铎校园 BBS 社区3Yx+h)c(M(H G
return 0;
lDV4W8H BOI0}木铎校园 BBS 社区pUMX [$} OK-P
输出为什么是木铎校园 BBS 社区o I)QU&w/i[
4木铎校园 BBS 社区9teJ+C-k.KXBr
1木铎校园 BBS 社区0oOxG,HE6w_
-1木铎校园 BBS 社区6Cy@I*n v8B6Z
-4木铎校园 BBS 社区:r#E[9_;X4y
ffffffff木铎校园 BBS 社区hQ1I@!H&k
因为0x99在内存中表示为 100 11 001 , a = 001, b = 11, c = 100木铎校园 BBS 社区Z9UZn8\.B IFm.v:R
当c为有符合数时, c = 100, 最高1为表示c为负数,负数在计算机用补码表示,所以c = -4;同理木铎校园 BBS 社区Qai&I_
b = -1;
;A ]9A"MN2[ e(wwM0当c为有符合数时, c = 100,即 c = 4,同理 b = 3木铎校园 BBS 社区'R JY\ _)N
木铎校园 BBS 社区"azt9ij(i2M5v{*y

[_K/^^+xJXiZ0位域 :
-RZ/]l Os0有些信息在存储时,并不需要占用一个完整的字节, 而只需占几个或一个二进制位。例如在存放一个开关量时,只有0和1 两种状态,用一位二进位即可。为了节省存储空间,并使处理简便,C语言又提供了一种数据结构,称为“位域”或“位段”。所谓“位域”是把一个字节中的二进位划分为几个不同的区域, 并说明每个区域的位数。每个域有一个域名,允许在程序中按域名进行操作。这样就可以把几个不同的对象用一个字节的二进制位域来表示。一、位域的定义和位域变量的说明位域定义与结构定义相仿,其形式为:木铎校园 BBS 社区_e!^d y&RI~
struct 位域结构名木铎校园 BBS 社区pBc0l'J1[t6g
{ 位域列表 };木铎校园 BBS 社区&QJ0}&Fx
其中位域列表的形式为: 类型说明符 位域名:位域长度木铎校园 BBS 社区-H,u'\#ZI5H
例如:木铎校园 BBS 社区nSS]/~
struct bs木铎校园 BBS 社区v;y#[1v6]3ZF
{木铎校园 BBS 社区3m4hX r C k5M E EF_ Ij
int a:8;木铎校园 BBS 社区8DW'nw1V*L
int b:2;木铎校园 BBS 社区v&wI4gnq$I
int c:6;木铎校园 BBS 社区2qt IUK a{-O4V
};木铎校园 BBS 社区 eJf[7a3d-_0|
位域变量的说明与结构变量说明的方式相同。 可采用先定义后说明,同时定义说明或者直接说明这三种方式。例如:
h4I\QhVdi7AV0struct bs木铎校园 BBS 社区(sX%hpf L
{
T@m'sv C9~0B+N0int a:8;木铎校园 BBS 社区+Kr~,?1\9ra;qG
int b:2;木铎校园 BBS 社区(QX&o-~7z,Cv#\
int c:6;木铎校园 BBS 社区5`qc:n;Dg
}data;木铎校园 BBS 社区 }!HM-S F)yyU1Dk
说明data为bs变量,共占两个字节。其中位域a占8位,位域b占2位,位域c占6位。对于位域的定义尚有以下几点说明:木铎校园 BBS 社区t9J#D.g9fP

-Cl)L~'@z'rat01. 一个位域必须存储在同一个字节中,不能跨两个字节。如一个字节所剩空间不够存放另一位域时,应从下一单元起存放该位域。也可以有意使某位域从下一单元开始。例如:木铎校园 BBS 社区 \ Z(g bN;e
struct bs木铎校园 BBS 社区'xY&Fg tH `H
{
)bL*s~ v{rq6e#k0unsigned a:4
7^R[ M2v v3tw0unsigned :0 /*空域*/
%_-X~0r8^j o X8U,O0unsigned b:4 /*从下一单元开始存放*/
TP F1h2z2`|0unsigned c:4木铎校园 BBS 社区)s G~\H#ra
}
O.i*K#y*b%]0在这个位域定义中,a占第一字节的4位,后4位填0表示不使用,b从第二字节开始,占用4位,c占用4位。木铎校园 BBS 社区2Qf3Vgz

[\R)Q P&o)t N$@C02. 由于位域不允许跨两个字节,因此位域的长度不能大于一个字节的长度,也就是说不能超过8位二进位。
U*vDq%hVT-S0木铎校园 BBS 社区b#?+L@5y$V4f Wm
3. 位域可以无位域名,这时它只用来作填充或调整位置。无名的位域是不能使用的。例如:
oA%]/Ry`5v0struct k
"yW2]"eH2Q{0{木铎校园 BBS 社区#f:F@v[ u.Zd.\-T
int a:1
I/B Im EPh0int :2 /*该2位不能使用*/木铎校园 BBS 社区ZO~;fR2p*` s;F \
int b:3木铎校园 BBS 社区z ]k/CLU*a
int c:2木铎校园 BBS 社区1}8o!h FuG$U:n D
};
])F y-^;F0从以上分析可以看出,位域在本质上就是一种结构类型, 不过其成员是按二进位分配的。
@y1YH~j.i0木铎校园 BBS 社区/F.oSvy+IB1~x
二、位域的使用位域的使用和结构成员的使用相同,其一般形式为: 位域变量名•位域名 位域允许用各种格式输出。木铎校园 BBS 社区__)D8gx
main(){
O:Bl+c9Yk|9o H0struct bs
V(S9kW-C m9Q0{
9fi2{y1JJQ0unsigned a:1;木铎校园 BBS 社区u+S] o+_ Be7\
unsigned b:3;木铎校园 BBS 社区3r O7{&Q#x8kM\
unsigned c:4;
iY$P9b&J2^ X0} bit,*pbit;
4s;usP@!\-Bg0bit.a=1;木铎校园 BBS 社区 |,?+PG$Dt"d/F+O
bit.b=7;木铎校园 BBS 社区tHz:L_
bit.c=15;
9\|o%q$Q^0pri
c:x/G/K0`j0木铎校园 BBS 社区K-MRrQfZ
改错:
;o @1v(j,{ UN0#include
dgi0mV#j*n}0木铎校园 BBS 社区/~*BJ`L6m
int main(void) {木铎校园 BBS 社区2^0?v{u$G

OB.Y PZd(S0int **p;木铎校园 BBS 社区HV%ch,m]
int arr[100];木铎校园 BBS 社区;y8A\ O/QH3X5U1^

8q9X(H"Z"aeW0p = &arr;
OW!TCK xts0木铎校园 BBS 社区jK zI(PZ6fZ
return 0;木铎校园 BBS 社区;IqQ&FuM0b
}木铎校园 BBS 社区6x(|zv3ZC| D
解答:
q5z6W5c c'gDc0搞错了,是指针类型不同,
7U^-F7GpG`t,~"_$M(l0int **p; //二级指针木铎校园 BBS 社区 U{FN0x#W0v
&arr; //得到的是指向第一维为100的数组的指针木铎校园 BBS 社区2{_6_0Ymz*TdI%s4b
#include
)me I? ER UUX0int main(void) {
v4_t.NQAE0int **p, *q;
{$H3w6u0eX:l|^0int arr[100];
/A(u[#V0Z3h5v1e!W%b`#P0q = arr;木铎校园 BBS 社区8o.Nh!]|]
p = &q;
$d:Z(yLfj0return 0;木铎校园 BBS 社区)M~&vn!c
}
$_` } ~'wB0
)O SQ(RKO0木铎校园 BBS 社区3C"oyQ~0p`1mp'[:L
下面这个程序执行后会有什么错误或者效果:木铎校园 BBS 社区FB,p1F7B0V5b1f
#define MAX 255木铎校园 BBS 社区C;[\V&Q5kW
int main()
Y"ZJSM$u0{
V3l2_.O!W\/V0unsigned char A[MAX],i;//i被定义为unsigned char
p"l@S|^!U"I8_1z0for (i=0;i<=MAX;i++)木铎校园 BBS 社区Tt-KQCw*{#m;u
A[i]=i;木铎校园 BBS 社区4t.z,T1UQ-S
}木铎校园 BBS 社区-o*y*by~/N
解答:死循环加数组越界访问(C/C++不进行数组越界检查)
o`|8V6F5g@ MX0MAX=255木铎校园 BBS 社区 dd$Ku2D'bPL
数组A的下标范围为:0..MAX-1,这是其一..木铎校园 BBS 社区(k6V9DC[-IS7|{@oO
其二.当i循环到255时,循环内执行:
2I `wHt0A[255]=255;木铎校园 BBS 社区x?_ T/GII
这句本身没有问题..但是返回for (i=0;i<=MAX;i++)语句时,
FkX-X-NcM0由于unsigned char的取值范围在(0..255),i++以后i又为0了..无限循环下去.木铎校园 BBS 社区m]8N0|-Gw6[N a

:E!V ^8RJ2m:ma0struct name1{木铎校园 BBS 社区7U8\8Vna_.z]o
char str;木铎校园 BBS 社区4q HZ|V
short x;
$|*v*^.n\#G0int num;木铎校园 BBS 社区8k9N#p QH"VI
}木铎校园 BBS 社区,hd)N#[)r0F/J

J LQ+gTq6FP0struct name2{木铎校园 BBS 社区_OS!x}hE
char str;
2]2VJ$jf!Ta/I u)zR0int num;
(|vFd$N8^0short x;
'jI3R1l9K4|5J$k2b0}木铎校园 BBS 社区&oikI;zlLhu,T6so

p{x@L#C!x0c0sizeof(struct name1)=8,sizeof(struct name2)=12
;|2uK Ws6DDQV0在第二个结构中,为保证num按四个字节对齐,char后必须留出3字节的空间;同时为保证整个结构的自然对齐(这里是4字节对齐),在x后还要补齐2个字节,这样就是12字节。木铎校园 BBS 社区@5Y1JZY6K4]C

fb:X5iq,nCJ0intel:
Pt$cfv.?:D L2^0A.c 和B.c两个c文件中使用了两个相同名字的static变量,编译的时候会不会有问题?这两个static变量会保存到哪里(栈还是堆或者其他的)?
FWlkleGl0static的全局变量,表明这个变量仅在本模块中有意义,不会影响其他模块。
"jl-[a tK0他们都放在数据区,但是编译器对他们的命名是不同的。
@&MZNL N0如果要使变量在其他模块也有意义的话,需要使用extern关键字。木铎校园 BBS 社区c+`/e+x ^|
木铎校园 BBS 社区|9NYuhR6t9V A8_9RQ
struct s1
bql%l;Jj Rw0{
I }'EP7z.g0int i: 8;木铎校园 BBS 社区IiG-J W-{R4m
int j: 4;木铎校园 BBS 社区!\Dr2E&i`T8K
int a: 3;
(N]`8U8O&P#tGi0double b;木铎校园 BBS 社区%ZE w,}:B/E
};木铎校园 BBS 社区A\m^h_I e-y
木铎校园 BBS 社区){#i rOu
struct s2
D)|Tj py#Qk [0{
/g'^7P)p;uiL0int i: 8;木铎校园 BBS 社区0QEY(Uh0_BC
int j: 4;木铎校园 BBS 社区Zg%e/[%h
double b;木铎校园 BBS 社区\3H4sO:}Q0]0h
int a:3;木铎校园 BBS 社区!YWw#I!UY*|C
};
^0|9Pe Z)}2@I\S0木铎校园 BBS 社区P _R!A ^.]`e5^
printf("sizeof(s1)= %d\n", sizeof(s1));木铎校园 BBS 社区;}TS\au/L
printf("sizeof(s2)= %d\n", sizeof(s2));木铎校园 BBS 社区/ab{C~o7t6t'G{
result: 16, 24木铎校园 BBS 社区.k[e `]*Iy
第一个struct s1木铎校园 BBS 社区d:H\,e*h5?EK
{木铎校园 BBS 社区8{x PY&b {E@
int i: 8;
8sv5HO M.Ot0int j: 4;
e.tI:pE,i&BsL0~1U0int a: 3;木铎校园 BBS 社区*Ur fy4aj,g0\5^
double b;木铎校园 BBS 社区7Y;}a@ _.f!F
};
t@3|2hC@!E0理论上是这样的,首先是i在相对0的位置,占8位一个字节,然后,j就在相对一个字节的位置,由于一个位置的字节数是4位的倍数,因此不用对齐,就放在那里了,然后是a,要在3位的倍数关系的位置上,因此要移一位,在15位的位置上放下,目前总共是18位,折算过来是2字节2位的样子,由于double是8 字节的,因此要在相对0要是8个字节的位置上放下,因此从18位开始到8个字节之间的位置被忽略,直接放在8字节的位置了,因此,总共是16字节。
v!~TW_&SC'L Q!q0
'To(Q S(Vl0第二个最后会对照是不是结构体内最大数据的倍数,不是的话,会补成是最大数据的倍数
} T7m@/n01)读文件file1.txt的内容(例如):
D1c#]6E#y"|012木铎校园 BBS 社区|7pL*M {P
34木铎校园 BBS 社区I e3y2Ol$^G~8J[ [
56
8d\3A"` TE9^0输出到file2.txt:木铎校园 BBS 社区1fsyao+_RmV
56木铎校园 BBS 社区@td E](?$Pm6\
34木铎校园 BBS 社区S4|S5YbO?/F
12
Z0V7a*iZ$] S*@0(逆序)木铎校园 BBS 社区+]({/_*O i u-]
2)输出和为一个给定整数的所有组合木铎校园 BBS 社区0p Q i],C^H
例如n=5
V/j\#`&F~;y+\05=1+4;5=2+3(相加的数不能重复)木铎校园 BBS 社区,{Z6zZp}rc6g-S
则输出
W#z \L ? I#h5EAC\{ X01,4;2,3。木铎校园 BBS 社区 z uw1iaV0P5t7q k)`
望高手赐教!!
d WN z0u5A0木铎校园 BBS 社区!x3K9o {_j
第一题,注意可增长数组的应用.木铎校园 BBS 社区$q4Y6H;ZH0F*p
#include木铎校园 BBS 社区8Xjb%w:n k^
#include
^\].f9dva!z0
\M4N q k*{*H)rVCU$Z0int main(void)木铎校园 BBS 社区%\Y0KFU;D&t
{木铎校园 BBS 社区0H3VE3D^7?ZS f
int MAX = 10;木铎校园 BBS 社区;r,h"Uy emhn
int *a = (int *)malloc(MAX * sizeof(int));
;KjxG[`e KR+c0int *b;木铎校园 BBS 社区;f{.vB*o+|w"Ko
木铎校园 BBS 社区;vM0d lB uHm
FILE *fp1;
%v/G`4qG3B^}.SpP9|0FILE *fp2;木铎校园 BBS 社区9\M+{Y;@NAa
木铎校园 BBS 社区$r1[pF2^@G:IEm
fp1 = fopen("a.txt","r");
6?Ebs1g F$VCA'Q0if(fp1 == NULL)
"XINpV7`!|0{printf("error1");
OYW E^R0exit(-1);木铎校园 BBS 社区zW,S2t7Z^M,x&v
}
7j#Ev@)[ Y:Y0木铎校园 BBS 社区}e7wJ a
fp2 = fopen("b.txt","w");
f%HYU$Fo;x W0if(fp2 == NULL)木铎校园 BBS 社区(G)AV#S}-T
{printf("error2");
I.~} c9O,_0exit(-1);木铎校园 BBS 社区7M8ZS6WA+J2Q lON
}木铎校园 BBS 社区 y-VfW3oc6l
木铎校园 BBS 社区:t wLL_
int i = 0;
s2j(H TuuL0int j = 0;
&VR%EKlh+E R0木铎校园 BBS 社区g kPV,u8^
while(fscanf(fp1,"%d",&a[i]) != EOF)
lB&raV8R8}0{木铎校园 BBS 社区N5g D&F[
i++;
}!XAUl9d s L*s9L0j++;木铎校园 BBS 社区 pm%m N z$Qa.J`
if(i >= MAX)木铎校园 BBS 社区"kQya3?yH;nwG
{
I%WYP mps/J0MAX = 2 * MAX;木铎校园 BBS 社区U6C3?,?(~
b = (int*)realloc(a,MAX * sizeof(int));
9s1{`1?e'VG/{0if(b == NULL)木铎校园 BBS 社区t g;gN?N$z}
{
zSo#n1IU0printf("error3");木铎校园 BBS 社区:C:`A5G6u~`b
exit(-1);
k%XkOO!{Z0}木铎校园 BBS 社区of~&z,UKhd
a = b;
$H\/wT3Vq2G'T}0}
'@^ J\M0j0}
L#`4HY8g$Y)IP4w0木铎校园 BBS 社区+u ok8b `:o
for(;--j >= 0;)
6~N2c~E(_m5Sz0fprintf(fp2,"%d\n",a[j]);木铎校园 BBS 社区D M2q'| }5L
木铎校园 BBS 社区fUK+[2h,my
fclose(fp1);
1]Yxf3Ftr0fclose(fp2);
j;Wj ?V*B-W0木铎校园 BBS 社区bZ'_8Tx%Rm]iZ X!o
return 0;
#n[ w*d*ey%u o2~0
Z1Q$bCmb KJ0木铎校园 BBS 社区0Uf3@F3v \np |
}木铎校园 BBS 社区 u0`F*]J%xVE

?$@v}g0|0第二题.木铎校园 BBS 社区{~b2J&L0in#?8Xs
#include木铎校园 BBS 社区;Xm#hmL#h@v

y8Mt+aEo"Y0int main(void)
W {?^:xV.A,B0{
? r.K#`;b$D0unsigned long int i,j,k;
X`h;A&J~A0
,Cf nM ^%u0printf("please input the number\n");木铎校园 BBS 社区8AV;e3}ZxXv
scanf("%d",&i);木铎校园 BBS 社区ddO N c;\NE7^
if( i % 2 == 0)
3f(XjS'E'w*V\0j = i / 2;
l1P;I#a)|+m E8o|0else木铎校园 BBS 社区r*iW!Ea} w
j = i / 2 + 1;
:o3B8_-R"v e*XG i0
Q"L)_,A{0printf("The result is \n");木铎校园 BBS 社区9c#d3F5N%Z#Y5Q r8nLk
for(k = 0; k< j; k++)木铎校园 BBS 社区#@(nZ({oE/Z'N;^
printf("%d = %d + %d\n",i,k,i - k);
Tz&OkW[9J-c*]0return 0;木铎校园 BBS 社区o2T ghtf
}木铎校园 BBS 社区!aY%~+c T6a
木铎校园 BBS 社区'gu+?Z[ dB7]
#include
a}!TP ]9pk0void main()
wRu8p*d&p:qd0{木铎校园 BBS 社区gOXLq
unsigned long int a,i=1;木铎校园 BBS 社区-c8N S x9~&h}X@
scanf("%d",&a);木铎校园 BBS 社区jk]5k!z }
if(a%2==0)
;UL;^\I1I {XL4}0{木铎校园 BBS 社区T!v"Y$j%b;s+p|
for(i=1;i
木铎校园 BBS 社区skx0K5MSs|8P6Uf
printf("%d",a,a-i);
1~ nT{$tA3\0}木铎校园 BBS 社区TxE&{.qAIJ
else
H S^x EU3?0for(i=1;i<=a/2;i++)木铎校园 BBS 社区T\%H!V:oxls j
printf(" %d, %d",i,a-i);木铎校园 BBS 社区f`_`R)I$U6^B
}
"Mun6ny-K0
)\M cXM;}0兄弟,这样的题目若是做不出来实在是有些不应该, 给你一个递规反向输出字符串的例子,可谓是反序的经典例程.木铎校园 BBS 社区.m-R"`3BOD{qZ:t

-ty}2h"{0}4pq0void inverse(char *p)木铎校园 BBS 社区(` y8S;^ fosR$g
{木铎校园 BBS 社区&d.Vb~[(k!WF$J
if( *p = = '\0' )木铎校园 BBS 社区%rdd`m2eY
return;
*A K+ss\{*|0inverse( p+1 );
Ca)y{ve^-z0printf( "%c", *p );木铎校园 BBS 社区5Q']/Pi5V"m_m&G
}
(ny4pKY|.B3X0木铎校园 BBS 社区pz;m5f5t _jDH H
int main(int argc, char *argv[])木铎校园 BBS 社区2IIxuSK&MQ7dm8eW
{木铎校园 BBS 社区%P"m[p'AFx0n%P$p#B{
inverse("abc\0");
*U h+dE(xvu0木铎校园 BBS 社区h ]8F"D}I m
return 0;
'yw R(b4v }9_4gM0}
`EnAl-U*p\ j0木铎校园 BBS 社区.@[Az\%V5\y
借签了楼上的“递规反向输出”
loLq.J s-t"jh| ^0#include木铎校园 BBS 社区1l wUhu6WMU$]bb
void test(FILE *fread, FILE *fwrite)
y0\;t7Dw U {E0{木铎校园 BBS 社区6blkbXv|"N
char buf[1024] = {0};木铎校园 BBS 社区+r!\}!h5v1nmf
if (!fgets(buf, sizeof(buf), fread))
0S0DK-~T!C H.a8T8[0return;木铎校园 BBS 社区[8m`E ~ ke~
test( fread, fwrite );
-ww z E {t Gq0fputs(buf, fwrite);
3q8m:tnt\0}
zG|F0^1K8rj0int main(int argc, char *argv[])
:AXb:k$R-crR0{
f?t cP/U0FILE *fr = NULL;木铎校园 BBS 社区zu:E I$T!t.IIX
FILE *fw = NULL;木铎校园 BBS 社区JQ$gP\KL
fr = fopen("data", "rb");木铎校园 BBS 社区7n}9i4h#N9^q@
fw = fopen("dataout", "wb");木铎校园 BBS 社区qut'w?;O-V
test(fr, fw);
IMQRkN+N0fclose(fr);木铎校园 BBS 社区cy#^ _QF
fclose(fw);木铎校园 BBS 社区MQV j&_ i
return 0;木铎校园 BBS 社区,IS^VqOl
}
.{!Z%E1o i4a u'gP C]j0
j g6I0cfN-GS.D?%O%J0在对齐为4的情况下
ddXa)o xNL0struct BBB木铎校园 BBS 社区+L8E zv6h2k7P V
{
+K)D.G%OJ`$WVY:B0long num;木铎校园 BBS 社区5YF NYo"i$a
char *name;
Hk?|S9}9d0short int data;木铎校园 BBS 社区7A nV8qb4s
char ha;木铎校园 BBS 社区J"Cr)Pg8}5A/g
short ba[5];
f!t PKA0}*p;木铎校园 BBS 社区KN C @ek
p=0x1000000;
MBj-|3l}0^'Cu._0p+0x200=____;木铎校园 BBS 社区1~.Ic!r%}0|
(Ulong)p+0x200=____;
T ^9j0}q5KS"?0(char*)p+0x200=____;木铎校园 BBS 社区Vz\b$x{
希望各位达人给出答案和原因,谢谢拉
FPzC,J nq*U0解答:假设在32位CPU上,
/GU EH`0sizeof(long) = 4 bytes木铎校园 BBS 社区9dD0qCo \L
sizeof(char *) = 4 bytes
x []9^Z0sizeof(short int) = sizeof(short) = 2 bytes木铎校园 BBS 社区3MrBq2k%Y.qc
sizeof(char) = 1 bytes木铎校园 BBS 社区+UgqtMdhT

WR(KQ6Vf0由于是4字节对齐,木铎校园 BBS 社区-t5wa,`,y"p Wsf
sizeof(struct BBB) = sizeof(*p)木铎校园 BBS 社区}9_|"{ xw2M:P#f$b ?
= 4 + 4 + 2 + 1 + 1/*补齐*/ + 2*5 + 2/*补齐*/ = 24 bytes (经Dev-C++验证)木铎校园 BBS 社区9u8Go }$OO

4B6MY$c Y Q7A%O0p=0x1000000;
$jT F y5Ft1xaH0p+0x200=____;
C+@/N[{.i}0L0= 0x1000000 + 0x200*24
ts~TT*f6MJo(M_;a0木铎校园 BBS 社区 ]&J+G]X,U!P
(Ulong)p+0x200=____;
BMn)BCU0= 0x1000000 + 0x200木铎校园 BBS 社区9YyQ+qQ{ F

l9@%vmu`*kE0(char*)p+0x200=____;
s8P)W fapp0= 0x1000000 + 0x200*4
/liL.o(V"S5vgE){e0木铎校园 BBS 社区%bd+K*Q+E0eA{
你可以参考一下指针运算的细节木铎校园 BBS 社区o(g f*f@ uPl
木铎校园 BBS 社区Y9AZgp9gI;F$Y2Y
木铎校园 BBS 社区&\ w ^ yW0\B]7Gr
写一段程序,找出数组中第k大小的数,输出数所在的位置。例如{2,4,3,4,7}中,第一大的数是7,位置在4。第二大、第三大的数都是4,位置在1、 3随便输出哪一个均可。函数接口为:int find_orderk(const int* narry,const int n,const int k)
s5`'s Y?L.M0要求算法复杂度不能是O(n^2)木铎校园 BBS 社区(S.Rh^:za1I(z
谢谢!木铎校园 BBS 社区pH)p3mO;xz&m$d
可以先用快速排序进行排序,其中用另外一个进行地址查找
HD.|uN3q/c [3vu0代码如下,在VC++6.0运行通过。给分吧^-^
w;d2G C;f(o#o0
#B:w*]~ eT.t-c0//快速排序
vIt4rz3\0
+na l+AN_%]K/i0#include
Ew-vl4uJzQ0
H&I K!gG9c.U0usingnamespacestd;木铎校园 BBS 社区[)j&b)i r^~

#} ]O'qF/eB9ei0intPartition (int*L,intlow,int high)
&d'~#x$n!x6n ~i0{
]m!DjXWL8OW9W0L0inttemp = L[low];木铎校园 BBS 社区.X*Tp!G/x$y;fdu
intpt = L[low];木铎校园 BBS 社区F#ofFz[3[`!@

;[0u/v\;p&i0while (low< high)木铎校园 BBS 社区8q3X'? g"R~
{
@)_!{!K{ F&F0while (low< high && L[high] >= pt)木铎校园 BBS 社区A)D]%j:SA3h/\(Zi
--high;木铎校园 BBS 社区WKZ WP"{
L[low] = L[high];
\I S%zR7y#hm C7oG-E"b0while (low< high && L[low] <= pt)
? [U"_\ gJZ.h0++low;
JU(V:vW/|+GID|0L[low] = temp;木铎校园 BBS 社区M0z ^7^W(P
}木铎校园 BBS 社区b2} YthwJd
L[low] = temp;木铎校园 BBS 社区my_e cM"\7Uu
木铎校园 BBS 社区`9dE6]q0V#|Fl
returnlow;
C]8`BdI0}木铎校园 BBS 社区 M.VY:ppu
木铎校园 BBS 社区?0BQY$]/~4H@O8Q
voidQSort (int*L,intlow,int high)木铎校园 BBS 社区v;yl#[6V?_}5{
{木铎校园 BBS 社区$J"zfG5g |6iV
if (low< high)
;o2ona8]r!@ {o0{木铎校园 BBS 社区zY2df({2ga
intpl = Partition (L,low,high);木铎校园 BBS 社区/Ii,A&k`m

!G-t3V;bAEwWh0QSort (L,low,pl - 1);
[)q1P5S5E qW0QSort (L,pl + 1,high);木铎校园 BBS 社区$w3UU)i ~z
}
0b2L ]aK6E0}
Ktny+c0木铎校园 BBS 社区5}2A$q~@;_m'H
intmain ()
e @&UH"j$_cin+e};w0{木铎校园 BBS 社区g;YU.\9u:J+MJ!q5p
intnarry[100],addr[100];
DhF%Nw0intsum = 1,t;
!A(oB9a,CqrAPj0木铎校园 BBS 社区G}S(RP[I@9vD1{
cout<< "Input number:" << endl;木铎校园 BBS 社区*L9A6iE-H4eV j
cin >> t;木铎校园 BBS 社区 {8V~^`#b:oM(w:A~!O
木铎校园 BBS 社区*w5ADqsJ/] ~
while (t != -1)木铎校园 BBS 社区)U Nm/~FYP
{木铎校园 BBS 社区 I,E!}"Np#X j$P f1?
narry[sum] = t;木铎校园 BBS 社区8b(N@x/\.}@'Vz,Z
addr[sum - 1] = t;木铎校园 BBS 社区D j-NSO0j
sum++;木铎校园 BBS 社区0`3mwN/[a*I1k%]$\
木铎校园 BBS 社区;Co!w!w1D K
cin >> t;
:C4fY9jk4WXV o&U0}木铎校园 BBS 社区2t8EAk0\ e Mi

a*Gbh$I}O0sum -= 1;木铎校园 BBS 社区3C1e b5['A O:yXDZ$`
QSort (narry,1,sum);
.o9z^|$x0I0木铎校园 BBS 社区m0^2QK&j"^+Z|
for (int i = 1; i<= sum;i++)
A ]u6l l$m4v0cout<< narry[i] << '\t';木铎校园 BBS 社区,Dl }8dH
cout<< endl;
Y k-@5I[g[0
j ^&x!pf^D$t ?A0intk;木铎校园 BBS 社区8XOk;dS2Z
cout<< "Please input place you want:" << endl;木铎校园 BBS 社区(G4fl7r/[{$P
cin >> k;
]6f)?-GB"M's`0木铎校园 BBS 社区2z&@D3s-M\ ge
intaa = 1;
+Vb~d3_ q0intkk = 0;
j-b,\p6MP6^l0for (;;)
]6B(f-\ X2iFQ,o0{木铎校园 BBS 社区-vB-HDjT,o.\
if (aa == k)木铎校园 BBS 社区;la4b.m-V,Wx
break;木铎校园 BBS 社区 LM ~+K;i
if (narry[kk] != narry[kk + 1])
q-uL&A9H2[B0{木铎校园 BBS 社区zU!m$ig?6B
aa += 1;木铎校园 BBS 社区z G^ ^)z(Q OB
kk++;
)C0L A+C0\(M8G0}木铎校园 BBS 社区Nq*cgD5n~BI6U
木铎校园 BBS 社区0^-A9O` \EVL1Z
}木铎校园 BBS 社区3?/~+Z5{/Nu
木铎校园 BBS 社区 VG%R&[l
cout<< "The NO." << k << "number is:" << narry[sum - kk] << endl;木铎校园 BBS 社区 }5N gev
cout<< "And it's place is:" ;
:Hi#YWkWd t0for (i = 0;i< sum;i++)
C|hju7d!w2`0{木铎校园 BBS 社区|\Q#~7h/f
if (addr[i] == narry[sum - kk])
){RH:Za6i,u0cout<< i << '\t';
|S*VG5fC6?K0h;H0}木铎校园 BBS 社区f$` q o9zhQu^
木铎校园 BBS 社区tek)w e8T6R9{
木铎校园 BBS 社区r0|IUv
return0;木铎校园 BBS 社区KG;aN-A|%b(Jc ~8\,I1N
}木铎校园 BBS 社区)])Oj ?1a2n*yK1a){7x

7c0j8c2if.@D01、找错木铎校园 BBS 社区Q)o)w'Tp J
Void test1()
_"u ^p qk Tw n:o0{木铎校园 BBS 社区F%HM#R~
char string[10];
$Gy;d|1vzmf|;Q!nr0char* str1="0123456789";
?)H2Zh?H+C0strcpy(string, str1);// 溢出,应该包括一个存放'\0'的字符string[11]木铎校园 BBS 社区i x_&K4x5v7_0XS0u
}木铎校园 BBS 社区[7D d^:Wi:k)k2L
木铎校园 BBS 社区qj^)?DC9b:gb#z|

igr };q0Void test2()
Kdk qQ txl7Wm0{木铎校园 BBS 社区[N+E#Iqy3j1W;RP
char string[10], str1[10];
/z S$zJ.t9aT B0for(I=0; I<10;I++)
@X.\6b"L)[:i0x0{
J;xOG&j;^0str1[i] ='a';木铎校园 BBS 社区5T.U'_ h2DD
}
*RO!vxA&Y,K0strcpy(string, str1);// I,i没有声明。木铎校园 BBS 社区g,x0A{1dt.k4{l
}
1`(Wd ^vs;?OM0
{-Q\'~j0Void test3(char* str1)
#T-cl#u0cE-R {C%S0{
(Qi-\Yy0MW(Lk0char string[10];木铎校园 BBS 社区S `%Ir D)t.q-pQXI
if(strlen(str1)<=10)// 改成<10,字符溢出,将strlen改为sizeof也可以木铎校园 BBS 社区ju^v/`$H)F
{木铎校园 BBS 社区CRK|q0k| Q
strcpy(string, str1);
J-Xr&Zr;_B:@^7Q.P0}木铎校园 BBS 社区KP ~ gN#Z?
}木铎校园 BBS 社区hNi7L.{3ya| d-aS.Z
木铎校园 BBS 社区Nho wH8x s
2.木铎校园 BBS 社区 b2VV0F8y;d)D@
void g(int**);木铎校园 BBS 社区t/S!H\]
int main()
CIPwt%s ?Y0{木铎校园 BBS 社区t(~"_*@"s:u:J
int line[10],i;
J(~5X6t zn)T3v;^0int *p=line; //p是地址的地址木铎校园 BBS 社区!f;Otlk H%GN
for (i=0;i<10;i++)木铎校园 BBS 社区\ W%S2D4j|W3r}i7J
{木铎校园 BBS 社区 {2xJ a}NQ
*p=i;木铎校园 BBS 社区V:OS ^7w
g(&p);//数组对应的值加1
1FHsnn-u0}木铎校园 BBS 社区| XS9Y B\#pw+y
for(i=0;i<10;i++)木铎校园 BBS 社区!N+d&P7N/e,if.si
printf("%d\n",line[i]);木铎校园 BBS 社区k}@q] F
return 0;
hH'X d5R*I@&C(W0}
"^!f ];_m0木铎校园 BBS 社区 z|5[3CvFe~
void g(int**p)木铎校园 BBS 社区2u$eR'V8\vA
{
"{ P0j?,M$fa0(**p)++;
/q w x5z'l*c/g w)? A0(*p)++;// 无效
L?;|A \k q0}木铎校园 BBS 社区\4Ke#`$@ y
输出:木铎校园 BBS 社区(q&aXPx7vB0^d
1
}t8W ~!Rj02
6nig K/WZA-vF03
X{)[6z4_.T%U9a04
/m"jVus\_05木铎校园 BBS 社区@8jN4yt&VG)|V/y
6
8c(@}F-l2eY7?B5MU07
Pl,Iwf)h%Mz;X08木铎校园 BBS 社区!Sz bUp+t)O
9木铎校园 BBS 社区arDeZ)m)J3B9x
10木铎校园 BBS 社区e6{S9l:]pa:N
3. 写出程序运行结果
P,K@*_%H]0
2N8N.X-_,}BA [0int sum(int a)木铎校园 BBS 社区-M^3\(m;]#ov8c
{木铎校园 BBS 社区2ws1s7n|
auto int c=0;木铎校园 BBS 社区 Khd ey6k
static int b=3;木铎校园 BBS 社区D{Y G"W+h {{
c+=1;
R i$Jb(R h0b+=2;
.uI:l6v0L0return(a+b+c);木铎校园 BBS 社区 o/D X+f6g
}
IR;g6}5@S$l6dAa0
P~ Z'XZ6sT0void main()木铎校园 BBS 社区/`9f*Hd\'u6_&Q.w
{木铎校园 BBS 社区\]!LOh;P
int I;木铎校园 BBS 社区0\x`E"v%c)c
int a=2;木铎校园 BBS 社区X`9T'R:NH#J$a/hU
for(I=0;I<5;I++)木铎校园 BBS 社区w6@3`4ALMM]g-a!D!V
{
|0Kdw+` VjT^*`0printf("%d,", sum(a));木铎校园 BBS 社区@e2AHr2P4x
}
j,`ob{8f6e0}木铎校园 BBS 社区*Z2b%}1^QW
// static会保存上次结果,记住这一点,剩下的自己写
8v8g({T;U-g_!r4k0输出:8,10,12,14,16,木铎校园 BBS 社区#]2TyU8T%@ns
木铎校园 BBS 社区1X*] _ NA5L

g9LHM6KhU4O p"_04.
-dM/?G9YC)\m J0木铎校园 BBS 社区7K F tG?
int func(int a)
2Ma&i:u X"R:c@0{
S n ok(G g q+a0int b;
VZS.^e9c)?0switch(a)木铎校园 BBS 社区mnd5B-P!?.qf
{
1a3VD!d9b3F-_*i'\0case 1: 30;
-EIu%^(\%n,X0case 2: 20;
LSz;nR'PlV`0case 3: 16;木铎校园 BBS 社区+gY%I z#t
default: 0
J7Jg.rG!|1M0}木铎校园 BBS 社区Z8xO;{+f
return b;
Ki"H$y;ncGd0}木铎校园 BBS 社区?%Uj3f*W1w|o7J @
则func(1)=?木铎校园 BBS 社区!uo lR EW
// b定义后就没有赋值。
m#_ l'E J7|Kv5o0木铎校园 BBS 社区"o0}l \X9_\G
5:木铎校园 BBS 社区GM:{~fi+t*f
int a[3];木铎校园 BBS 社区-t3L r}(lfS$u
a[0]=0; a[1]=1; a[2]=2;木铎校园 BBS 社区P c n9_*S4{
int *p, *q;
,iM t.X}Q0p=a;
P%`&sT Di0q=&a[2];木铎校园 BBS 社区 E T#s:q%`Y zt
则a[q-p]=a[2]木铎校园 BBS 社区W9U7O~ }$\0E|
解释:指针一次移动一个int但计数为1木铎校园 BBS 社区6`L3hl,y0n P

7X,o!\'B1Y[,O Ry5_0今天早上的面试题9道,比较难,向牛人请教,国内的一牛公司,坐落在北京北四环某大厦:
a^'pEU nS6Y9m01、线形表a、b为两个有序升序的线形表,编写一程序,使两个有序线形表合并成一个有序升序线形表h;木铎校园 BBS 社区 uNH,I/XPT%?7d
答案在 请化大学 严锐敏《数据结构第二版》第二章例题,数据结构当中,这个叫做:两路归并排序
v |;k"t7XC#Ve+\0Linklist *unio(Linklist *p,Linklist *q){
P Gbl z7vw#Mb h,C0linklist *R,*pa,*qa,*ra;
TM5X"oV5txCv0pa=p;木铎校园 BBS 社区_B$SP9`9f^
qa=q;
W|!k ag }DR0R=ra=p;
mwX ?e"t&fL8s0while(pa->next!=NULL&&qa->next!=NULL){
3C!UWI0YJ?s0if(pa->data>qa->data){
)^[? RLk8y)l,@([-V0ra->next=qa;
\@Pn%v*G/V*GtIUV_0qa=qa->next;
:b.Y:^.N/~Ku.pk+Pk0}
}ch"@ ~0else{木铎校园 BBS 社区7P:["?}S
ra->next=pa;木铎校园 BBS 社区-D t[VG;{g
pa=pa->next;
l+fr5nOx0}
#?4gv!Hj:y0}木铎校园 BBS 社区G^.`Q1r7dLu}$j
if(pa->next!=NULL)木铎校园 BBS 社区hdrhW z8u
ra->next=pa;
*ed#td#a$V7l0if(qa->next!=NULL)
ME1^UY0ra->next==qa;木铎校园 BBS 社区1Wyhc;I~
return R;
0n"ET[;N0}
0p8v]hP:p0P02、运用四色定理,为N个局域举行配色,颜色为1、2、3、4四种,另有数组adj[][N],如adj[i][j]=1则表示i区域与j区域相邻,数组color[N],如color[i]=1,表示i区域的颜色为1号颜色。木铎校园 BBS 社区b}2Db;e
四色填充
"j3m1L*Ty03、用递归算法判断数组a[N]是否为一个递增数组。
9Vv5A3H+V0l5cD+R0递归的方法,记录当前最大的,并且判断当前的是否比这个还大,大则继续,否则返回false结束:木铎校园 BBS 社区*b+LITJPJ'k)V
bool fun( int a[], int n )木铎校园 BBS 社区/]%B3p+LYD
{
3qg8pnRQ0if( n= =1 )木铎校园 BBS 社区G0SQ[Q1I.h|6e7M
return true;
.I7iiz$sy}s0if( n= =2 )木铎校园 BBS 社区e$J4xXwu1n
return a[n-1] >= a[n-2];木铎校园 BBS 社区4T'[ b.F9Bg7I,\M
return fun( a,n-1) && ( a[n-1] >= a[n-2] );木铎校园 BBS 社区VryXzcmW
}木铎校园 BBS 社区2EfoN$U$F&s"{8l/\
4、编写算法,从10亿个浮点数当中,选出其中最大的10000个。木铎校园 BBS 社区%Emv j uCU
用外部排序,在《数据结构》书上有木铎校园 BBS 社区F y8[/\ tSP;C
《计算方法导论》在找到第n大的数的算法上加工木铎校园 BBS 社区T k'A!{M-V x
5、编写一unix程序,防止僵尸进程的出现.木铎校园 BBS 社区#P:ys:aZ0G\j*y
木铎校园 BBS 社区"Jk _!on9G d
Top木铎校园 BBS 社区? O,Ic%zf t*F#L
  回复人:free131(白日?做梦!) ( 一级(初级)) 信誉:100   2006-4-17 10:17:34   得分:0木铎校园 BBS 社区3l$E K7im
?   
6r|!~$}'M0
1zb3^5f+VH0同学的4道面试题,应聘的职位是搜索引擎工程师,后两道超级难,(希望大家多给一些算发)
V{-f/N}~R!G"P? eQ01.给两个数组和他们的大小,还有一动态开辟的内存,求交集,把交集放到动态内存dongtai,并且返回交集个数
&E(xn7Jm g0long jiaoji(long* a[],long b[],long* alength,long blength,long* dongtai[])
9S6W}@7` s0s/z02.单连表的建立,把'a'--'z'26个字母插入到连表中,并且倒叙,还要打印!
gf;QcP0P,Wm0方法1:
#~ t4O)Q9g0typedef struct val
g.s c/D7P-lw5D0{ int date_1;木铎校园 BBS 社区 kg7|bE`*I ~*X Xf$J
struct val *next;木铎校园 BBS 社区 W$?0DyWy7U\F
}*p;
R5Vg_ {Z"K@0木铎校园 BBS 社区7M(b+N'eO$Z1\5a.B
void main(void)木铎校园 BBS 社区nl5D$e-Vws.i$U
{ char c;
E @nD|,c4^ V:l0木铎校园 BBS 社区'] P` {cu'W3~*e'}
for(c=122;c>=97;c--)木铎校园 BBS 社区2n"[#y8z8o,x.T9i
{ p.date=c;
S)m&A}!gk0p=p->next;木铎校园 BBS 社区%UU]-A#b A w ]{/y9q5j
}木铎校园 BBS 社区 Y r h:q$X
木铎校园 BBS 社区a?r;SpUM+n$U1D
p.next=NULL;木铎校园 BBS 社区x V,f@b ^v.Xa\d
}
0Q7r6B)A+`#h H0}
2JN0]W-AN'U0方法2:木铎校园 BBS 社区 m,x+Zh9?M
node *p = NULL;
$C{)mV#YCe.V0node *q = NULL;木铎校园 BBS 社区}it%C H h

LBB_7W.v0node *head = (node*)malloc(sizeof(node));木铎校园 BBS 社区O6y ~d$m
head->data = ' ';head->next=NULL;
9[0Zuhi0
u~+T)dN0node *first = (node*)malloc(sizeof(node));木铎校园 BBS 社区H2x q/k4Rn
first->data = 'a';first->next=NULL;head->next = first;木铎校园 BBS 社区:jcR!^kw2ap?D
p = first;木铎校园 BBS 社区3G3? hO1S(^b2?

[9H7a+N)Z0int longth = 'z' - 'b';
5x;C]7Af m!I0int i=0;
;x x#A|a}`0while ( i<=longth )
/t1DT'h"Q5h ? b0{木铎校园 BBS 社区t!i&Bc"\F!`k#s
node *temp = (node*)malloc(sizeof(node));
[R p kZ0temp->data = 'b'+i;temp->next=NULL;q=temp;木铎校园 BBS 社区YH8X#Y"pYn
木铎校园 BBS 社区)g;Cc-uCG
head->next = temp; temp->next=p;p=q;木铎校园 BBS 社区 mZb(y)P7om
i++;木铎校园 BBS 社区p"d0[Ioa
}
|%}(~R)T,],@0木铎校园 BBS 社区m9@Afi m
print(head);
OA&K7k%~Ze6LV0木铎校园 BBS 社区+y~7Cr+IG6Jw
3.可怕的题目终于来了木铎校园 BBS 社区^|u^)kC3^1p(R
象搜索的输入信息是一个字符串,统计300万输入信息中的最热门的前十条,我们每次输入的一个字符串为不超过255byte,内存使用只有1G,
S1D"~K!} zAZ'J0请描述思想,写出算发(c语言),空间和时间复杂度,
"CO"A XcS7IV04.国内的一些帖吧,如baidu,有几十万个主题,假设每一个主题都有上亿的跟帖子,怎么样设计这个系统速度最好,请描述思想,写出算发(c语言),空间和时间复杂度,木铎校园 BBS 社区2V1E k;KPCz X

j,UZ"O3o6g0
u[/Gr.`'rcI0#include string.h
E*R }/{9`0main(void)
3mn h q/zZ-b0{ char *src="hello,world";木铎校园 BBS 社区$kxVR0h z
char *dest=NULL;木铎校园 BBS 社区\*\5K%a@h&i5d}
dest=(char *)malloc(strlen(src));木铎校园 BBS 社区;Gw^ h$u
int len=strlen(str);木铎校园 BBS 社区e(p0t] r
char *d=dest;木铎校园 BBS 社区5b%V QD%C"c,Fv
char *s=src[len];木铎校园 BBS 社区_g)e!w`Z2\w4S\
while(len--!=0)木铎校园 BBS 社区J/Y [aS
d++=s--;
/P#v5Ug4{` J"{0printf("%s",dest);木铎校园 BBS 社区+l*q7R,Z R+H} y
}木铎校园 BBS 社区4D BO s7I&F6O
找出错误!!
{/b;d{t#k+Vmg0#include "string.h"
T&} DY-bcG7lvvD!p0#include "stdio.h"
T&Wi;YI0#include "malloc.h"
{j.szWlb_,e.B H0main(void)木铎校园 BBS 社区?kA%r3bO
{
!`~9H7jVCP0char *src="hello,world";
&Ea)n.[&E:gS6~0char *dest=NULL;
b'JnB&G5r0dest=(char *)malloc(sizeof(char)*(strlen(src)+1));木铎校园 BBS 社区m|a:\^_
int len=strlen(src);木铎校园 BBS 社区lEv4] J+w qDk
char *d=dest;木铎校园 BBS 社区!cKrB4a,`.Xt
char *s=src+len-1;
,TD m4} X]4k{0while(len--!=0)木铎校园 BBS 社区z4D/@+\0m8T r,{
*d++=*s--;木铎校园 BBS 社区 hI,CH I+Y}f1u
*d='\0';
tAR bxEr-}O7i3c0printf("%s",dest);木铎校园 BBS 社区g!V#}g$TFH
}木铎校园 BBS 社区;S7S ~*u#EW3~h

)D.`)D{qI)E P01. 简述一个Linux驱动程序的主要流程与功能。木铎校园 BBS 社区D&bLU/w r$~#] m p
木铎校园 BBS 社区.k!}$Cttv X6U z
2. 请列举一个软件中时间换空间或者空间换时间的例子。
lfF/`pbUAz0void swap(int a,int b)
]&}0e,y&maq0{木铎校园 BBS 社区{"k;A2M`iSv
int c; c=a;a=b;b=a;木铎校园 BBS 社区R;[#T*{-l i?7c
}
eIY*E(os:]0--->空优
1DIn l,f,Jg"l0void swap(int a,int b)木铎校园 BBS 社区,dKp5y6hR4EnvgA0r
{
?S]!l&T%qPa;h"h s$f&}0a=a+b;b=a-b;a=a-b;木铎校园 BBS 社区:nb9]Ye
}木铎校园 BBS 社区#Q9n|o8}k\
6. 请问一下程序将输出什么结果?
~l,egHccZ,gW j0char *RetMenory(void)
m9\r2OihF0{木铎校园 BBS 社区P]'Q9\ Aa {#hBk
char p[] = “hellow world”;
z'A I9h2_-G!b-\)A0return p;
0~W`3qDg0}木铎校园 BBS 社区\:Cs;s~)i^`I'g,P
void Test(void)
+p/_M!Xm5l-`ex3M[0{
j0X4tSE&D ? X0char *str = NULL;木铎校园 BBS 社区q:Qym0{$d"P [#@0X6x
str = RetMemory();
1s/oKR)O0printf(str);
9D&To,hqrO0}木铎校园 BBS 社区llaXch
RetMenory执行完毕,p资源被回收,指向未知地址。返回地址,str的内容应是不可预测的, 打印的应该是str的地址
#KrlEoY p0
7?%i1r H1Y1}FY0
3Nov0qsh ~6n:J0写一个函数,它的原形是int continumax(char *outputstr,char *intputstr)木铎校园 BBS 社区U_!j6S2Q:Vc'v6M
功能:
mD/qX%he P.W5?$[0在字符串中找出连续最长的数字串,并把这个串的长度返回,并把这个最长数字串付给其中一个函数参数outputstr所指内存。例如:"abcd12345ed125ss123456789"的首地址传给intputstr后,函数将返回木铎校园 BBS 社区 vq i#Z4` C;D l
9,outputstr所指的值为123456789
| xN/RU3B[ J0int continumax(char *outputstr, char *inputstr)
4cag*g:QG5?0{
+}E:D/qd [%oI0char *in = inputstr, *out = outputstr, *temp, *final;木铎校园 BBS 社区#O6I3j2a+p
int count = 0, maxlen = 0;
Z!R.uz6t0木铎校园 BBS 社区 W5Y:p)H \+ww1p9M
while( *in != '\0' )
#c+PQ4U&e v9|-kt0{
7t!u9} H/b]0if( *in > 47 && *in< 58 )木铎校园 BBS 社区 DiIhR
{<