招聘的遭遇 ---- 欢迎新朋老友继续骂我

Question

今天晚上，收到了他的EMAIL（是昨晚发的），内容如下：（注，除了姓名和联系方式删除外，其它的都只字未改）/*
首先我讲述一下我自己对new,delete与malloc,free的看法.
new与malloc最主要的区别：
在与在对象中new会触发对象的构造函数，而malloc则不会，它仅内存分配,new能重载，
以便写自己更合理，快速的内存分配，所以new优于对象。而malloc在通用类型，char,
int,等更能发挥实力，减少消耗。当然，用同一种方法是很好的风格，这是可以接受的
delete与free
同上，delete能触发析构函数，优于对象，free对通用类型能更少消耗，风格一致最好。

说明：
写得简单，因为我觉得程序员最重要的是理念。开阔的视眼，如果真正了解底层架构。代码随时随地都能写得安全，稳定，
快速，反之，未见得。以我现在的思路来理解，代码就是一种字母组合。只要知道自己要实现什么，要如何才能安全的实现。
那函数简直就是几个字母，不必在乎它。不知道我的思想是往更高层次的发展呢，还是退化。但我坚信我自己。

简单介绍我的编程风格
虽然我的编程风格，可能有些人看了不习惯，觉得变量太哆嗦，但我依然。这是我自己发明的一种速记变量的风格
变量由以下三部分组成：
（中间以下划线_隔开） 变量类型，变量模式，变量简要说明  函数参数变量： 如LPVOID hwd_f_Param
变量类型 变量模式 变量简要说明 合并 注 
hwd(HWND类型) f(f为flag变量) Param(函数参数) hwd_f_Param
(一看就明了HWND类型，函数的，参数的，变量)
私有变量： 如char *Psz_pr_ReadBuffer
变量类型 变量模式 变量简要说明 合并 注 
Psz(P指针,sz字符，字符指针) pr(函数体内private变量) ReadBuffer(读取数据缓存) *Psz_pr_ReadBuffer
(一看就明了char *类型，函数体内私有的，读取缓存的，变量) 合局变量： 如char *Psz_gb_ReadBuffer
变量类型 变量模式 变量简要说明 合并 注 
Psz(P指针,sz字符，字符指针) gb(程序全局变量) ReadBuffer(读取数据缓存) *Psz_gb_ReadBuffer
(一看就明了char *类型，程序内公有的，读取缓存的，变量)
类私有,保护变量： 如char *Psz_prP_ReadBuffer
变量类型 变量模式 变量简要说明 合并 注 
Psz(P指针,sz字符，字符指针) prP(类private变量) ReadBuffer(读取数据缓存) *Psz_prP_ReadBuffer
(一看就明了char *类型，类私有的，读取缓存的，变量) 类公有,发布变量： 如char *Psz_prG_ReadBuffer
变量类型 变量模式 变量简要说明 合并 注 
Psz(P指针,sz字符，字符指针) prG(类public变量) ReadBuffer(读取数据缓存) *Psz_prG_ReadBuffer
(一看就明了char *类型，类公有的，读取缓存的，变量)
*/


