博客园-沐枫小筑

.net winform 的 OnKeyDown 与方向键

沐枫 — Mon, 18 Aug 2008 08:13:00 GMT

　　随手写了一个小程序，突然遇到一个问题：

　　在自定义的控件中，override了一个OnKeyDown，用于处理方向键。结果，无效，跟踪调试发现，方向键无法进入函数断点，但其它如数字字母等键可以。

　　上网查了一下，发现不少人遇到同样的问题。不过不是在自定义控件中，是在窗体中。当然，解决的方法很简单，设置KeyPreview为true就可以了。

　　自宝义控件可没有KeyPreview属性。

　　为什么方向键会这么特殊？很简单，原来，方向键、制表键(Tab)等用于窗体中的各个子控件的焦点切换，因此在OnKeyDown之前就被截获并处理掉了。

　　知道原因了，解决起来就好办了：

　　在自定义控件中如需要处理方向键，应该override OnPreviewKeyDown/OnPreviewKeyUp等弊病数就可以了。

[新闻]十年祭:昔日明星软件今何在?
博客园首页社区新闻频道小组博问网摘闪存

MySQL 5.1 无法创建、修改存储过程的解决（简单问题）

沐枫 — Tue, 22 Apr 2008 06:05:00 GMT

刚开始用MySQL 5.1，就遇到无法创建、修改存储过程。
尝试无果，上网搜索，居然简单就解决了：

网友dracoo提供答案：
问题就出在你用了新版的MySQL
在建立存储过程前加上这个命令吧。
SET sql_mode = '';

为了省事，我直接把MySQL的服务器参数sql_mode去掉了。然后一切正常。

[新闻]六大可能出售IT企业名单：SUN领头或被猎走
博客园首页社区新闻频道小组博问网摘闪存

一个稍微好用些的 svn 服务器

沐枫 — Sat, 15 Dec 2007 10:31:00 GMT

今天安装svn服务器。上官网下载，发现windows下有一个稍微好用些的svn服务器。
下载地址： http://www.visualsvn.com/server/

这个东西有几个特色：
1. 安装和配置过程很方便（最大优点之一）
2. 自带apache/ssl/mod_dav_svn/...等模块，既小巧，又简单，也安全一些。
3. 自带MSC管理工具，可以创建用户、用户组，还可以管理多个源码库，以及配置各个路径的访问权限（最大优点之二）

通过上面下载地址，可以看到截图。不过，截图的版本稍低点。目前的版本是1.01。核心是Svn1.45，与官方同步。其实它也是为官方提供windows移植版的网站之一。

需要注意的是，这个网站提供的VisualSVN Server是免费的，而客户端VisualSVN是收费的。我们可以不用该客户端，客户端还是用TortoiseSVN/AkuhSVN之类的。VisualSVN客户端从介绍上看，与AnkhSVN是差不多的，只不过功能上略有优点。定价是$49。

[新闻]Linux内核2.6.27正式到来
博客园首页社区新闻频道小组博问网摘闪存

VC中的一个很奇怪的问题－－关于C4244

沐枫 — Fri, 30 Nov 2007 04:48:00 GMT

从VC2003到VC2005，一直有一个很奇怪的问题。
如下的代码：

    short s1 = 0;
    short s2 = 2;

    s1 += s2;

在这两个编译器的 /w4 四级警告打开的时候，就冒出以下的警告来：

warning C4244: “+=”: 从“int”转换到“short”，可能丢失数据

为了消除这个警，只能将 += 拆成 = 和 +，如 s1 = s1 + s2。

终于，这个问题在VC2008消失了。

[新闻]《星际争霸2》一分为三各种族依次登场
博客园首页社区新闻频道小组博问网摘闪存

汉语编程++

沐枫 — Wed, 17 Oct 2007 12:20:00 GMT

没想到汉语编程又有人开始网上对骂了。一方指另一方骗人，一方吹自已伟大。
今天群里头有人又把它翻出来了，刚好无聊，也就发明了一个汉语编程语言，集成到visual studio 2005的IDE中，名字就叫汉语编程++，欢迎同样无聊的朋友试用。

#include "常用头文件"

整数主函数(整数参数数量, 字符指针参数是数组)
{
    整数变量1 赋值为 3;
    如果(变量1 大于 0)
    {
        打印("可以中文编程\n");
    }

    系统命令("Pause");
    返回 0;
}

