找工小结~~北电+深信服+。。。

homexxhh

时间如白驹过隙，转眼就要毕业了！从上大四开始就为了工作忙忙碌碌准备一些找工作的事宜，到现在为止，工作也算是稳定下来了，有空写个面经！PS：本人现在找到的公司并不牛，只是想在这里留点对师弟师妹可能有用的东西！
7 I+ {) `, l- c! p- A       我自认为自己的基础不是很扎实，所以我是从暑假就开始准备的，整个暑假都呆在学校，学习编程，并特地为找工作准备了一个项目！开学的时候刚好完成了，那么从9月份到10月份一个月时间是一直在复习之前学过的知识，这里要跟师弟师妹说的就是一定要在找工作之前把重要的科目复习一遍，不过如果时间不是很充裕的话就不用复习所有的科目了，至于要哪些科是要复习的就是通过看前人留下来的笔经和面经，确定哪些重要科目。因为我是通信工程的，所以我给自己选的重点科目就是：C++、数据结构、通信原理、移动通信、现代交换原理、现代通信网、自学了计算机网络！然后再复习重点科目里面的重点章节。比如C++在类那部分的继承、多态、虚函数、虚基类；数据结构的 单链表的增、删、改、查，二叉树的遍历、排序、查找；通信原理就是总结了整个通信的流程，计算机网络的：TCP、UDP、IP、OSI七层。现代交换原理、现代通信网 看得比较少，重点科目中的重点科目是：C++、数据结构、计算机网络。最后在找工的过程中证明这三科确实是最重要的三科，重点章节也基本上覆盖了。所以建议师弟师妹们在接下来的时间里面重点加强下这三科的知识！
' T2 k' j( V& m1 w1 }       准备完了，正式投入到找工大军中！
      北电依然跟往年一样，来得特别早！也是我投的第一家公司，投了研发职位。第一份简历----炮灰！没通知我去笔试~~~极度不爽，本人特别看重的是北电，所以花了大力气去准备C++和数据结构，当然，接下来的肯定是去霸笔了，唉~~~处女笔就是霸笔！北电的笔试题有四个部分：第一部分是英译中和中译英(研发类职位是两种题型都有，测试的就只有英译中)，第二部分是一道编程题，将一个字符串中的所有字母放到字符串的前端，所有数字紧接着字母存放，其他所有字符放在最后面，这个简单。第三部分是程序填空题，涉及到一个最短路径的问题，图的内容，因为自己没学过，准备的时候也没准备，只能现场根据自己的思路整了一番。第四部分是改错题，平衡二叉树的，也不会！唉~~~理所当然给BS了！而且今年北电不给霸面~~~~北电到此结束！总的来说，北电比较重视的是C++、数据结构(链表、二叉树、排序、查找)、计算机网络。(在最后附上自己整理的关于北电笔试和面试的资料)
3 J) Y2 I4 O# h1 C1 g8 P( C       除了北电后比较感兴趣的就是深信服了，总共可以说是参加了这个公司的3次招聘！找工作之前是不知道有这个公司的，第一次是在10月份初吧，深信服来学校宣讲，了解到，总的来说深信服的待遇是挺不错的，而且那公司很年轻，我认为比较有前途！对找工作还没很清楚的概念，她是现场投递简历，然后过几天就笔试，整个过程就那么一个星期！那天宣讲会我去得很早，听完宣讲然后投了简历，给BS了~~~当时还不知道怎么把握机会，比如去霸笔，霸面之类的！第一次机会就这样过去了！第二次的时候是在中大BBS上看到的消息，在中大宣讲，也是现场投递简历，可能中大的人不是很看重这公司吧，那天去的人很少，很幸运，拿到了一次笔试机会！笔试的时候感觉还是蛮好的，因为之前自己看过一些深信服的笔经，有一些题目是做过了，还算做得比较顺利！但是再一次给BS了！说实话，深信服的笔试确实挺难的！但是，经过这次笔试后我进行了很深刻的总结，将自己不会的题目都好好的总结了一次，把所有不会的题目都整理一遍！在整理的过程中，对照往年的笔试题目，发现05、06、07三年的题目很多很多部分是一样的！！！所以把这些题目组成了一个题库！于是第三次机会来了，我通过第一次笔试时候通知我的号码联系上了深信服的一个HR，很诚恳的跟他说了一通自己对公司很感兴趣之类的！大概过了一个星期，然后他给了我再一次的笔试机会！这次我就学乖了，把自己总结的题库所有题都好好的做了一遍，把所有不会的题目都彻底弄懂！那份试题是6页，总共12面！好像是18道编程题，6道简答，几道填空和选择！题量很大，2个钟完成，果然不出所料，基本上的题目都是做过的，所以虽然题量很大，但是基本上两个钟的时间都是用在写字上面，基本上没用大脑想了！两个钟基本算把全部题目都做完了！顺利接到了面试通知，同样，经过对几年的面经总结，发现面试题目同样也是由一个类似题库的东西上来的！不过面经找到不多，所以准备得不是很充分！问得很深，只有几道是回答得比较好的：1、new 和 malloc 的区别  2、将一棵树转换成二叉树  3、windows socket编程中的linger的用法 4、setsockoption 的用法(好像是9种)，常用有哪些，分别讲一下 5、调用函数的时候，系统取函数的实参是从后面开始取还是从前面开始取?  还有一些回答得不是很好的，如:printf函数是可以实现参数个数可变，是怎么实现的？还有一些其他的不记得了！最后那老总跟我说:"这次你没希望了!"，被现场BS了！总的来说：深信服比较重视的是C++的能力!最好有项目经验!(在最后附上自己整理的关于深信服笔试和面试的资料)
" x. a* N( I7 I2 W7 V+ k/ h6 y其他公司就不在这里啰嗦了！最后是签了深圳的一个IC公司，台资企业，虽然不是很大的一个公司，但是自我感觉是蛮适合我的，适合我的水平，也和我的兴趣比较符合！所以算是结束了找工了！找工作不一定要找最牛的，找到一个适合的就是最好的！
- L( N- d4 s! R7 r- |/ t& S8 W       上面说了那么多，总结下自己对大学的看法：...... 这总结就等版主给个精华再继续了！^_^ （开个玩笑，主要是因为昨天才想起在后院留下点墨水，而过两天就要去实习了，后续有空再继续帖一些个人觉得比较好的资料上来给大家PP）
8 }( _8 `# d3 V, @- G; n( N- a- `
: Z9 ]! Z# C! ]8 X总结我想到一点就上来补一点吧：
     1、个人认为可以上网找一些笔试常见题型来看看！很多公司都会照搬那里的题目的！虽然我们这样做不是最根本的，但是目前来说还是比较有效的！