读写数据线程,没来得及封装成类
const THREAD_IO_PARAM =8888; //线程第二个标注参数,32位值8888
const MAX_BUUFER_SIZE =1024*1024*100;
CEvent Event_prC_ThrdStart;
CEvent Event_prC_ThrdEnd;
CEvent Event_prC_ThrdReadDataFinish; /*
一次分配本行业数据包最大的Size,可以防止多次内存分配，释放，所得内存碎片。
最后没有写delete[]Psz_pr_ReadBuffer,在这里代写，说明我申明的时候便考虑到在何处实行内存释放了

当然有更有灵活的内存管理方法，如可利用空间表的指针链接管理器，大块分配足够内存,分次分配.等，最后
写了个简单的空间表指针链接内存管理器，时间匆忙，如您能明白我意思就行,
*/ char *Psz_pr_ReadBuffer =new char[MAX_BUUFER_SIZE];
//启动线程
void BeginThreadIO()
{
AfxBeginThread(ThreadIOProc,THREAD_IO_PARAM,THREAD_PRIORITY_NORMAL);
} //线程体，处理任务
UINT ThreadIOProc(LPVOID hwd_f_Param)
{
bool bl_pr_ReadDataPack; //检测是否有新的数据包下载变量
//循环读取，中间休眠5分钟=300秒=300*60*1000毫秒
const dw_pr_SleepTimeNo =18000000; //无数据时休眠时间
const dw_pr_SleepTime =100; //有数据时休眠100毫秒以降CPU


bool bl_prC_Error =false;
DWORD dw_pr_TimeArry[2]={dw_pr_SleepTimeNo,dw_pr_SleepTime};
while(true)
{

try
{
bl_pr_ReadDataPack =ReadDataPack();
}
catch(AAAAAAAAAAAA)
{
bl_prC_Error =true;
//做些错误处理
}

Sleep(dw_pr_TimeArry[bl_pr_ReadDataPack]);
/*
用数组代替,以提高效率，这是要注意的，判断也会增加程序开销的，虽然
很小，但是我们要尽量避免，而用数组，无其它开销
if(bl_pr_ReadDataPack)
Sleep(18000000)
else
Sleep(100);
*/
//已完成数据读取，与主线程通信,以便主线程显示一些提示信息给客户
if(!bl_prC_Error) Event_prC_ThrdReadDataFinish.SetEvent();
}
}
可利用空间指针链接内存管理：
Class MemoryListBase
{
static MemoryListBase *Po_prC_MemLstBase;
MemoryListBase *Po_prC_MemLstNext;//指向可利用空间表的下一段内存
MemoryListBase *Po_prC_MemLstNew;
MemoryListBase *Po_prC_MemLstDelete;
public:
MemoryListBase(){}; //构造
~MemoryListBase(){}; //析构
inline void *operate new(size_t); //重载new，以便自定义更合理，快速的内存分配方式
inline void operate delete(void *); //重载delete
}; //重载new
inline void* MemoryListBase ::operate new(size_t int_f_MemSize)
{
//如果内存已分配，从MemoryListBase内存管理类中分配
if(Po_prC_MemLstBase)
{
//在上述已定义，不适宜在局部定义，以便每new一次，增加开销
Po_prC_MemLstNew =Po_prC_MemLstBase;
Po_prC_MemLstBase =Po_prC_MemLstBase->Po_prC_MemLstNext;
return Po_prC_MemLstVar;
}
malloc(int_f_MemSize); //其它情况就用malloc分配
} //重载delete
inline void MemoryListBase ::operate delete(void * Po_f_Var)
{
Po_prC_MemLstDelete =(MemoryListBase *)Po_f_Var;
Po_prC_MemLstDelete->Po_prC_MemLstNext =Po_prC_MemLstBase;
Po_prC_MemLstBase =Po_prC_MemLstDelete;
} //最后设置static Po_prC_MemLstBase指针为NULL
MemoryListBase *MemoryListBase::Po_prC_MemLstBase =NULL;

Answer 1

由于他是朋友介绍的，而且昨天聊得感觉还不错，于是我就依老卖老地给他写了一回复，内容如下：
    今天实在太忙，所以给你回复晚了，很抱歉。我现在就你在附件中的内容做一些回答吧。
一、关于变量的名命规则。
    其实关于名命规则已有很多老前辈考虑得比我们还要多还要成熟了，而且也被广为使用。我们自己自以为比较好的规则其实也未必比人家的好，更重要的是，我们的代码在别人看来是很糟的。你得注意一条：代码写出来后，以后维护的不仅仅是我们自己。常用的命名规则与你的其实差异太大。可能你没有在比较大的公司呆过，你对规范编程没有感性的认识。一般来说，全局变量前加g，成员变量前加m_，……这是最基本的规范，对于HWND的前缀，习惯应该是h，在没有上下文要求的前提下，一般写成hWnd。在这方面，还是少一些自己的特色为好。
二、我要你写的一个适合于异步处理的数据流缓冲区，也就是在一个缓冲区流中，一边用于输入一边用于输也，类似于一个管道。而你写的我看不明白其意义。而从基本上说，const MAX_BUUFER_SIZE =1024*1024*100;这样的定义是有语法错误的，应该是在 const 后面紧跟着类型，还有一个问题是 直接定义这么大的内存，这是很不明智的。如果我这个缓冲区只是用来传送几百字节的内容，你却定义了100M，不感觉有些夸张吗？为了避免内存碎片并不是这样的，现在比较成熟的方案有两个，一是只分配定额（如1024）的某倍数的内存,二是使用内存池。
三、从代码来看，你经常性地出现语法错误。这可以说明两个问题，一是写代码不够细心，二是对代码缺乏一种直觉。虽说语法错误可以在编译时间发现，但经常性的错误也很大程度上影响了思维的连惯性，也影响了编程效率。对于有三年以上经验的人来说，应该可以做到，在你视野范围内存在语法错误时能凭直觉找出来，再细查其错误的原因，就象在白墙上发现污垢一样，污垢的类型你可以在进一步检查时才清楚，但你不能凭直觉找出污垢，那就不大能算富有经验的人。

Answer 2

在我回复发出不久，就连续收到他三个回复，内容如下：
--------------------------------------------------------------
logical，您好！ 
 
  工作并不重要，我主要感兴的在于算法，及优化
 
