前几天被老版本pdb格式折磨的死去活来，由于源文件多，大于64M报错，把pdb嵌入dll里也报错。无奈只能用line number only来调试，郁闷的不行。

文章专业啊，那么多方法，惭愧。偶个人推荐Bilateral，效果不错。O(1)的中值滤波和FFT也值得考虑一下。

强啊，纯支持留爪。

pix，有调试信息输出，顺便做个笔记，呵呵。

有时，说话太多也是杯具-_-

商用RSA程序一般有以下三个特点：
1. 汇编级优化
2. 对于Montgomery优化算法上的极度理解，把大量的耗时操作都放在预计算参数里解决。
3. 无内存分配函数的调用开销，也就是全程不调用malloc()，或者自己重载内存分配模块。
4. 对现代cpu利用有加，基本很少用byte级别操作，一般都是uint32。

这些都是自己造轮子挺难超越的障碍，哎。。在我机器上这些程序用了crt算法，2048bit加解密也不会超过0.01秒。

我从书本上弄了个非常简单的大数算法，无CRT，直接算RSA 2048bit，速度能有0.1s.

如果用到了标准开源库，比如gmp之类，加上RSA的优化幂模算法，我测试了一下，都在0.0001s就搞定了，实在是有很大差距。

要说最优，首推google的优化算法：http://omaha.googlecode.com/svn/trunk/common/security/rsa.cc，，计算速度绝对瞠目结舌，就是那个预计算RR值有点BT了。

sleep/usleep主要用途是均分cpu占用资源，变相降低当前进程优先级。并不是为了计时而设定的。

@waiting4you

杯具，测试数据写错了，是十进制的结果，被我写成了16进制，已经修正。感谢。

@atyuwen

啥，已经有人实现过了？有点杯具，去找来bloom filter研究研究。

@oldman
你说的很对哦，呵呵。static_cast仅仅只能有个编译警告，解决不了任何问题。

@jmchxy

你说对了一半，address1确实等于value的值（也就是D的内存值）。但在单一继承的情况，这种转换的写法是绝对允许的，而且结果是完全正确。

唯独多重继承情况下会出错，我就把这种情况归结为多重继承的问题了。

单一继承下，A,B,C,D共用一个D的内存地址是没问题的。
多重继承下，A,B,C,D共用一个D的内存地址是不可以的。

这就是两者最大的区别，也是文章核心所指 --- 父类是否能和子类共享同一内存地址。

@空明流转

class C : public A, public B
类C同时继承了A和B，这就是多重继承。 这篇文章的本意是虽然B是D的子类，但是不能直接用(B*)做类型转换，需要写成(B*(D*))这种形式，因为B和D的关系不是单根继承。

ps:虚函数的那种继承叫虚拟继承。

@Jakcie

这样的话，最终生成exe里，数组的实体会被克隆N份，你可以用ultraedit来查看。比如table1是100k, 有10个cpp引用了，exe的最终大小 = 程序 + 数组1000k.

移动互联网有个致命的弱点，入门的门槛低，那种java低技术水平的东西，很难有强大的市场竞争力。

想要活得好，至少在技术方面比对手高出一截。然后才是市场，运营，管理的问题。

最后一段说的很真切，人家美国已经能把3D运算放到服务器，通过极快的网速，在没有游戏显卡的机器上实现3D加速。

未来这个技术能在网游实现的话，一切的环境破坏都是有可能的。

“他应该觉得自己没有预见未来大势的能力啊，或者说预测的不准，所以只好估测一下，然后凭运气喽”

运气还是很重要的。投资和招聘一样，比如网游开发，是高科技产业，有好项目你得找到合适的人选才行，不是说有钱就能怎么怎么的。成功的关键依靠人，而人这个最不稳定的因素，是靠投资者的运气。

给normal做矩阵计算时，只提取旋转变换因子，不用到平移，切边，缩放这些因子不就可以了。