运行结果就是：“可以中文编程”
语法呢，就是C++一样的，那个“常用头文件”的内容如下：

#define 整数 int
#define 如果 if
#define 大于 >
#define 打印 printf
#define 系统命令 system
#define 赋值为 =
#define 主函数 _tmain
#define 字符指针 _TCHAR*
#define 是数组 []
#define 返回

#include <tchar.h>
#include <iostream>

唯一美中不足的是，#include暂时无法汉化。于是劝群里的人用这个写写情书，结果，没人响应...
不过，#include 可以在项目属性中去掉它（C++高级选项：强制包含），或是指定编译命令参数 /FI "常用头文件" ，这样就可以去掉上面的“#include "常用头文件"”了。
-----
以上程序在VC++2005上编译并运行通过。

附群朋友的程序：

高興不<> 19:54:59
还真有这么玩的啊
沐枫(Liny)() 19:55:02
各位朋友，咱们提供一个头文件，于是全中国人都可以用vc++2005来进行中文编程了。
风在奔跑() 19:55:05
我从来没这么玩过.
沐枫(Liny)() 19:55:19
玩玩吧，挺好玩的。
风在奔跑() 19:55:28
干脆把所有函数用中文define成一个中文编程库.
沐枫(Liny)() 19:55:30
不就是一堆#defing
沐枫(Liny)() 20:13:43
用这个写情书吧各位。
西瓜() 20:13:57
女朋友不懂程序怎么办
ＴＬＡＨ() 20:13:58
这样的情书...球球不会喜欢的
高興不<> 20:14:04
。。。情书里就一个弹出的对话框"欲知详情，请看代码"
西瓜() 20:14:17
球球又没出现
ＴＬＡＨ()  20:19:00

#define 趁还 while
#define 那个啥 int
#define 总的来说 main
#define 买 cin
#define 卖 cout
#define 进 >>
#define 出 <<
#define 拜拜了 return
#define 去掉 -=
#define 等于 =
#define 屁 100e4
#define 我说 (
#define 是吧 )
#define 啊 a
#define 那么就 {
#define 得了 }
#define 呀 ;
#include <iostream>
using namespace std;

那个啥总的来说我说那个啥啊是吧
那么就那个啥有钱等于屁呀
趁还我说有钱是吧    那么就
那个啥多少呀买进多少呀卖出多少呀有钱去掉多少呀
卖出多少呀得了
拜拜了啊呀得了

高興不<>  20:19:30
最有语义的中文编程诞生了

[新闻]IBM花300万美元打造互联网三维虚拟紫禁城
博客园首页社区新闻频道小组博问网摘闪存

关于Array.IndexOf

沐枫 — Tue, 16 Oct 2007 08:22:00 GMT

今天出了一个小问题，倒是令我有些惊讶。

byte[] data = {1,2,3,0,5,6,7,0};
int n = Array.IndexOf(data, 0, 0);

结果，n为-1。
而如果改为：

int n = Array.IndexOf(data, (byte)0, 0);

    就能输出正确的结果: n=3
    看来，IndexOf对于类型也要求正确匹配。

-----------
    以上是在VC#2005中测试的。

[新闻]11个处于悬崖边缘的 Web 公司
博客园首页社区新闻频道小组博问网摘闪存

从赋值到初始化

沐枫 — Thu, 27 Sep 2007 09:50:00 GMT

C语言确实很优雅，整个语言的设计简洁一致。而在C++中，有一个让人诟病的问题就是变量初始化的不一致性。
C语言中的初始化，都是用花括号进行，简单美观：

int array[] = {1,2,3,4,5};
struct Point point = {2, 3};
struct Point arrPoint[] =
{
  {2,3},
  {4,5},
  {6,7}
};

C++自然也兼容了C语言的初始化机制。然而，C++的Class乃至STL都不支持。它们要用不同的方式来初始化，甚至根本不能够直接初始化，只能使用运行时的赋值。
比如Class：

class Param
{
public:
  int Age;
  int Value;
private:
  int Level;
};

Param param = {2,3}; // ERROR
Param param = {2,3,4}; //ERROR