第一，及命名规则，你说的我在N年前就知道了，为什么会有这样的命名规则，为什么不能有自己的命名规则，你对自己的知识完全
        没有认知程度，你看看吧，看看微软的命名规范吧，看看多少人用起来不爽，多少人说吧，微软的随意
        命名性招许多人说，你却没有自己的看法，却是人云云，这注定你永远都是一个应用程序员，可能我这个
        后生说话你受不了。希望你将来更多些创新，如果一天到晚去抄袭别人的代码，认为那就是高手，那你
        很难再有提高了。
 
第二，我用的是文本文件写的，没经过编译器，在打瞌睡的程序下，用二十多分钟写完的，不信，你写写看。
        1024*1024我只是懒得去算，再去用其它。并非不知。100M，是看你接收什么数据，我在上面写了，根据
        行业要求，要多大的数据，这只是个例子。我在上面都标注了，你这都看不明白。看代码也并未觉得你细心。
        还讲一点，不知道你说的只分配1024的倍数，你不觉得是个笑话吗？每一种对象都可以有一个特定的内存管理
        器，这是最优方法，虽然不灵巧，却是最快的，内存大小不是你说多少就是多少，是对象说多少就多少，要算。
        内存池我在后面说了，我知道，懒得去写，因为我最讨厌这种应用程序员的问法。
        
 
第三，我想问问你多少算法，如果我是考官，帮我把几个算法写出来，我只怕你连函数调用的开销用汇编指令都
        标示不出来，不知道计算机是如何工作的。只知道书上这么说的，就是这么写的，书上说那样高效，噢，我记
        住了，那就高效，遇上另一种情况就不知道如何高效了。想想八年的编程经验你是达到何种境界。
 
    还说一句，有的人软件工作8年经验就能出书，有自己独特的见解，中国太多代码抄袭程序员。看看属于哪类。        
    也不知道你有没有经常看一些理论深入的话，还是只看看哪种事情怎么实现，把它代码抄下来。你的内存
    文件映射，内存池，数据输入输出流，网上代码到处都是，这也能作为一个编程能力，我昨晚听到你那种说法，
    我就知道你对程序的无知，还要一个人来写一段代码，笑，昨晚就不想去你那工作了，回来随意应付了一下。
    还想告诉你一句话，比尔盖茨说，我宁愿招个学物理的，让他来学程序，也不愿意招个普通软件工程师，意
    为无创新的代码抄袭员，多看看书，对你有帮助。
--------------------------------------------------------------
logical，您好！再不信，你去网上看看，你这种说法，看招多少人骂。我不跟你辩，有时间，去网上发发帖子。把你的邮件和我回你的邮件都放上去，让人家去说。 　　　　　　　　致
礼！
  

Answer 3

我昨晚说的原话是“你明天把这个代码写好给我发EMAIL看看，不急，我明天也是晚上才可能有时间去看EMAIL了。”而他昨晚到一点多写完了给我，也不好好检查。这并不是在我的意料中的。我给了他相对还充足的时间，为什么写完了不检查一下呢？在我看来是一种不良习惯。如果是一个产品，人家给你一年的时间，你会不会花一个月写完了，没有测试就直接推出去呢？但愿大家可以讨论一下，骂骂我也无妨。如果我能从大家的回复中学习到点什么，我的目的就达到了。如果大家能从这里学习到点什么，这也算是达到一石二鸟的效果了。

Answer 4

本人钻牛角尖的毛病发了，想看看他的代码中是否有可以学习的地方，发现有代码段:
  Sleep(dw_pr_TimeArry[bl_pr_ReadDataPack]);
/*
 用数组代替,以提高效率，这是要注意的，判断也会增加程序开销的，虽然很小，但是我们要尽量避免，而用数组，无其它开销
  if(bl_pr_ReadDataPack)
     Sleep(18000000)
  else
     Sleep(100);
*/
注：bl_pr_ReadDataPack定义成bool类型我真的没有想到这样可以提高效率，于是我写了一段代码测试，如下
bool  B=false;
int Value[]={1800000,200};
DWORD dwTime0,dwTime1,dwTime2,dwTime3; for(int i,temp,j=0;j<20;j++)
{
dwTime0 = GetTickCount();

for(i=0;i<100000000;i++)
{
temp = Value[B];
}

dwTime1 = GetTickCount(); for(i=0;i<100000000;i++)
{
temp = B?1800000:200;
} dwTime2 = GetTickCount(); for(i=0;i<100000000;i++)
{
if(B)
   temp = 1800000;
else
temp = 200;
} dwTime3 = GetTickCount(); TRACE("%d  %d  %d\n", dwTime1-dwTime0, dwTime2-dwTime1, dwTime3-dwTime2);
}输出结果是：
703  954  953
703  953  937
719  953  938
719  953  937
719  937  954
718  938  953
719  937  953
703  954  953
703  953  953
703  953  953
704  953  937
719  953  938
718  953  938
719  937  953
719  938  953
703  953  953
703  953  953
704  953  953
703  953  953
703  953  954如果把上述代码中的bool  B=false;改成bool  B=true;，得到下面结果：
719  953  1297
718  938  1312
704  953  1312
703  953  1297
719  938  1312
703  953  1297
719  953  1297
719  937  1313
703  953  1297
719  937  1313
703  953  1297
718  954  1296
719  938  1312
703  953  1297
719  953  1297
719  937  1313
703  953  1297
719  937  1313
703  953  1297
719  953  1297由于其它的操作都是相同的，故而花时的差异可以视为三种方法的差异性。得出两个结论：
一、在条件为false时，if语句与?语句是相同的，但条件为true时，？语句比if语句要优一些。
二、使用数组的方式比使用?语句在100000000次运行中，可以节省250个千分秒，相对于if语句，可以快近一倍。更一个问题是，把bool做为下标，有些不大好懂。增强了可维护性。这相对于提高的这么一点点效率，我个人看法是不提倡。