"在国外,35岁以上的程序员才是高手,看来又是一个忽悠招聘",
国外35岁以上都是算法高手，不是什么实际项目开发。

知道scene demo大赛吗？参与的全部都是顶尖程序员。还不是看到不少因为体力不支，而提前退休的。人的体力毕竟有限，30岁后会分很多精力在现实生活中，这点就别怀疑了。

针对游戏的每帧更新UI，这种消息结构是没有什么太大价值，一堆回调继承函数会迅速膨胀代码量。

微软用消息做UI最大的好处，是效率。可是当显卡，CPU如此快速，为什么不寻找另外一种UI解决方式？

"这点有点明白了，一开始多了，而以后必须向下兼容，于是肩上的包袱就永远卸不下来了，是吗？" 支持+赞同KISS原则。

真正0依赖意义并不大，自己写的程序难免有BUG，要完善势必花很多精力，时间，你真的觉得自己花上几年完善一个LIB是值得的？如果不是研究院，还是按照具体工程来扩展自己的类比较实在些。

程序写多写大，最大的感受是以前程序一切速度优先，有些看起来杂乱的语法，现在都会用简单慢速明了的语句去表达。。速度越来越不是重点了，结构清晰才是程序长久生命之源。

那么复杂。。对于数组，智能指针容易内存泄漏。实用性最重要，程序是要不断维护的，一切从简。。

我用最简版本，也过得滋润潇洒，KISS 原则。。


// Quake4 SourceCode, this class is NOT safe for array new's. It will not
// properly call the destructor for each element and you will silently leak memory.
// it does work for classes requiring no destructor however(base types)
template<typename T> class auto_ptr
{
public:
explicit auto_ptr(T* ptr = 0) : m_ptr(ptr)
{
}

~auto_ptr()
{
delete m_ptr;
}

T& operator*() const { return *m_ptr; }
T* operator->() const { return &**this; }

private:
// disallow copies
auto_ptr<T>& operator=(auto_ptr<T>& ptr);
auto_ptr(auto_ptr<T>& ptr);

T* m_ptr;
};

看要怎么奋斗，没有积累，不动脑子做一辈子程序，那叫愚蠢。

奋斗要把有限的精力投入到专一的领域，才会有所成就。

at 要离婚的程序员:

应该不是每个程序员都那么惨吧? 真的话就太悲哀了, 你用的是什么语言?

"我只要做Java（C＋＋）；"

最后一句有什么问题? 人的精力是有限的,东看看西摸摸,到最后什么都不精通.还不如只看一门语言.

你知道某职业C++程序员,让他临时转LUA开发后的感想是什么吗?"就如断一条胳膊在干活!"

吐血啊，自己来实现NtOpenProcess? 有这水品，干脆转行开发操作系统算了！

夜半三更来顶贴。

@dongming

我导出excel2003是纯粹的文本xml格式，自己一行一行边分析边导出的，就是麻烦点，没有什么技术难度。

你知道输出xml的程序部分是很乱的，似乎也没有很大的参考价值。需要的话可以加我QQ。

GetQueueCompeltionStatus 恐怖的一沓糊涂，运行一段时间就蹦出些莫名的错误，我这辈子是不会再用了。。。socket万岁。

BOOL bSuccess = GetQueuedCompletionStatus(m_hCompletionPort, &dwNumberBytes,
&CompletionKey, (LPOVERLAPPED*)&overlap, 10);//10ms for cpu eat.

time_check();

if (overlap) personal = overlap->content;