无法初始化。而如果不初始化的话，所有的成员而处于无政府状态，这显然很不让人放心。于是，C++提供了专门用于Class的初始化方式－－构造函数：

class Param
{
public:
  Param(int x, int y)
    : x_(x), y_(y)
  {}
  Param()
    : x_(0), y_(0)
  {}
private:
  int x_, y_;
};

Param param(1,2);
//或
Param param;

有了构造函数，可以在构造函数的初始化列表中对成员进行初始化。可是很明显，这里头还是有一个陷阱，默认构造初始化和非默认构造初始化的调用方式是不一致的。默认构造函数不能用括号来调用，否则编译器将会发疯：

Param param();

它会把上面的语句看成是函数声明，而后面调用的时候就会出错，而错误信息可能会让你抓狂一下。但是这样也就算了，偏偏 new 可以接受有括号和没括号两种写法：

Param* p1 = new Param;
Param* p2 = new Param();

再来说说初始化列表。初始化列表，事实上，也只能支持简单的标量类型，诸如int,bool,指针之类的；复杂点的，如数组、结构，不好意思，不支持－－只能在构造函数体中进行赋值。还有一个很迷糊初学者的问题是，成员初始化的顺序仅依赖于成员定义的顺序，而不是初始化列表中的顺序。

再比如STL容器，这下好象更惨，连构造函数都帮不上忙了，除了初始化一个空的容器，或是复制一下别的容器，我们只能做用默认构造函数进行初始化。我们拿数组和vecotr做个比较：

// 数组
int arr[]={1,2,3,4};
// vector
vector<int> iarr;
// 必须在某个函数中赋初值
void init()
{
for(int i = 1; i <= 4; ++i)
iarr.push_back(i);
}

   再复杂一点的数据结构，那单单赋值程序就要写上老长，而且还不好看。还要记得调用。这对于仅仅是简单的设置一些初值的用途来说，太过于烦琐。

   横向比较，这次好象C++还不会太落伍，只有C和动态语言提供了初始化特性，其它支持OO高级语言好象都是学C++的。如Java, C#(注C#3.0开始提供初始化功能)...

   C++能不能做到简洁一致的实始化呢？
   Boost的assign库做了许多有益的工作。使用assign库，至少现在可以初始化了：

vector<int> arr = list_of(1)(2)(3)(4);

typedef boost::tuple<int,std::string,int> tuple;
vector<tuple> v = tuple_list_of( 1, "foo", 2 )( 3, "bar", 4 );

map<int,int> next = map_list_of(1,2)(2,3)(3,4)(4,5)(5,6);

stack<string> names = list_of( "Mr. Foo" )( "Mr. Bar")( "Mrs. FooBar" ).to_adapter();

如果是赋值，也可以简略很多：

vector<int> v;
v += 1,2,3,repeat(10,4),5,6,7,8,9;
// v = [1,2,3,4,4,4,4,4,4,4,4,4,4,5,6,7,8,9]

不过，也仅能如此了。assign经过许多努力，也仅能支持容器的初始化，而且还不够漂亮。

C++0x已确定提供与C一致的初始化功能。 Initialer lists Initializer Lists for Standard Containers Initializer lists WP wording 等草案就是为了这个目的服务的。
如果使用C++0x，那么程序的初始化将变得清晰和一致：

complex<double> z = {1,2};
//或
complex<double> z {1,2};
// 初始化中，有等号和无等号都是允许的，下同。
z += {2,3};

int a = {1};

new vector<string>{"once", "upon", "a", "time"};

f( {"Nicholas", "Annemarie"} ); // 参数是两个元素的列表

return { "Norah" }; // 返回只有一个元素的列表

int* e {};  // 初始化为0或NULL指针

map<string,int> anim =
{
  {"bear",4},
  {"cassovary",2},
  {"tiger",7}
};

这好象是C++欠了十多年的债吧。

[新闻]扎克博格：Facebook要先赚吆喝后赚钱
博客园首页社区新闻频道小组博问网摘闪存

从for到foreach

沐枫 — Wed, 26 Sep 2007 11:48:00 GMT

一直在使用C/C++，对于循环语句while、do while、for，对于for情有独钟，因为其简洁、清晰、灵活。访问数组类型的变量，只有for写出来的语句是最易于阅读的，如：