Answer 5

我把代码搞到我的机子上的结果是这样的：
B 为false
453  469  406
469  453  406
453  469  391
468  453  391
453  453  375
469  469  390
485  453  375
453  453  391
469  453  390
453  454  390
453  453  422
485  453  390
454  453  390
485  453  390
469  485  406
453  469  406
469  453  390
454  453  390
469  453  391
453  437  407 B 为 true 
609  453  438
593  469  391
578  453  391
563  453  391
578  468  407
593  438  391
593  453  375
578  453  391
578  453  375
578  453  391
578  453  375
578  453  375
625  485  422
578  453  375
578  468  375
610  453  406
594  469  406
609  453  375
610  453  391
593  453  407 
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝我的结果和楼主的好像一样。
结果反而是反过来的。从楼主的结果种看到的是第一种运算比较好。但我这里却正好是if比较好。
不知道其中的原因是怎么样的？不过进行了这么多次的运算才能提高这么一点点效率。也真够好笑的。面试的这位朋友真是丢了西瓜捡到芝麻。在我看来还是代码的可维护性重要一些。代码不是写给一个人看的。软件发展到现在的阶段，已经不是一个人或者几个去完成一个大型的软件了。软件的大规模生产现在已经开始了。开来这位面试的朋友了解新事务也不是怎么的快。要是有5000个人同时在做一个项目,由他做老大，不知道这位面试的朋友会怎么样？让其他4999个人都去适应一个人的代码规范？真的是很可笑的事情。任何事情的创新并不是将老的事务全部驱除掉。而是要留其精华，去其糟粕。这样才能发展下去。

Answer 6

突然又想起了以前看到了一个文档《高质量C++/C编程指南》。我想很多人都看过。
其中的前言里这样写着：博士毕业前半年，我曾到微软中国研究院找工作，接受微软公司一位资深软件工程师的面试。他让我写函数strcpy的代码。
太容易了吧？
错！
这么一个小不点的函数，他从三个方面考查：
（1）编程风格；
（2）出错处理；
（3）算法复杂度分析（用于提高性能）。其中编程风格在第一位，也是有他的道理的。
也想听听大家的意见。
对我也是一个学习的机会。

Answer 7

偶是比较赞同那位面试者的观点，我们现在的程序员太多的沉溺于抄袭，沉溺于所谓的经验和技巧，没有自己的见解和认知，很少有人真正的去深入研究。中国有了太多的copy代码为生的程序员，只有很少一部分成长为软件工程师。
关于编程风格，我觉得不需要去强求所谓的规则去限制，只要对每个function做个简单的注释，再加上开发档案就足够了；如果你觉得看不懂不能接手做二次开发或维护，那只是个人能力不足而已，即便加上去代码也属于垃圾代码，不动也罢。
以上纯属个人观点

Answer 8

shootingstars说的对,自以为水平多高,结果稍微一看错误成堆,即便是水平高也不能以自己威中心,么具有良好的团队精神.我觉得工作2年后的程序员都比较谦虚和务实了,不再谈论多高多高的水平,而是以能做出多好的项目或者产品为目的了

Answer 9

机器烂，不敢跑那么多次。
我的运行结果是这样的：为FALSE时：931  1272  1252
941  1262  1272
1022  1351  1433
991  1272  1282
991  1292  1312
为：TRUE时：
951  1282  1743
961  1282  1752
922  1212  1712
931  1272  1803
1101  1322  1753
和楼主的结论一致。

Answer 10

bool 作为下标是绝对不允许的。对于c的bool规定，0 是 false， 非0 就是 true，所以作为下标存在逻辑错误。

Answer 11

鉴定：
    一、太以自我为中心，缺乏团队合作精神；
    二、代码风格太差；
    三、工作不认真、不仔细，错误百出；（用的是文本文件写的，没经过编译器，在打瞌睡的程序下，用二十多分钟写完的）
    四、沉迷于小技巧，没有大局观；结论：不予录用ps：我看这个人三年的程序白写了，应该好好看看《高质量C++/C编程指南》