if (bSuccess == FALSE)
{
DWORD LastError = GetLastError();
if (LastError == WAIT_TIMEOUT)
continue;

// 2 - 系统找不到指定的文件。
// 121 - 信号灯超时时间已到。

// 1450 - 系统资源不足，无法完成请求的服务。
// 995 - 由于线程退出或应用程序请求，已放弃 I/O 操作。

// 64 - 指定的网络名不再可用。
// 10053 - 您的主机中的软件放弃了一个已建立的连接。
// 10054 - 远程主机强迫关闭了一个现有的连接
// 10058 - 由于以前的关闭调用，套接字在那个方向已经关闭，发送或接收数据的请求没有被接受。

// 0 - 操作成功完成。
// 997 - 重叠 I/O 操作在进行中。
// 998 - 内存分配访问无效。 (when fread() filesize > 3G)

为了安全因素，SOCK_RAW在现在的操作系统上不支持了吧，只能用IMCP开头的API。

个人网络项目里，ping值一直是用socket连接后，发个小包计算返回时间，实际测试效果也不错。

引用一直从来只定义const的飘过。

"个人觉得只要能设计出合理的hash还是hash更快些吧", 严重同意！不过对于楼主来说，写一个hash查找来替换std::map挺费时间的，内存管理上弄不好的话，效率和稳定性会下降，说不定还没人家stl的快，所以不是很推荐呢。

我喜欢用BKDR Hash Function，简单方便，散布率对本人而言，已经相当满意了。

晕死，打错字了，是RB-TREE.

楼主应该不是hash表，是rt树，不过两者速度也差不多了，没什么可优化的地方。hash只有在数据相当大的情况下（>1000万条），才会有明显优势。

如果你用的是标准的new，stl的string会频繁调用也耗费不少时间。可以改用id software的那个idHeap，官网quake4 sdk里就有，速度号称是vc版本的N倍。

当然，前提必须是单线程。

map查找已经足够快了。你看看是不是单词多，排序浪费了太多的时间。可以修改成radix sort, 加快速度。不过可能会有点难度，你要把string转换成int，还用到多重排序。

个人测试大规模数据，速度还能接受。贴点逼人的简陋代码，仅供参考，核心算法见：http://www.codercorner.com/RadixSortRevisited.htm

class vector_string : public vector<string>
{
public:
vector_string()
{
}
~vector_string()
{
}

public:
void sort(vector<int>* r_offsetset = 0)
{
vector<string> swaplist;
swaplist.resize(_Num);

vector<uint> sorttable1;
vector<uint> sorttable2;
vector<uint> sorttable3;

sorttable1.resize(_Num);
sorttable2.resize(_Num);
sorttable3.resize(_Num);

int i;
for (i=0;i<_Num;i++)
{
const string& str = _First[i];
uint b;
int n;

b = 0;
for (n=0;n<4 && n<str.size();n++)
{
if (n == 0) b |= (str[n] << 24) & 0xff000000;
if (n == 1) b |= (str[n] << 16) & 0x00ff0000;
if (n == 2) b |= (str[n] << 8) & 0x0000ff00;
if (n == 3) b |= (str[n]) & 0x000000ff;
}
sorttable1[i] = b;

b = 0;
for (n=4;n<8 && n<str.size();n++)
{
if (n == 4) b |= (str[n] << 24) & 0xff000000;
if (n == 5) b |= (str[n] << 16) & 0x00ff0000;
if (n == 6) b |= (str[n] << 8) & 0x0000ff00;
if (n == 7) b |= (str[n]) & 0x000000ff;
}
sorttable2[i] = b;

b = 0;
for (n=8;n<12 && n<str.size();n++)
{
if (n == 8) b |= (str[n] << 24) & 0xff000000;
if (n == 9) b |= (str[n] << 16) & 0x00ff0000;
if (n == 10) b |= (str[n] << 8) & 0x0000ff00;
if (n == 11) b |= (str[n]) & 0x000000ff;
}
sorttable3[i] = b;
}

radixsort_t radix;
uint* sorted = radix.Sort((uint*)&sorttable3[0], sorttable3.size(), false).Sort((uint*)&sorttable2[0], sorttable2.size(), false).Sort((uint*)&sorttable1[0], sorttable1.size(), false).GetIndices();

resort(sorted, 0, _Num, swaplist);
if (r_offsetset) r_offsetset->resort(sorted, 0, _Num);

// ------- 2 ------
vector<uint> swaptable;
swaptable.resize(_Num);

for (i=0;i<_Num;i++) swaptable[i] = sorttable1[i];
for (i=0;i<_Num;i++) sorttable1[i] = swaptable[sorted[i]];

for (i=0;i<_Num;i++) swaptable[i] = sorttable2[i];
for (i=0;i<_Num;i++) sorttable2[i] = swaptable[sorted[i]];

for (i=0;i<_Num;i++) swaptable[i] = sorttable3[i];
for (i=0;i<_Num;i++) sorttable3[i] = swaptable[sorted[i]];

// 测试 程序 文字 1
// 测试 程序 文字
// 测试 程序 文比
uint tab1 = 0xFFFFFFFF;
uint tab2 = 0xFFFFFFFF;
uint tab3 = 0xFFFFFFFF;

int samecount = 0;
for (i=0;i<_Num;i++)
{
if (tab1 == sorttable1[i] && tab2 == sorttable2[i] && tab3 == sorttable3[i])
{
samecount++;
continue;
}

if (samecount)
{
int start = i - samecount-1;
int total = samecount + 1;

bool exactsame = true;
for (int n=start+1;n<start+total;n++)
{
if (_First[n-1] != _First[n])
{
exactsame = false;
break;
}
}

if (exactsame == false)
{
quicksort_t::sort((int*)sorted, _First+start, total, _cmp);
resort(sorted, start, total, swaplist);
if (r_offsetset) r_offsetset->resort(sorted, start, total);
}
}

tab1 = sorttable1[i];
tab2 = sorttable2[i];
tab3 = sorttable3[i];
samecount = 0;
}

if (samecount)
{
int start = i - samecount-1;
int total = samecount + 1;

quicksort_t::sort((int*)sorted, _First+start, total, _cmp);
resort(sorted, start, total, swaplist);
if (r_offsetset) r_offsetset->resort(sorted, start, total);
}
}

protected:
void resort(const uint* r_sorted, int r_offset, int r_num, vector<string>& r_swaplist)
{
int i;
for (i=0;i<r_num;i++) r_swaplist[i].swap(_First[r_sorted[i]+r_offset]);
for (i=0;i<r_num;i++) _First[i+r_offset].swap(r_swaplist[i]);
}
};

不错哦，我已经加到自己的程序里的，谢谢楼主，呵呵。

多用assert也不太合适，特别是服务器程序，万一外挂来一个非法修改，你服务器端crc错误就弹一个assert，那就完了。

楼上说的不错啊。拔网线在用轮训select时很容易就能检测出来。

还有关于丢包，send不是任何时候都可以全部发送成功的，如果window buffer填满了，send会只发送一部分，还有在send前，最好先select一下是否可以write的标志，这样更安全些。

我昨晚还在看这个呢。WH_MOUSE_LL也不需要DLL，而WH_MOUSE就需要了，user32.dll里会做进程DLL注入操作。两者实现原理不一样。

干程序员时间越长，以前的车轮就越有收益。个人体会是，不要太过局限于钻技术牛角尖就OK，大凡高深的技术，实际用途少。

回楼上，这个程序核心实现技术难度不大，就是文本文件分析。如今信息不比往日，老外高手的开源项目多如牛毛，可供学习参考的太多。鄙人代码为了平台的移植，都没用标准库，也没用什么技巧。就不贴代码出来献丑了。

非常谢谢楼上，刚发出来软件就CRASH，郁闷死了。可否加我的QQ？631955284。再次感谢。

自己写一个isspace啊，十几行的事情，我一直不太相信vc crt string部分。

PC上有个类似的函数HeapCompact，初看很像内存整理，仔细看也不是的。内存整理牵涉的操作太多，操作系统也不好办。