5 T; i/ i% z0 m( F    2、多看笔经、面经，建议多上华工、中大的BBS
) y6 x1 x; m3 D- t5 W+ n    3、因为我现在在实习了，结合我这一小段时间里的感受给师弟们一个建议，因为我现在做的是单片机的，所以就说这方面的，想在单片机方面发展的话最好不要停留在老师的教学水平上，自己去实践一下IIC，EEPROM、串口通信（双机、单片机和电脑），还有记得参加学校的电子设计大赛，等你找工作的时候你就知道那东西有多好用（谨记！！）！
7 E4 ^- b4 m4 X  e( w8 ]/ m5 \    4、下面的是深信服08年的笔试题、基本上是齐的了，据我个人统计，05、06、07、08这四年深信服都是这套题，所以大家可以稍微深入点去研究，至于其他公司的题目就大家多去各大BBS逛了！还有这份题不能挂在网上太久，我过5天就把这题目删了，认为可以用得着的都保存起来吧，也请各位下载了题目的就留个名，其他人如果错过了这五天时间的就大家互相转发一下！还有，那些题目的答案都是我做的，所以 ^_^  辩证的看！
! i! _1 r- s1 |0 h! G    5、我发现在找工的时候很多同学多存在一些问题：1）在大四上学期的时候不努力去找，跑了几场招聘会就说很累了，我认为这是不可取的，在你没找到工作之前，每一场招聘会对你来说都是一个机会，如果你在大四上学期错过了很多机会，那么意味着你可能在大四的下学期可能会更加累！你是否希望在大四下学期大部分同学都去公司实习了你还在找工作呢？ 2）好些同学去招聘会的时候心态不是很好，抱着一种试试看的心态，我认为这大可不必，首先，如果你抱着这种心态去参加招聘会你不会很尽力的。 3）那些招聘人员也不是吃闲饭的，给人家一看就看出来了！你说还有没机会呢？ 4）你可以说你不自信。但是我认为，一流的学校有三流的学生，三流的学校也有一流的学生，我们广工也不是三流学校，那么我们这里肯定可以出一流的学生。为什么跟华工、中大的一起的时候就感觉没自信呢？相信自己！！其实他们也很菜~~~ ^_^