楼主也不用和这样的人校真了，让他多碰几次头好了:)

Answer 12

成大事而不拘小节？？？我不同意！感觉中国的古语真是害人不浅！
呵呵，别忘了万丈高楼平地起，世界上没有实用的空中楼阁的。只有你做到小节才能成大事。
我喜欢有钻研精神的程序员，但是我不喜欢固执己见的，顽固不化的程序员；
我喜欢勤恳的程序员，但是我不喜欢只会打字的程序员；
我喜欢务实的程序员，但是我不喜欢不论环境而一直务实的程序员。
社会在发展，相关的软件、硬件技术也在发展，一点点的CPU时间没有什么大的影响。
考虑问题首先得有一个前提条件。

Answer 13

所谓代码风格 其实就是让别人看起来容易懂 看起来不会很反感 容易修改和维护看看微软的风格吧不管是windows源代码  还是 一个简单的 htc注释简明扼要   函数命名清晰   变量名规则   。  看起来清爽
再看看上面的   感觉自己再做智力题

Answer 14

--------------------------------------------------------------
logical，您好！ 
 
  工作并不重要，我主要感兴的在于算法，及优化
------------------------------------------------------------程序员都这样  都以为自己是老大 要不 还要项目经理干吗？

Answer 15

此人会是一个好的code，做不了一个好的programmer。
楼主莫气，弃之可也。
另外，楼主可以建议他从事自由软件开发，他可能走出自己的路出来的。：）

Answer 16

此人会是一个好的code，做不了一个好的programmer。
楼主莫气，弃之可也。另外，楼主可以建议他从事自由软件开发，他可能走出自己的路出来的。：）

Answer 17

看了上面的评论忍不住想说几句：
1。从技术角度看，这名程序员的代码是典型的C语言风格，非常注重细节，但是他在对细节的把握上还是有欠缺,有些东西似是而非。
    首先，象这种用数组的方式去优化IF语句的事情，其实不一定就能达到目的，因为程序在通过不同的编译器优化后会产生不同的结果,
而且即使编译器优化了，具体到计算机系统执行的时候，计算机系统内部（硬件层次）也还会有一个优化（大家可以看看计算机系统结构
），尤其是现在的微处理器各有各的优化方式，因此执行效率当然也有所差异.我想aben_king(阿笨)兄之所以得出一个相反的结论，恐怕
和这些因素有关。其实，象这种优化问题应该交给编译器和微处理器生产商，与程序员无关。没有一个人能保证自己的代码在任何编译器
和微处理器下运行都是最优的。
    其次，关于重载new,delete函数，说实话我从来没有用过这个技术，不过我把搂上贴出来的程序与Effectvie C++(中文版,以下简称   
EC)书中的范例程序比较了一下，发现了一些问题.第一个问题就是当你重载new,delete函数的时候“你的函数的行为应该与缺省的operator 
new 保持一致性”(EC,p33),很显然他没有做到(最起码他的程序没有触发对象的构造函数).第二个问题是如果分配失败的话"则应该遵循条
款7所描述的规则,并抛出一个型别为std::bad_alloc的exception."（EC,p34）具体关于重载new,delete函数要注意的事项Effectvie C++
中的内存管理这一节有非常详细的说明。如果随便重载new,delete函数又不遵循必要的规范，导致的后果可能非常严重，内存泄露，非法
指针过于轻率的对待内存分配问题只会使程序的可靠性、稳定性大大降低。
    最后，既然他那么注重细节就不应该犯一些基本的语法错误（重载new,delete的语法就是错的）。
    
2。从管理角度看，他个人意识太强，过于强调底层技术自命清高，不屑与其它程序员交流（从他的EMail中说话的语气推断出来的）不太
适合团队开发，很难和别人合作开发。对一个项目而言，他可能就是一颗定时炸弹在最关键的时候，他会以自己掌握的底层知识来和你对
着干，他只会做他自己认为正确的事情不会服从项目经理的指挥。因为，他根本就没有把任何人放在眼里。
补充一点，我就是一个代码抄袭程序员。我觉得"抄袭"无罪，我们编写代码除了完成功能以外不是在一直强调可重用性吗？既然有人写了
类似的代码，我为什么就不能重用一下呢，难道还要重新造轮子（我们用的API函数就是人家微软编写好的代码阿，那个Windows程序员不
是天天"抄袭"这些API做软件的？我没见过那个人写一段Windows程序连带自己去实现API的）再说了，你多抄一点就可以省很多时间，项
目就有希望按期完成，项目完成了就有Money啊。我可不想和钱过不去！：）

Answer 18