int arr[N] = {/**/};
for(int i = 0; i < N; ++i)
printf("arr[%d] = %d\n", i, arr[i]);

然而，这种情况，到了STL时，就有些变味了：

for(vector<MyClass>::const_iterator iter = m_vecData.begin(); iter != m_vecData.end(); ++iter)
{
if(!iter->IsBusy())
iter->DoSomeThing(param);
}

这么长的一个for，不再给人一种清晰的感觉了。或许因为这个程序比较短，还没有太大的感觉，当回头去看自已的程序中，有不少这样的写法时，我就觉得一阵心烦。改改？

for(size_t i = 0; i < m_vecData.size(); ++i)
{
if(!m_vecData[i].IsBusy())
m_vecData[i].DoSomeThing(param);
}

不错，还是简单点好啊。但是因为这里举的是vector的例子。如果是list或是别的什么容器，就行不通了。
其它的高级语言，都提供了foreach或是for in语句，写出来就很清晰：

foreach(item in m_vecData)
{
if(!item.IsBusy())
item.DoSomeThing(param);
}

C++是不是也可以这么简单？好象STL中也有一个for_each，试着改写一下：

struct IfNotBusyThenDoSomeThing
{
    IfNotBusyThenDoSomeThing(const Param& param)
        : param_(param)
    {}
    void operator() (const MyClass& item)
    {
        if(!item.IsBusy())
            item.DoSomeThing(param_);
    }
private:
    const Param& param_;
};

for_each(m_vecData.begin(), m_vecData.end(), IfNotBusyThenDoSomeThing(param));

不错，for语句简单了，但是却多了IfNotBusyThenDoSomeThing的定义，这代码可是多了好几倍。要是每个循环都要来这么一下，我还不如直接写for，要来得爽快一些。或许还有别的办法：

vector<MyClass> notBusyClass;
remove_copy_if(m_vecData.begin(), m_vecData.end(), inserter(notBusyClass, notBusyClass.begin()), mem_fun_ref(&MyClass::IsBusy));
for_each(notBusyClass.begin(), notBusyClass.end(), bind2nd(mem_fun_ref(&MyClass::DoSomeThing), param));

    天哪，这种写法好象更恐怖。而且，还不是每种情况都能用的：
    1. notBusyClass不能是vector，因为不能建立指向引用的指针。这就要求MyClass是可拷贝的。但就算是可拷贝的，有时候拷贝成本也是很高的。
    2. MyClass::DoSomeThing的参数不能是引用（我们常定义参数为：const Param&），因为不能定义引用的引用这种类型。
    3. 一旦出现错误，这错误信息会让人极其昏倒。

    看来单靠标准C++是不成的。Boost的lambda的库似乎很不错，用用：

    for_each(m_vecData.begin(), m_vecData.end(),
        if_then( !bind(&MyClass::IsBusy, _1),
            bind(&MyClass::DoSomeThing, _1, param)));

不错，好了一些，但是还是很不好看。有没有更好的？有，boost1.34新加入的BOOST_FOREACH：

BOOST_FOREACH(cosnt MyClass& item, m_vecData)
{
if(!item.IsBusy())
item.DoSomeThing(param);
}

    Oh Yeah!

    好了，问题来了，为什么C++不直接在语言中提供foreach这个功能呢？
    个人认为，原因有几点：
    1. C/C++除了数组外，没有内置的容器，因此for语句足矣。
    2. 当C++进化到STL的时候，C++标准委员会根本没空去考虑其它的。
    而其它高级语言之所以内置了foreach，就是因为它们一开始就提供了标准的容器库和迭代/枚举接口，因此提供foreach就顺理成章了。

    现在，总算C++开始考虑，由模板引入而造成的代码复杂性的问题，这的确是Cpper的福音。因此，一系列相关的提案被提交。牵涉到上面代码中的提案就有： Decltype， Lambda expressions and closures for C++，proposal for new for-loop。　　
    其中，最符合foreach要求的就是新的for循环。采用这个语句，上面的程序就可以这么写：

for(const MyClass& item : m_vecData)
{
if(!item.IsBusy())
item.DoSomeThing(param);
}

不过，考虑到Decltype&auto提案已经被采纳，新的for-loop就不知道能不能再被采纳。因为使用Decltype&auto后，程序可以这么写：