--------------------------------------华丽的分割线------------------------------------------
深信服08年笔试题
3 Q2 j% g. v+ k7 C! u. X: p
填空选择类
; r; C' ^, x5 D  {8 @
2
12
1 t) f6 f. D  h4 A7 d' ^" Z1112
3112
132112
, z* l  q4 y* f% v0 c5 |311322或1113122112下一行是什么？有什么规律？ ///已解决

意思是上面一行有1个1，1个3，1个2，2个1，1个2，即132112
. ?% K7 r" t/ Y, A+ R; g: b
7 b9 X  {3 e5 B0 t; d8 `- W（M）？（a++）：（ a--），A，M==O，B，M==1，C，M！=O，D，M！=1
* _5 b, a$ ]5 B(条件表达式) ? (条件为真时的表达式):(条件为假时的表达式)  ///已解决
+ S4 y; i9 H5 C* H
# O/ j, w, ~* {4 y4以下哪些通信方式是可靠的通讯方式  
: f$ _  @2 Y; t) O: U  V1信号2管道3消息4tcp 5udp 6串口I/O
9 ^0 J$ E* b6 s  |' P" v& K8 ~$ A
. h9 ]- s0 `) V# K( ], q1 I可靠：信号 管道 tcp
, A9 ]/ M% E' S) F可以在不同主机之间的：
& w& l. P2 [, q
Unix的启动顺序排序。
) _4 b% f7 A" d" b(A)        Rc.X  (B) Rc.sysinit (C) login (D) init

9 w) t" |7 o( O$ y& H! MDBAC