to StockViews (股视) :看了这么多，忍不住要说点什么。
其实你根本不必把这件事放在心上，因为现在这种自高自大却没有什么真才实学的程序员很多。关于变量命名，我赞同你的观点，必须遵守大部分人的规范，不应该另搞一套。求伯君的那样可以独自写WPS的程序开发不会再有了，以后的软件项目需要更多人的参与和合作，也就需要大家都能遵守一套规范，以便你的继任者和合作者能够更好的读懂源码。那位面试的朋友的别出心裁的发明让我很看的很痛苦，他并不能强迫别人都去习惯他的命名方法，这对源码的维护和升级都不是一个好事。其实我觉得程序员的能力不应该体现在创造命名方式上，一个好的程序员应该遵从约定，用通俗易懂的命名方式、稳定灵活可移植的程序结构和高效率的数据算法来体现能力。我还是习惯m_iWndWidth这类命名方式。那位面试的朋友对new的malloc都不太清楚，相信他对c语言的理解并不是很深，在绝大数场合都应该用new来取代malloc。说点废话，其实项目的合作中除了考虑技术因素，还要考虑人的合作精神，如果大家都像那位面试的那样自负，一个人一套观点，一个人命名规范，那这个项目肯定要砸锅。我还是觉得，现在的软件开发越来越需要有合作精神的人，需要可埋下头来焊芯片脚的人，那些没拿过电烙铁却想直接画电路板的人迟早要祸害项目开发。提到合作精神，这两天刚碰到一件事。项目组里一个私交不错的朋友为了自己模块的开发方便，居然把共用的数据管理的DLL的函数接口改掉了，然后我这里执行GET后几个模块一个联调，他自己的模块没出问题，别人的模块出问题了。后来才搞明白他派生了那个dll中的一个类，却担心父类中的功能函数会影响子类的功能，所以把父类的功能函数注释掉了。且不说他对C++语言理解的错误，更重要的是他忽视了和别人的合作，对于共用的链接库和COM根本不应该修改，只应该通过派生子类来实现新的功能，万不得已要改底层模块时必须和其他有关人打个招呼。那位朋友的技术也不错，可为什么连这点合作精神都没有呢？多人的项目开发中，缺乏合作精神会给项目开发带来很多麻烦的。不好意思说多了呵呵

Answer 19

呵呵，完成了今天应该做的事情,又上来了。
看了上面所有朋友的回复，很谢谢。可惜骂我的人太少了些。好象有朋友误会我的意思了，因为我放到这里来并不是为了生气或别的什么，也不是什么“没有大局观，纠缠于这么一个细枝末节；没有自信，被一个啥都不懂的小屁孩几句话就说的迷糊了”，这点小事也不足于让我生出气来的，呵呵……我只是为了让更多的人看看，并对自己的一些想法进行反思。当然，还有一层意思是，就是希望志同道合者（与我的想法大致相同的人）能与我一起做些什么。工作这么长时间了，去应聘了Ｎ回，也为公司招聘了Ｎ回。应聘对于我来说，应该没有什么困难，在十多次的面试经历中，只有一次通不过的记录（人家只给我四道题，我只能勉强解决一道，呵呵），别的面试都是双方欢喜，就算我后来没有去那公司上班，我与面试的考官倒也成了多年的朋友。但招聘在我看来还真的很难，曾有过的几次招聘中，到现在为止还没有感觉很成功的案例。顺便把这次招聘的条件列一下，有兴趣的朋友可与我联系。
一、使用VC有两年以上经验，MFC比较熟悉，对CMap、CArray等模板比较熟悉。
二、对开发服务器系统有一定的经验（至少熟悉文件映射和大文件的处理），或能熟练使用CDC绘图和能按正常的要求制作对话框。
三、对常用规范有一定的认识，并能严格按照制定的规范来开发。有足够的耐心，具备团队精神，能与他人共享成果和分担责任。
待遇嘛，在3000到6000之间，没有其它任何的福利，也没有保险。
感兴趣的朋友，可以给我发EMAIL：[email protected]

Answer 20

bool  B=false;
461  751  511
370  751  511
370  752  510
361  751  511
380  741  531
360  752  510
371  741  531
360  751  511
361  761  500
371  751  521
370  751  521
361  751  510
361  751  511
360  751  511
361  741  520
361  751  501
370  741  521
371  751  510
371  751  521
380  811  581
bool  B=true;
450  742  510
371  741  511
360  751  511
370  752  510
361  751  521
370  741  521
371  741  510
371  751  501
370  731  511
371  751  520
401  771  511
370  761  511
371  751  520
371  751  521
370  761  621
371  751  531
390  882  540
371  751  511
370  751  511
371  751  520

Answer 21