for(auto iter = m_vecData.begin(), end = m_vecData.end(); iter != end; ++iter)
{
if(!iter->IsBusy())
iter->DoSomeThing(param);
}

似乎还是复杂点是吧？但是有了decltype&auto后，foreach功能可以用程序库或宏的形式被模拟，BOOST_FOREACH就是这么做的。具体模拟的方式<>提案写的很清楚了。
同时，假如lambda提案要是能再被通过的话，那就真的要开心了：

for_each(
  m_vecData,
  <>(item) extern(param)
  {
    if(!item.IsBusy())
        item.DoSomeThing(param);
  }
);

    Cool!
    沐枫小筑
    不过，VC++2008倒是增加了foreach功能，不过关键字不是foreach，而是for each，这个让人有点郁闷．要用的时候最好用宏定义替换一下，免得可移植性上出现问题．



[新闻]金融风暴改写富豪榜排名　巴菲特资产超盖茨
博客园首页社区新闻频道小组博问网摘闪存

关注C++0x: Concept

沐枫 — Sun, 09 Sep 2007 14:43:00 GMT

　　要说C++0x中对泛型编辑最大的改变，当属Concept了。
Concept这个东西，其实并不是刚刚提出来的。可以说，Concept是STL的基础。

STL之于C++的地位不言而寓，而其中最重要的，当属迭代器(Iterator)的概念(Concept)了。这是接触STL后得到的最明显的Concept。有了迭代器，就可以将算法与容易分离开来，这样就奠定了STL的基础。于是一个又一个服务于STL的概念(Concept)就诞生了。
不过相信大多数人只是直接使用STL，因此对于Concept没有什么印象。一旦涉及到自行创建程序库，特别是创建相容于STL规范的容器或算法的时候，就肯定要接触到STL中的一堆Concept了。
举个简单的例子，如何实现一个Iterator？STL中的Iterator有几个类别：ForwardIterator、BidirectionalIterator、RandomAccessIterator等5类。现在需要实现一个用于vector容器的Iterator，显然是要符合上述三种类型。但是要从STL找到象ForwardIterator的通用类，肯定是找不到。最多只能找到一个Iterator的通用定义：

template<class Category, class Type, class Distance = ptrdiff_t
   class Pointer = Type*, class Reference = Type&>
   struct iterator {
   typedef Category iterator_category;
   typedef Type value_type;
   typedef Distance difference_type;
   typedef Pointer pointer;
   typedef Reference reference;
   };

很昏倒吧，全是typedef。至于更具体的Concept，只好打开C++的标准文档了，想要满足ForwardIterator要哪些需求，满足RandomAccessIterator要哪些需求，然后对照着去实现。
至于实现后的Iterator是否真的符合这些Concept，就只好摸摸自已的良心，问问是否完全测试过了。
为什么会这样呢？因为这些Concept目前只停留在文档中。C++编译器对Concep完全没有概念。更过份的是，C++编译器甚至完全看不到或只看到一部份刚才定义的Iterator－－因为大多数编译器仅对确实需要具现化的类或成员才进行编译。

比如：

template<typename T>
class test
{
public:
    void kill_cpp(T t)
    {
        不要调用我啊！
    }
};
int main(int argc, char* argv[])
{
    test<int> t;
    //t.kill_cpp(0);
    return 0;
}

编译就完全通过，C++编译器对“不要调用我啊！”这几个字视而不见。我有时候就利用这个特点，以保证某些函数确实不应该被调用，而一旦被误调用了，还可以有一个能看得明白的错误信息：

error C2065: '不要调用我啊！': undeclared identifier (VC2008 Beta2)

也许STL的Concept还比较少接触。那么在写泛型程序时，也总会遇到一些类似的情形。比如下面的代码：

template<typename T>
static void Show(const T& t)
{
cout << t.Message() << endl;
}

这个函数用于显示某个类的信息。显然，它要求该类型必须拥有 Message 成员函数。但这个函数的用户知道吗？也许知道，因为你文档写的很详细。可是一旦用户忘记或者误用了，那麻烦就出来了，肯定是一堆错误信息。这个例子还比较简单，也就多几个错误信息，稍微仔细查看，还是能够解决问题。那么下面的例子：

#include <list>
#include <algorithm>
using namespace std;