进程的几个基本状态：就绪、执行、阻塞
$ Z1 ?* J! O) b/ C; ?( W4 [0 z
6 g: ?5 Y0 n) T- g; ^8 v7 ~程序：
" u# u5 F3 `* I* ]' q: [
. C( _  \# w# ]9 C3 [$ B) j现有1000个球，10个盒子，问各个盒子内应该分别放入多少个球，才能达到需要1至1000
% T% |- Z" p) L, Q  |! w之间任何数量的球，你都可以用若干盒子组合出来（用C/C++编写程序）
3 x4 |* s& \/ ]5 P0 S; l
2 i: j; g/ b# @# ?! Z0 E/ \, o1、2、4、8、16、32、64、128、256、489

6 P" U4 A( t2 g# B4 F用一个程序示意常见的错误能够导致栈破坏，如何检查？

#include "iostream.h"
# R, {/ z5 {+ {  F: E) X#include "string.h"
void main()
{
/ }: n* G) d2 B. m: q        char str[5];
# |. w1 @- a5 V) I1 y% p        cout<<"input: ";
1 \  m- ]0 `! i        cin>>str;
        while(strlen(str)>5)
* S& f$ N" W0 q$ Q. l) s$ [' _8 @! v        {
                cout<<"too long!"<<endl;
                cin>>str;
        }
# i- u- _. w$ C' T        cout<<str<<endl;
8 ]2 m# {; ~+ i6 n7 s, L# z}

2 R1 v1 c  o: @如果系统堆栈很小,不能处理超过4级的函数调用,如何解决八皇后问题
#include<iostream.h>
void main()
; C. H7 }; k2 a1 A( H! h{
        int A[8];
        int flag;//标记
- a* S0 }# I1 N0 y$ K' M( s        int m=0;//总共有几种答案
        int t,tt;
4 Y1 h; `( U# d0 H        for(int a=1;a<=8;a++)
                for(int b=1;b<=8;b++)
2 \% U7 X! p+ ^' T7 @" ^                        for(int c=1;c<=8;c++)
                                for(int d=1;d<=8;d++)
                                        for(int e=1;e<=8;e++)
                                                for(int f=1;f<=8;f++)
                                                        for(int g=1;g<=8;g++)
. J1 _5 @+ K/ F* V8 ?                                                                for(int h=1;h<=8;h++)
% k5 X2 i! W6 n* f1 ?                                                                {
                                                                        // 为了便于运算数组里
5 g7 l$ \, a: e* j" ^* @) I                                                                        A[0]=a;  //A=k  指第i行的在第k列已经有放置
: ?! m- O/ x2 U# x6 ]# O                                                                        A[1]=b;
0 P2 H- Z# ~- `) Q; y' A' \* }                                                                        A[2]=c;
# v4 }1 s( i9 e                                                                        A[3]=d;
1 |1 r4 v5 P' C$ L                                                                        A[4]=e;
                                                                        A[5]=f;
                                                                        A[6]=g;
/ i  M  O& e( p                                                                        A[7]=h;
                                                                        //比较是否在同一列
& l- a3 O2 E' O                                                                        flag=0;
5 a# r# X* F4 i' I  e9 A                                                                        for(int i=7;i>0;i--)
                                                                        {
: c$ j3 R/ E7 N( n$ x                                                                                for(int j=0;j<i;j++)
                                                                                {
9 b+ {1 W* r1 s, A; d                                                                                        if(A==A[j])
                                                                                        {
                                                                                                flag=1;
$ J: V- T" M; n# m2 N& X& @                                                                                                break;
                                                                                        }

( p) Q- \7 d8 J$ P                                                                                }
' f5 a; X& d4 |                                                                                if(flag)
" B' c- M5 u5 v; C9 [9 S                                                                                        break;
( Q5 I0 O8 v) t+ Y3 S1 R                                                                        }
. q% g  x+ E$ q; M: I) @                                                                        if(!flag)//比较是否在对角线上
                                                                                for( i=7;i>0;i--)
                                                                                {
& s* Q. M+ j9 h. s* w* q$ r9 J                                                                                        for(int j=0;j<i;j++)
                                                                                        {
6 c' L; e9 e& ~* ]4 s" P/ c1 ~                                                                                                t=A;
                                                                                                tt=A[j];
. x( U5 f$ o' |/ Q                                                                                                if(tt>t)
  r% _% x% a+ M) r* {                                                                                                {
/ `) [. ]% a1 {                                                                                                        tt=9-tt;
# K) P1 g9 m( Y  j; N. M4 e                                                                                                        t=9-t;
0 S5 v4 `1 W5 n! p0 ^' u/ \                                                                                                }
9 b/ n- _' @! V/ V. J& X                                                                                                if(t-i==tt-j)
" q0 j" Q  C# N% V! S: p3 h* A                                                                                                {
                                                                                                        flag=1;
                                                                                                        break;
                                                                                                }

4 j: N" ]' j1 _                                                                                        }
                                                                                        if(flag) break;
& U9 c1 N  V; E  h! _/ F                                                                                }
                                                                                if(!flag)
                                                                                {
                                                                                        //cout<<endl<<endl;
                                                                                        for(i=0;i<=7;i++)
                                                                                                cout<<A<<" ";
! v5 j/ P' A; _7 h+ g( _                                                                                        m++;
/ R* n3 @9 y5 k+ \' S  }                                                                                         cout<<"************************"<<m<<endl;
; ~+ e$ r" d( g" q6 l                                                                                }
                                                                }
# F# `+ t% q& X/ U  K! t}
6 h4 u; h' @6 J- s
, T0 Z1 S6 P3 I- m* b) r2 }5 a要求在s1中删除所有s2的字符，要用最快的算法
) D. l# z& m3 U% b! c/ i2 m* y% w. E引入 char tempstr[256]={0}; char* p1=s1 ; char* p2=s2;
1、        第一次遍历S2，while(*p2) tempstr[*p2++]=1;
2、        第二次遍历S1，
while(*p1)
4 t: U2 b3 x5 A, Z  t# f+ T{
                If(tempstr[*p1==’1’])
( h. U  _6 ^0 g7 y* R/ r" O{
                        *p1=0;
. D  c' }' s% Y8 q}
5 K. {# f% f( U" R0 EP1++;
0 C1 L2 s6 D  `; v7 Q}
3、        再次遍历S1
P1=s1;
, ^3 F# o: e0 \7 A* b2 @2 ~3 jWhile(*p1)
7 ?9 @( w) C$ ], ]$ q! p{
                If(*p1==’0’)
{
9 l0 I* J( L9 U" [4 x: X                        P2=p1+1;
                        While(*p2==’0’)
+ v; F% l6 t* Z                                P2++;
/ N3 d' [# b7 Y- |                        *p1=*p2;
* ]( n% R) s* l# f% {                        *p2=’0’
                         P1=p2;
}
. H" U% j& a, C# {9 p}
! z0 K7 a( k( K
写一个函数判断系统是大端还是小端。若处理器是Big_endian的，则返回0；若是Little_endian的，则返回1.
. e: O3 c& d4 u/ q大端格式：在这种格式中，字数据的高字节存储在低地址中，而字数据的低字节则存放在高地址中
9 _8 d: i3 K, K6 [4 `0 A小端格式：与大端存储格式相反，在小端存储格式中，低地址中存放的是字数据的低字节，高地址存放的是字数据的高字节
* ~4 [. _( O7 \% |, S2 F# n联合体union的存放顺序是所有成员都从低地址开始存放。
8 v: ]9 t! U$ d6 J6 uInt checkCPU ()
{
9 G* T, ]0 Q% Q' p6 H        Union w
6 x% l& N. m, e$ w{
        Int a;
3 S3 y+ i9 w- g        Char b;
. R& \" _8 U( ?}c;
& V! g$ @/ \3 g) y* x+ E% [c.a=1;
! B- ?5 D+ p7 I6 ^% h* Oreturn (c.b==1);
$ L0 w4 I0 S! a2 W* O' p9 d}


9 r7 a3 e$ \6 r0 I6 u) W
! R) o' `/ O' S/ ?3 t
给出两个链表的头指针pHead1 和 pHead2 ，写一个函数判断两条链表有没交叉点
Node* checkLink(Node* pHead1,Node* pHead2)
{
0 L( r/ E0 k: K2 o        Node* p1=pHead1,p2=pHead2;
: j+ J( G/ P' ?        int i=1,j=1;
        if(p1==NULL || p2==NULL)
                return NULL;
        if(p1==p2)
9 _+ l- `' D1 ]8 z$ _. H                return p1;
9 _  Q$ |( F7 S# G( _        while(p1->pNext!=NULL)
        {
! W4 D* J1 M$ ^                p1=p1->pNext;
                i++;
        }
- v% l& c1 |9 m1 X2 x. h+ [1 H  x7 c        while(p2->pNext!=NULL)
        {
5 s% s& [0 C; O2 ?1 Z7 y& N) s                p2=p2->pNext;
                j++;
        }
        if(p1==p2)
# C- ]4 o0 O- E2 P8 v                return NULL;
        else
8 E  j9 r) `, O% p- i* ]        {
+ E+ I0 i8 D- w% n  u% o% Q7 w4 `                for(int k=0;k<fabs(a-b);k++)
                {
: l9 K5 W% b. n4 m8 P; I                        if(i>j)
                                p1=p1->pNext;
6 f1 C' [4 S5 g* U3 g; C                        else
' _: i* Y% g2 g8 K                                p2=p2->pNext;
" |4 b4 d$ V3 e2 A4 D5 V3 Q8 R2 B1 N                }
: h  Y' K5 z# H* r                while(p1!=p2)
$ e4 Y" S) Z; t+ \. c6 {                {
                        p1=p1->pNext;
                        p2=p2->pNext;
                }
. U* u* Z, p. ?, T9 L! W6 ?                return p1;
6 {' i; p$ j+ Y        }
, H/ ~& ?2 d, y' l9 Z5 B+ I2 y5 d}
; [6 Q! A) A  U! H/ f/ }) M9 V
" O4 m0 P( s/ |" `用C/C++编程，从1到100中取出10个不同的数，要求打印出所有可能的组合；
( v7 K3 M/ k1 T' }1 [) F# @6 n#include <iostream.h>
int source[100];
! _4 o7 ]+ [/ z8 O5 m2 m; P7 L: qint dest[10]={0};
int index_source=0;
int index_dest=0;
int k=10;
int i=0;
int j=0;
4 L) k0 O2 c' N- A) g! h9 h! Fvoid composition(int source[], int index_source, int dest[], int index_dest, int k)
; O4 |0 U3 Z$ S+ ?4 I' ?; q6 N{
; y! \$ u  P2 \  ^. l; l  {        if(100-index_source==k)
2 I- B; F! X' r, u6 Q2 Q1 x        {
5 O  t! Z$ m) |/ ~$ `2 {  [3 s  s                for(i=0; i<index_dest; i++)
9 ~! G9 N7 n# g0 |/ Q$ Z5 u  W                {
                        cout<<dest<<" ";
                }
1 Z; _. U; U6 \* m3 v                for(i=index_source; i<100; i++)
                {
# Q8 Y4 _/ R7 k" c" {2 ]                        cout<<source<<" ";
4 y& K/ K. l7 z6 D  d                }
                cout<<endl;
1 L; o+ s# ~' e& I( g                return;
        }
        if(index_source<100 && k==1)
        {
7 l( U- @: E& ^, T" V4 w- r1 [  l5 \                for(i=index_source; i<100; i++)
                {
                        for(j=0; j<index_dest; j++)
                        {
                                cout<<dest[j]<<" ";
& Q0 t- X. H' {7 U8 o( l9 S- t                        }
* H9 C! W! e2 c# Z$ }5 x1 S                        cout<<source<<endl;
( \2 U1 ^" Z6 ~$ y                }
                return;
" D0 D8 ~' {$ o" c4 K& e% C8 g  W+ b        }
6 K& H7 D2 l3 o0 m- n$ k        composition(source, index_source+1, dest, index_dest, k);
! P0 J* T4 K& A7 c6 C/ d$ @' i$ n        dest[index_dest++]=source[index_source];
5 r, ^) ]3 K6 J8 u- h        composition(source, index_source+1, dest, index_dest, k-1);
, |2 ?. {+ [* ]4 U4 Z. s" M}

' w1 u+ {  l$ ]# B  F3 Tvoid main()
{
        for(int i=0;i<100;i++)
0 c$ F9 E% W/ Y! u2 }9 V                source=i;
        composition(source,0, dest, 0, 10);
}
& G* A0 a3 `6 q9 C0 `

* z; P3 W* N) N问答
2 V% S+ I7 f# c# U
const 有什么用途？（请至少说明两种）
" l3 B, C* G% ^/ F1、        用在变量前面的时候可以避免变量被修改
2、        用在函数声明部分允许const 的类对象成员访问const 成员函数，如果类的成员函数不会对数据成员进行修改的话最好把该函数定义为const类型，这样无论是const的类对象还是非const 的类对象都可以访问该函数
, c; W# K' j# m0 n4 ]+ W: A) {) T) h3、        可以用来代替define ，define 只是简单的代替，但是const 还会进行类型检查。
! z$ B* h- Q  m0 E2 a
) C  F: H3 W5 P% Q怎么避免头文件重复包含

#ifndef  H_HEADFILENAME
#define  H_HEADFILENAME
0 B% C# f9 E1 P2 ~( n) Y文件内容….
: S5 `3 V( X6 H8 n  \#endif

: i7 A% s: G$ c7 t+ r拷贝构造函数和赋值号的异同
8 D; T2 c/ y0 N; o+ ~0 w3 ~8 h" T3 F
3 D- }% h& W! q7 X( I  e! m9 K4 |同：都可以对对象的成员进行赋值
异：
拷贝构造函数首先是一个构造函数，它调用的时候产生一个对象，是通过参数传进来的那个对象来初始化，产生的对象。
赋值是把一个对象赋值给一个原有的对象，而且还要检查一下两个对象是不是同一个对象，如果是的话就不做任何操作。
; P# p' {; N1 Z
& T) P% \, ~. c* J- A2 D哈希表和平衡二叉树的适用场合

哈希表：哈希表查找速度比较快，但是要耗比较多的内存。所以比较适用于对查找速度要求比较高、且内存空间足够的时候
2 ]  L8 c" H) m) C6 h- U' r平衡二叉树：如果想在以后用二分法查找的时候查找速度比较快的话用建立平衡二叉树的方法（）
& D' b7 [' [  o/ X$ h
recv函数如何在阻塞模式下没有收到数据就返回
3 c, O  D. g, \  z# }6 I
3 s1 w! D, O& ~+ |2 X7 ^, ~3 ^检查window （release）下的内存泄漏
& }' Q& Z# ^( c
1、        放置关键字 assert（）
2、        生成map 文件。它并不往可执行文件exe 中添加任何东西，只是在编译的时候将各个函数入口地址记录在后缀为.map的文件中，程序崩溃的时候可以得到一个EIP地址，通过地址知道崩溃所在函数
  q! n) s1 v% J( ?. D3 V3、        可以设置断点，在希望设置断点的地方加入 _ASM int 3
4、        可以通过编译时的汇编程序看出
5、        采用第三方工具
7 Z. Y  n! i9 c# W0 j( }在C++中extern c的作用
- ]8 }7 F  Z0 Z$ F1、        extern是C/C++语言中表明函数和全局变量作用范围（可见性）的关键字，该关键字告诉编译器，其声明的函数和变量可以在本模块或其它模块中使用
' i  W  j' z" Y; g0 d) P9 w6 w2、        被extern "C"修饰的变量和函数是按照C语言方式编译和连接的；
! @8 n; c% Q4 [+ {" f! S; l
; b) k$ E& B$ A9 x7 n: M临界区（Critical Section）、互斥量（Mutex）、信号量（Semaphore）、事件（Event）的区别
+ M2 V8 P0 G* U! s1、临界区：通过对多线程的串行化来访问公共资源或一段代码，速度快，适合控制数据访问。在任意时刻只允许一个线程对共享资源进行访问，如果有多个线程试图访问公共资源，那么在有一个线程进入后，其他试图访问公共资源的线程将被挂起，并一直等到进入临界区的线程离开，临界区在被释放后，其他线程才可以抢占。
( s5 l# y' T8 E0 o& w1 K2 g2、互斥量：采用互斥对象机制。 只有拥有互斥对象的线程才有访问公共资源的权限，因为互斥对象只有一个，所以能保证公共资源不会同时被多个线程访问。互斥不仅能实现同一应用程序的公共资源安全共享，还能实现不同应用程序的公共资源安全共享
$ I# v! b$ ^# l$ ~+ n' y7 s4 K3、信号量：它允许多个线程在同一时刻访问同一资源，但是需要限制在同一时刻访问此资源的最大线程数目
% h2 k0 l* @; I+ z4、事 件： 通过通知操作的方式来保持线程的同步，还可以方便实现对多个线程的优先级比较的操作
6 G+ J; L$ P# W1 t; y+ m, u/ z% K
, O0 @: U# F' b2 p% K% F0 W/ u: |Main函数中两个参数的作用
第一个形参argc是一个整型变量，第二个形参argv是一个指针数组，其元素指向字符型
8 T4 [0 w- P$ d" v# l) o数据。
5 o: f+ M2 d- |& z用带参数的main函数可以直接从命令行得到参数值（这些值是字符串），在程序运行
时，可以根据输入的命令行中的不同情况进行相应的处理。利用main函数中的参数可以使
3 Y- Q! p! p8 Q) P程序从系统得到所需的数据，增加了处理问题的灵活性。
/ |& H2 ?8 A/ ^: X9 l- @* v
8 p/ K) o7 W/ P# [6 C$ |[ 本帖最后由 homexxhh 于 2008-9-11 21:53 编辑 ]

轻水惜寒

好，来学习的，帮顶了

叶落无痕

赶紧留名:hug:

J.Kidd

留名再看.....

lhpzong

看完留名

zzdny

面包会有的。。。

云出无心

师弟好样的！

Ike

好，我也留名。。

U秀学生

可惜我不是计算机的！

108820507

谢谢LZ

vio

不错，顶了

arhlongge

收藏了

feng~boy

原帖由 U秀学生 于 2008-3-4 13:08 发表
可惜我不是计算机的！

/ [7 n5 Y2 n6 A( ^
) ?" j) y0 A6 HLZ不是计算机的

kinlay

留个名

豪情

lz 是不是 LZF,呵呵，知我系谁吗

zhangrongji

lz能否留下QQ号码？有问题请教

kintry

跟我现在的感觉很像

homexxhh

更新了，自己顶起来！！

homexxhh

原帖由 豪情 于 2008-3-5 23:48 发表
lz 是不是 LZF,呵呵，知我系谁吗

我系啊~~~我知道你系边果！HZH ~~~~你这个大牛要留多点啊！！！

wshong

哈~楼主的八皇后写的很有型~~