什么是抄代码?
按面试者的话来说,全世界的程序员都是在抄代码,大部分程序员用的都是微软,SUN等软件巨头公司的代码.你强的话你就自已写一套类库吧,不要去用人家的类库.别以为你在调用人家的类,继承人家的东西就不是抄代码,就连你用的那个malloc函数代码都是人家写的.如果你不抄的话,那你重写一个此函数出来吧,看看你的函数有没有人家写的好.
社会分工的细化讲究生产效率,最别人之长补自已之短有何之过?我们做一个项目没有必要什么东西都自已重头写吧.干脆我们真的从硬件做起,接到一个项目后首先进行如下操作:
   设计电路--买电子器件和芯片--组装计算机和测试--开发操作系统---写编译器--开发自已的类库或函数库--然后开始自已的项目!! 这样就可能爽透了!!!!!!!!!

Answer 22

呵呵，那么你让他自己写个Quake的引擎之类的东西试试。我觉得这个家伙完全把注意力放在了所谓的“底层效率”上。早就有人说过软件工程的重要性，其中一条就是代码的可重用和可维护上，这个家伙以为他比世界上的软件工程师都牛吗？不大可能吧。另外我想提一点，所谓“我想问问你多少算法，如果我是考官，帮我把几个算法写出来，我只怕你连函数调用的开销用汇编指令都.......”，呵呵，又是底层啊。我要说明的是，一个算法最重要的是在于其思想，而不是是实现，当然，实现的时候不能太胡来就是了。算法的空间复杂度和时间复杂度都有其各自的理论知识，而不在于使用汇编，C还是java，当你的算法从数理角度得到高效的证明的情况下才要注意其实现语言和实现方式，那位老兄不是说算法牛吗，给他几个算法改进试试，比如并行算法之类的。仅仅用实现方式提高的效率是很小的，必须从根本思想上提高才行。我觉得这个家伙既不适合做理论研究也不适合进入团队，牛的话自己写产品好了。最后，俺觉得这个家伙完全就是写代码写多了，底层东西看多了，同时又掌握一点理论知识，就把整个东西扭曲了过来，记住一点，奇不胜正。
当然，比代码实力估计要比人家差好多。

Answer 23

楼主搞一套编程规范出来不就得了？
两年前，我还和人争执过
fun {
}
和
fun
{
}
的区别。其实没啥区别，规范叫你怎么做你就怎么做。要不然想做你工作的人还等着呢。

Answer 24

楼主主要是没有具备整体的服务器端架构的整体概念。如果楼主做过比较复杂、高效的 MMORPG 的服务器端就知道了，呵呵

Answer 25

to IO2(G*道也):
 你说的对,我虽写过一段时候的服务器程序,还毕竟没有经过正规的培训。只是凭自己的一点点经验就写了起来，当然在应用过程中还是可以满足要求的，只是不知道是否算高效。
　我有些不大明白，我好象没有在这里没有涉及到服务器端架构什么的，您怎么知道我“主要是没有具备整体的服务器端架构的整体概念”？真神了，呵呵避开什么面试的事，讨论一下服务器的技术如何？
难道说，在服务器端采用文件映射不科学吗？我还提过一点，就是分配内存的时候以某常数的整倍数为单位分配，我想这应该是有好处的吧？我习惯上这样写：
DWORD nNewSize = (DWORD) (ceil(nRequestedSize/1024.0f)+1) * 1024;
PBYTE pNewBuffer = (PBYTE) VirtualAlloc(NULL,nNewSize,MEM_COMMIT,PAGE_READWRITE);
//注：nRequestedSize为实际要求的内存长度，nNewSize为真正分配的内存长度。如果你认为有什么不妥，还敬请帮我提出。面子事小，能让服务器稳定、高效地跑于几年是大事呀。

Answer 26

呵呵，多分配1024内存了，(ceil(nRequestedSize/1024.0f)+1)*1024　改成 ceil(nRequestedSize/1024.0f)*1024就行

Answer 27

看这帖从昨天看到今天,感触彼多1:  团队精神
2:  编码规范前两点在做项目开发时肯定得遵守,一个项目的按时按质完成才能得以保证3:  "抄袭代码" (重要的是这个引号) PS: 时代在前进,牛顿早就说过了,要站在巨人的肩膀上! 
最后问一个小问题,上面提到的
fun{
}
还是
fun
{
}
这个问题, 大家用得多的是哪个呢?小弟还混在大三 ,向前辈们不断学习ing

Answer 28

fun{
}
还是
fun
{
}前者你要考虑你的函数名过长的时候，还有眼睛要往右看然后往左看，如果是后者就方便多了。

Answer 29

我记得fun{
       }是SUN公司的标准
      fun
      {
       }则是MS的标准
请指正.
所以我写JAVA用前面的,写VC用后面的.

Answer 30

哈哈，招我吧，不要据于小节，能做出来符合要求就行了，不要像某位人兄说的Sleep没效率，要说算法，有，都线程+信号量，不过这增加了复杂度和调试开销，没有必要的地方Sleep还是不错的