int main(int argc, char* argv[])
{
    list<int> lst;
    sort(lst.begin(), lst.end());
    return 0;
}

这个例子将会产生一大堆的错误信息，足以让刚接触到的人如坠云雾。而实际原因只不过是list的iteraotr不是RandomAccessIterator(也就是说list不能象数组一样随机访问，所以不能使用sort函数)。

Java和.NET等新加入泛型编程特性的语言，对此自然深有体会，不约而同都加入了模板约束的机制。假如让.NET来实现这个sort的话，它可能会这么写：

void sort<T>(T container) where T : IEnumerable
{

}

这样，当container被代入共它类型，如int时，编译时将会给出明确的错误：

The type 'int' cannot be used as type parameter 'T' in the generic type or method sort(T)'.
There is no boxing conversion from 'int' to 'System.Collections.IEnumerable'.　（VC# 2008 Beta2)

是啊，模板约束很有用，至少可以让我们放心，编译器会帮我们检查那个T要满足什么条件。于是开始羡慕起Java和C#了：毕竟是后来者，把C++的优点采用了，缺点补上了...
为了让C++也能拥有这个特性，C++的模板库编写者真的是费尽心思。类似模板元编程等技术横空出世。boost有相当部份的程序类在为此努力。但是所有的努力，都仅仅只能让程序库的易用性有一些改善，却大大增加了程序库的编写复杂度和可维护性。势必在C++语言中内置相关的特性，才是最终的解决方案。

盼啊盼啊，终于盼来了C++0x，而且令人惊喜的是，C++并没有采用Java和C#那一套模板约束的方式，而是将STL的Concept从文档化变成语言特性了。这个变化我认为是革命性的，而且还带来了前所未有的新的编程方式，将创建继模板以来的新的流行－－可以预见，C#和Java最终也将会采用这个特性。
Concept的应用包含了C#和Java中的模板约束，但不止于此。模板约束仅仅是基本。

对于上面sort的例子，在C++0x中将会出现比较简洁的错误信息：

sort.cpp: In function 'void f()':
sort.cpp:7: error: no matching function for call to 'sort(std::_List_iterator, std::_List_iterator)'
<path>: note: candidates are: void std::sort(_Iter, _Iter) [with _Iter = std::_List_iterator<int>] <where clause>
sort.cpp:7: note: no concept map for requirement 'std::MutableRandomAccessIterator >'

错误信息一条：找不到可用的sort函数。
提示信息一条：List的Iterator没有到MutableRandomAccessIterator的映射。
稍微动一下脑，也就明白sort是需要随机访问的Iterator，而List既没有该类别的Iterator，也没有可以到该类别的Iterator的映射。
解决方法有两个：一是换用有随机访问的Iterator的容器，如vector；一是实现一个到MutableRandomAccessIterator的映射。

Concept目前在C++0x的提案已经确认肯定会被通过了。Concept引入C++，目的是要让模板库得容易使用，和容易编写。

对Concept有兴趣的朋友可以查看相关的文档。也许因为C++0x众多令人激动的特性，我会用我的方式进行一一表达。

相关链接：
http://del.icio.us/pongbablog/cplusplus
　　《C++0x漫谈》系列之：Concept, Concept!
　　C++0x展望[语言核心进化]
呵呵，偷一下懒，刘未鹏的文章推荐对C++0x感兴趣的朋友观看，文后所附的资料及相关的标准提案相当详细。这里就不照抄了。

[新闻]红杉资本发出严重警告：黄金时代已成历史
博客园首页社区新闻频道小组博问网摘闪存

Ultimate Toolbox 开源了

沐枫 — Fri, 07 Sep 2007 12:50:00 GMT

又是后知后觉，今天猪猪给我一个地址，让我看看怎么回事，结果我一看，是codeproject的MFC专栏。乍一看，真的晕了，所有的项目都是Ultimate Toolbox的。再一看，哇，Ultimate Toolbox从2007年8月起开源了，免费了。其最后几个产品是5月份发布的。

就象被个馅饼砸中了一样，有点晕。想当年，MFC下面最知名的界面库Ultimate ToolBox是个非常让人留口水的。没想到现在居然开源了，而且免费了。开发小组还花了许多精力，写了无数个控件介绍和下载贴在codeproject中。