Answer 31

哈哈，招我吧，不要据于小节，能做出来符合要求就行了，不要像某位人兄说的Sleep没效率，要说算法，有，多线程+信号量，不过这增加了复杂度和调试开销，没有必要的地方Sleep还是不错的

Answer 32

楼主要兼职么？我在深圳。
时间和上网条件可以保证的。如有意，看看我网站：www.happytango.com有我联系方式。
谢谢。

Answer 33

这里一般连sleep可能都不用，直接一个seamphone估计就可以了。

Answer 34

Sleep()没什么不对的，要看用在什么地方。
多线程也不一定效率就高。

Answer 35

能否麻烦各位高人写个分配50个整型数的内存空间的语句出来给小弟参考参考？int *p;p=                 ; // 这个空该怎么填？感谢。

Answer 36

呵呵，看到上面有几位兄弟似乎对sleep仍然情有独钟？
sleep意味着什么？意味着调用这个指令的线程主动放弃了自己对CPU的拥有权，并且不知道什么时候能够醒过来（记住：Windows不是实时操作系统，Sleep(50)不意味着线程50毫秒后回醒过来，如果系统繁忙，线程多的话，也许是很多个50毫秒以后才能够回来）也许sleep用在效率要求不高的地方无所谓，但是搂主指明了使用在对效率要求很严格的服务器程序上，我觉得sleep还是尽量少用的好。我经常看到很多帖子上问如何减少CPU的利用率，几乎最“简单有效”的方法就是Sleep。其实，很多时候都是设计的问题，不应该用轮询+Sleep的方式解决。

Answer 37

to sevencat(七猫) :
能用malloc写一个吗？不要new的。

Answer 38

int *p = malloc(sizeof(int) * 50);

Answer 39

同步+轮询+Sleep
->异步+队列+seamphore

Answer 40

to  xiao_xiao_zi(笑小子):不对啊

Answer 41

to  xiao_xiao_zi(笑小子):不对啊

Answer 42

int* p = (int*)malloc(sizeof(int)*50);

Answer 43

楼主对服务器端使用高效的hash算法有什么体会吗？你知道高效的文件、磁盘和大量相关联的元素都使用什么算法来高效实现的吗？你知道内存的碎片是怎样产生的吗？有什么处理的算法来实现高效的处理吗？你知道++a和a++等看是平常的操作在效率上有什么巨大的差别吗？如果你连基本的架构概念都没有，就不要谈什么服务器端的高效设计这样的话题了，呵呵

Answer 44

不是说什么情有独钟，而是Sleep()作为一个系统调用，必然有适合它的地方。
最近写了一个每秒处理几万条消息的服务器，界面更新就是起个单独的线程用Sleep()来做的。简单，有什么不好？谁让你把Sleep()用在繁忙的工作线程上了？

Answer 45

to IO2(G*道也):
   谢谢你的批评，我可能真的连“基本的架构概念都没有”，但只是批评我知识的穷乏并不能帮到任何人呀。如果有有这方面的见地，还是希望你能把基本的架构概念写一写，这样我可以学习学习，能看到这贴子的人也能得到提高。
   我个人的想法是,自己写出来的文字是别人需要花时间来看的,所以要么不写要么就写对别人有意义的.我发这个贴子,我相信还是有人从这里学到一点东西的.但从你回的N个贴子看不出你的水平，更重要的是，没有人可以从你的回贴中学到任何东西。
   关于你所提到的什么hash算法呀什么高效的文件、磁盘和大量相关联的元素什么什么的，我本无才，我只知道使用VC中的CMap呀，或WIN下支持的什么文件映射之类的。
   关于内存的碎片产生的原因，我想一般学习过写程序的人都知道吧。至于怎么去避免，这是各人有各人的招，我个人喜欢使用系统页的整倍数去分配和使用内存池等，别的就没有想过了。不过上面有人说系统页的整倍数去分配这并不能起来什么作用，不过凭我的经验还是有一定意义的，当然或许我的经验是错误的。我还是想请你对此有所述，当小弟们学习学习。   对于你上面提到的“写个分配50个整型数的内存空间的语句”，我不大能明白在一个常用的内存分配中能玩出什么花样来，还望赐教。    我的口号是：只求合适的，不求最好的。我上面所说的高效，只是基于我们的具体应用中，让用户感觉到足够快就成，如果能在0.1秒之内能得到响应，我也不会花太多的精力去追求0.001秒或更短的时间得到响应。    我一直是搞应用的软件的，在我看来软件是以用为本。只要能满足用户的需要，能解决用户的具体问题，而后期的维护又不至于太麻烦就可以了。如果要我造跑车，在满足一般跑车的一般要求之外，我或许可以考虑怎么去处理让更安全一些，但我决不会花时间去解决一辆跑车怎么能同时容纳20人这个问题。