再到主页http://www.theultimatetoolbox.com/中一看，原来是要停止这个项目了。那么，对于原有客户来说，开源免费确实是唯一的选择了。而Ultimate发生了什么，主页上没有说。或许是转型了。

[新闻]2008年10月11日科技博客精选
博客园首页社区新闻频道小组博问网摘闪存

关于C#2.0编译器的一个瘕疵

沐枫 — Wed, 29 Aug 2007 09:38:00 GMT

C#2.0编译器有个瘕疵，在开发过程中常常让人哭笑不得。被郁闷了。
主要发生在码代码时，将关键字打错的情况。

我就举两个例子。
例１：

    public class PacketId
    {
        public cosnt byte LOGIN = 1;
    }

上面红色的cosnt其实是笔误，应该是const，编译后当然会出错。但是错误提示居然让人不知所措：
错误 CS1519: 类、结构或接口成员声明中的标记“byte”无效
于是我找啊找啊，byte没有问题啊，真是头大。最后，多看了好多眼，才发现是const打错了。该死的，cosnt错了居然颜色和关键字一样(是不是我用了Assist造成的颜色不对呢？)。

例２：

    public class PacketId
    {
        pubilc const byte LOGIN = 1;
    }

上面的pubilc也是笔误，应该是public，错误信息为：
错误 CS1519: 类、结构或接口成员声明中的标记“const”无效
　　痛苦啊，怎么常量也不能定义了？？这回有经验了，果然，是public打错了。

－－－－
呵呵，不要笑我。

[新闻]搞死开心网还是搞活他？
博客园首页社区新闻频道小组博问网摘闪存

VC2008 beta2 的几个新东西

沐枫 — Mon, 13 Aug 2007 16:34:00 GMT

关于.net方面，已经有许多人在关注了，我就关注一下，VC2008方面的新东西吧。
1. 晕倒，实证后，没有增加tr1库（仅增加了tr1::hexfloat).
2. 对于模板的>>符号，中间不再需要空格了。
3. 增加了for each(T& in A){}语法－－这个不算是改进吧，估计是为了与.NET一起工作的产物。

这是今天下午初步扫一眼VC2008中Native C++后的感觉。
同时，标准库已不再支持Win95/98/me和NT4了。

至于C++/CLR，一个重要的部份就是STL/CLR。

[新闻]网络书店“新”军
博客园首页社区新闻频道小组博问网摘闪存

C++指针探讨 (四) 函数对象

沐枫 — Sat, 21 Jul 2007 13:30:00 GMT

函数对象不是函数指针。但是，在程序代码中，它的调用方式与函数指针一样，后面加个括号就可以了。
　　这是入门级的随笔，说的是函数对象的定义，使用，以及与函数指针，成员函数指针的关系。
沐枫小筑
函数对象实质上是一个实现了operator()--括号操作符--的类。
例如：

class Add
{
public:
int operator()(int a, int b)
  {
    return a + b;
  }
};

Add add; // 定义函数对象
cout << add(3,2); // 5

函数指针版本就是：

int AddFunc(int a, int b)
{
return a + b;
}
typedef int (*Add) (int a, int b);

Add add = &AddFunc;
cout << add(3,2); // 5

呵呵，除了定义方式不一样，使用方式可是一样的。都是：

cout << add(3,2);

既然函数对象与函数指针在使用方式上没什么区别，那为什么要用函数对象呢？很简单，函数对象可以携带附加数据，而指针就不行了。
下面就举个使用附加数据的例子：

class less
{
public:
    less(int num):n(num){}
    bool operator()(int value)
    {
        return value < n;
    }
private:
    int n;
};

使用的时候：

less isLess(10);
cout << isLess(9) << " " << isLess(12); // 输出 1 0

这个例子好象太儿戏了，换一个：

const int SIZE = 5;
int array[SIZE] = { 50, 30, 9, 7, 20};
// 找到小于数组array中小于10的第一个数的位置
int * pa = std::find_if(array, array + SIZE, less(10)); // pa 指向 9 的位置
// 找到小于数组array中小于40的第一个数的位置
int * pb = std::find_if(array, array + SIZE, less(40));　// pb 指向 30 的位置

这里可以看出函数对象的方便了吧？可以把附加数据保存在函数对象中，是函数对象的优势所在。
它的弱势也很明显，它虽然用起来象函数指针，但毕竟不是真正的函数指针。在使用函数指针的场合中，它就无能为力了。例如，你不能将函数对象传给qsort函数！因为它只接受函数指针。

要想让一个函数既能接受函数指针，也能接受函数对象，最方便的方法就是用模板。如：

template<typename FUNC>
int count_n(int* array, int size, FUNC func)
{
    int count = 0;
    for(int i = 0; i < size; ++i)
        if(func(array[i]))
            count ++;
    return count;
}

这个函数可以统计数组中符合条件的数据个数，如：

const int SIZE = 5;
int array[SIZE] = { 50, 30, 9, 7, 20};
cout << count_n(array, SIZE, less(10)); // 2

用函数指针也没有问题：

bool less10(int v)
{
return v < 10;
}
cout << count_n(array, SIZE, less10); // 2

另外，函数对象还有一个函数指针无法匹敌的用法：可以用来封装类成员函数指针！
因为函数对象可以携带附加数据，而成员函数指针缺少一个类实体(类实例)指针来调用，因此，可以把类实体指针给函数对象保存起来，就可以用于调用对应类实体成员函数了。

template<typename O>
class memfun
{
public:
    memfun(void(O::*f)(const char*), O* o): pFunc(f), pObj(o){}
    void operator()(const char* name)
    {
        (pObj->*pFunc)(name);
    }
private:
    void(O::*pFunc)(const char*);
    O* pObj;
};

class A
{
public:
    void doIt(const char* name)
    { cout << "Hello " << name << "!";}
};

    A a;
    memfun<A> call(&A::doIt, &a); // 保存 a::doIt指针以便调用
    call("Kitty"); // 输出 Hello Kitty!

大功告成了，终于可以方便保存成员函数指针，以备调用了。

不过，现实是残酷的。函数对象虽然能够保有存成员函数指针和调用信息，以备象函数指针一样被调用，但是，它的能力有限，一个函数对象定义，最多只能实现一个指定参数数目的成员函数指针。
标准库的mem_fun就是这样的一个函数对象，但是它只能支持0个和1个参数这两种成员函数指针。如 int A::func()或void A::func(int)、int A::func(double)等等，要想再多一个参数如：int A::func(int, double)，不好意思，不支持。想要的话，只有我们自已写了。
而且，就算是我们自已写，能写多少个？5个？10个？还是100个（这也太恐怖了）？
好在boost库提供了boost::function类，它默认支持10个参数，最多能支持50个函数参数(多了，一般来说这够用了。但它的实现就是很恐怖的：用模板部份特化及宏定义，弄了几十个模板参数，偏特化(编译期)了几十个函数对象。

----
C++0x已经被接受的一个提案，就是可变模板参数列表。用了这个技术，就不需要偏特化无数个函数对象了，只要一个函数对象模板就可以解决问题了。期待吧。

[新闻]百度C2C电子商务平台“有啊”youa.com上线
博客园首页社区新闻频道小组博问网摘闪存

boost 1.34 终于简化了内嵌python的支持

沐枫 — Wed, 23 May 2007 04:55:00 GMT

boost 1.34 终于简化了内嵌python的支持。
还支持了python2.5。
在中文windows下用vc8编译boost的过程中，虽然仍有代码页字符警告，但是可以正常编译成功，不再象1.33.1那样造成正则表达式库不修改源码不能够编译通过的问题了。

下面的例子是从boost文档中来的：

#include <iostream>
#include <string>
#include <boost/python.hpp>
#include <boost/ref.hpp>
#include <vector>
using namespace boost::python;

void greet()
{
    object main = import("__main__");
    object global(main.attr("__dict__"));

    // Define greet function in Python.
    object result = exec(
        "def greet(a):               \n"
        "   return 'Hello %s from Python!' % a \n",
        global, global);

    object greet = global["greet"];

    list lst;
    lst.append(1);
    lst.append(2);

    object r = greet(lst);

    std::string message = extract<std::string>(r);
    std::cout << message << std::endl;
}

int _tmain(int argc, _TCHAR* argv[])
{
    Py_Initialize();
    greet();
    system("Pause");
    return 0;
}

[新闻]Silverlight 2.0正式版下周发布
博客园首页社区新闻频道小组博问网摘闪存