MFC是否过时?如何学习MFC?

过时与否?简单回答就是:没有过时。

是否需要学习MFC?简单答之:depends on。

学习MFC最好的书籍?是这本:http://www.china-pub.com/45715 《VC++技术内幕》,另外深入一点可以看《深入浅出MFC》(侯捷)。

——————————————–

为何没有过时?很简单,微软一直在更新MFC,如果知道MFC的真正含义,你是不会说出过时两个字的,Microsoft Foundation Class,这是微软C++界面库的基础。有人会提WTL或者ATL,OK,他们被用的不多。至于QT什么的,那不是微软的东西,再好微软也不会用的。

MFC没有更新吗?当然不是,如果你安装了VS2008或者2010就会不经意发现,那些wizard提示方式下,你可以建立出更多更酷的界面模式,那些都是QT、WTL么?当然不是,那都是MFC的功劳!!!

MFC一直在与时俱进,为了建立微软的和谐帝国而努力更新更新。

要不要学MFC?这个问题值得思考,一般来说,如果你问我这个问题,我会问你两个额外的问题来确定你知道你想问什么。第一个额外问题是:你的工作或者学习需要你在Windows下搞开发么?第二个额外问题是:你所谓的学习,是指仅仅会用会从toolbox拖拽?还是懂得Internal的机理,知道它的优劣?

如果你只是想在Windows下搞界面相关的开发,依此谋生或者做点软件之类,那么学完我推荐那本《内幕》已经差不多足够了。再多看看一些MSDN的相关版本更新文章就足够你在公司里厮混下去。

如果你想了解的更多,其实微软也给你这个机会,MFC实际上是“路一直都在”,CString也好CDialog也好,其实它们的代码微软早就给你了,就在VisualStudio的MFC目录下,完完整整的哦。可是有多少人会去读会去看呢?想了解哪个类的实现或者函数的实现,只要“go to declaration”就可以了。

还有问题?欢迎留言,只要不是白痴问题,我都会尽量回答。

C语言趣味题目

http://stevenkobes.com/ctest.html

在这个网站上发现一套很有趣的C语言测试题,如果你招聘C语言相关开发人员,或者正在学习C语言,很值得做一做。

如果没有做,下面内容暂时不要看,最好自己先完成一遍。

—————————————–

image

——————————————–

OK,假设你做的答案没有完全正确,那你可以继续看下去了,否则,后面内容对你来说就是小菜一碟,不值得看。

——————————————–

第一题:

#include <setjmp.h>
static jmp_buf buf;
int main(void)
{
volatile int b = 3;
if (setjmp(buf) != 0)
{
printf(“%d\n”, b);
exit(0);
}
b = 5;
longjmp(buf, 1);
}

输出结果为A)3      B)5     C)0      D)都不是

答案为B,也就是输出5。

关键点在于理解setjmp以及longjmp,(http://en.wikipedia.org/wiki/Setjmp.h )第一次运行到setjmp,会设置jmp_buf,然后返回0。当调用longjmp时,会把longjmp里面的非0值作为setjmp的返回值返回(如果longjmp的value参数为0,setjmp恢复后返回1,也就是当恢复到setjmp存储点的时候,setjmp一定不会返回0)。

setjmp-longjmp组合的用处类似于游戏中的存盘读盘功能,经常被用于类似C++的异常恢复操作。

第二题:

struct node
{
int a;      int b;      int c;
};
struct node s = { 3, 5, 6 };
struct node *pt = &s;
printf(“%d\n”, *(int*)pt);
返回结果为3,这个算是比较简单,pt为指向结构s的指针,然后将pt转换为int指针,进行dereference,取出一个int值,那就是结构中第一个数。

我们将题目改动一下,如下代码

struct node
{
char a;   char b;  short c;   int d;
};
struct node s = { 3, 5, 6, 99 };
struct node *pt = &s;

printf(“%X\n”, *(int*)pt);
需要注意的是一般32位C编译器都认为char是8bit,short是16bit,int为32bit,所以node在内存中应该正好是对齐的,也就是abc这几个成员之间没有空隙。最终结果应该为60503,如果不是,欢迎你告诉我你具体的编译环境以及硬件配置。

第三题:

int foo(int x, int n){
int val = 1;
if (n > 0)
{
if (n % 2 == 1) val *= x;
val *= foo(x * x, n / 2);
}
return val;
}

这道题其实最简单的办法就是在纸上做一个推演计算,一步一步跑一下,就能得到答案了,这里面没有任何复杂的C语言概念。

第四题:

int a[5] = { 1, 2, 3, 4, 5 };
int *ptr = (int*)(&a + 1);
printf(“%d %d\n”, *(a + 1), *(ptr – 1));
这道题考的其实是指向数组的指针,&a是一个隐式的指向int [5]数组的指针,它和int* ptr是不一样的,如果真要定义这个指针,应该是int (*ptoa)[5]。所以ptoa每一次加一操作都相当于跨越int a[5]的内存步长(也就是5个int长度),也就是说&a + 1其实就是指向了a[5]这个位置,实际上内存里面这个位置是非法的,但是对ptr的强制转换导致了后面ptr-1的内存步长改为了1个int长度,所以ptr-1实际指向了a[4]。至于*(a+1)没什么好说的,值就是2。

第五题:

void foo(int[][3]);
int main(void)
{
int a[3][3] = { {1, 2, 3}, {4, 5, 6}, {7, 8, 9} };
foo(a);
printf(“%d\n”, a[2][1]);
return 0;
}

void foo(int b[][3])
{
++b;
b[1][1] = 9;
}

其实和前一题有异曲同工之妙,++b的步长实际上是3个int,也就是++b运算以后,b指向{4,5,6}这个数组的开始,而b[1]就是{7,8,9}, b[1][1]实际上就是8这个值也就是main函数中的a[2][1].

第六题:

int a, b, c, d;
a = 3;
b = 5;
c = a, b;
d = (a, b);

printf(“c=%d  “, c);
printf(“d=%d\n”, d);

这个其实有两个C语言知识点,一个是等号操作符优先级高于逗号操作符,另一个是逗号操作符相当于运算逗号前半部后半部的表达式,然后返回后半部表达式的值。所以c等于a(先计算等号),而d等于b(逗号表达式返回b)。

第七题:

int a[][3] = {1, 2, 3, 4, 5, 6};
int (*ptr)[3] = a;

printf(“%d %d “, (*ptr)[1], (*ptr)[2]);

++ptr;
printf(“%d %d\n”, (*ptr)[1], (*ptr)[2]);

依然是2维数组相关题目,ptr为指向int [3]数组的指针,首先指向a[0],所以(*ptr)[1], (*ptr)[2]就是a[0][1], a[0][2].然后++ptr,相当于ptr指向了a[1],这时得到的是a[1][1],a[1][2],所以结果就是2,3, 5, 6。

第八题:

int *f1(void)
{
int x = 10;   return &x;
}
int *f2(void)
{
int *ptr;   *ptr = 10;   return ptr;
}
int *f3(void)
{
int *ptr;   ptr = malloc(sizeof *ptr);   return ptr;
}

这里考的是返回一个指针的问题,一般来说返回指针的函数,里面一定有malloc之类的内存申请操作,传入指针类型,则是对指针指向的内容做修改。如果想修改指针本身,那就要传入指针的指针。

第九题:

int i = 3;   int j;
j = sizeof(++i + ++i);
printf(“i=%d j=%d\n”, i, j);
这道题考的内容其实就是sizeof,我在这篇文章里提到过http://sunxiunan.com/?p=1637 sizeof如果计算表达式,那么表达式是不会做计算的,也就是不管加加减减,sizeof就是针对i计算大小。在32位机器上,这个j应该为4。

我将代码扩展了一下,看看大家能不能想到结果:

short m;    int n;     double dn;
int j = sizeof ( m + n);
int k = sizeof ( n + n);
int l = sizeof ( m);
int l2 = sizeof (m * m);
int l3 = sizeof (m + dn);
int l4 = sizeof (m + m);

第十题:

void f1(int*, int);
void (*p[2])(int*, int);
int main(void)
{
int a = 3;
int b = 5;
p[0] = f1;
p[1] = f1;
p[0](&a, b);
printf(“%d %d “, a, b);
p[1](&a, b);
printf(“%d %d\n”, a, b);
return 0;
}

void f1(int *p, int q)
{
int tmp = *p;   *p = q;   q = tmp;
}

函数指针的数组p勉强算是一个知识点,另外一个知识点就是第八题提到的,对于int q这样的参数,是不会修改其内容的。而*p则可修改p指向的内容。

第十一题:

void e(int);
int main(void)
{
int a = 3;
e(a);

putchar(‘\n’);
return 0;
}

void e(int n)
{
if (n > 0)
{
e(–n);
printf(“%d “, n);
e(–n);
}
}

这道题自己debug一下就完全明白了,主要知识点就是递归调用,另外前置后置自减操作的返回值问题。

第十二题:

typedef int (*test)(float*, float*);
test tmp;

也是经常出现的一类题,对复杂的指针定义做解析,实际上K&R里面(5.12)也有介绍该如何解读。不熟悉的朋友可以试着练习练习标准库中的bsearch,qsort以及signal函数。

第十三题:

char p;
char buf[10] = {1, 2, 3, 4, 5, 6, 9, 8};
p = (buf + 1)[5];
printf(“%d\n”, p);

这道题我在http://sunxiunan.com/?p=1637 也提到过相关知识点,也就是p实际指向*(buf + 1 + 5),写的更诡异一些就是p=5[buf +1];也是同样结果。

第十四题:

类似十三题,也是把数组弄得有些诡异,(p += sizeof(int))[-1];相当于*(p + sizeof(int) + (-1))。

第十五题:

int ripple(int n, …)
{
int i, j, k;
va_list p;
k = 0;
j = 1;
va_start(p, n);
for (; j < n; ++j)
{
i = va_arg(p, int);
for (; i; i &= i – 1)
++k;
}
return k;
}

int main(void)
{
printf(“%d\n”, ripple(3, 5, 7));
return 0;
}

这道题也是两个知识点,一个是可变参数函数定义以及如何实现,va_arg会把5,7依次取出来。另一个知识点是i &= i-1,实际上是计算了i二进制形式中1的个数,每次计算都会消减掉最低有效位上的1。比如7二进制表示为111。i &= i –1的计算结果依次为110,100, 000 (也就是0)。在hacker’s Delights这本书里介绍了很多类似技巧。

第十六题:

int counter(int i)
{
static int count = 0;
count = count + i;
return count;
}

int main(void)
{
int i, j;
for (i = 0; i <= 5; i++)  j = counter(i);
printf(“%d\n”, j);
return 0;
}

只要了解静态局部变量的真正内涵,这道题就是小菜一碟碟碟碟碟碟。。。。。。

C语言strlen实现之不科学测试

代码放在这里:

http://gist.github.com/419473 

————————————-

其中strlenBSD为delphij实现的FreeBSD使用的strlen标准库函数。http://www.freebsd.org/cgi/cvsweb.cgi/src/lib/libc/string/strlen.c?rev=1.10

strlenVC来自VS2010的CRT src,我建立了一个内嵌汇编函数,其实是有问题的,因为MSDN说的很清楚,内嵌汇编这种方式是没法做优化的。

strlenDiet这个函数来自DietlibC,使用的是0.32版本。

strlenStandard是最一般常见的实现方式,比如wiki上、《c标准库》上都是类似写法。

logger是我自己写的一个高精度计时函数,里面用的QueryPerformanceFrequency这个函数,每段strlen计算都是单独start()以及stop(),然后计算运行时间。

还有一个重要的问题就是project setting。

首先我们使用release版本,在VC2010 project property page里面

image

最后一个问题就是测试字符串,我们使用了windowsUpdate.txt这个文本文件,大概1.2M左右。

当字符串个数为80000时,运行两次,我们得到测试结果如下(时间单位都是us):

Result strlen 0.000000 ##

Result strlenBSD 0.102586 ##

Result strlenVC 3012.946893 ##

Result strlenDiet 2802.122562 ##

Result strlenStandard 3485.999846 ##

—– second time ——–

Result strlen 0.000000 ##

Result strlenBSD 0.000000 ##

Result strlenVC 3015.086831 ##

Result strlenDiet 2806.302525 ##

Result strlenStandard 3676.002553 ##

可以看到这时候使用CRT标准库的strlen最快,而strlenBSD也是非常非常快乐,而标准实现是最慢的。

 

去掉优化看看。

image

Result strlen 4161.887115 ##

Result strlenBSD 3968.818857 ##

Result strlenVC 3078.673800 ##

Result strlenDiet 3819.303217 ##

Result strlenStandard 5035.940199 ##

—————– second ————

Result strlen 3165.460250 ##

Result strlenBSD 4013.348883 ##

Result strlenVC 3764.022041 ##

Result strlenDiet 5623.339493 ##

Result strlenStandard 6379.640180 ##

这个结果就比较有意思了,除了标准实现方式的版本最慢,其他差别不是很大,相比来说VC++内嵌汇编的实现比较快一些。

第二个测试文本来自ironruby的changelog.txt,大概5000行左右,我们依然试图读取80000个字符串(也就是只改变了代码中fopen的源文件)。

全优化版本两次测试结果如下:

Result strlen 0.000000 ##

Result strlenBSD 0.433735 ##

Result strlenVC 1011.775006 ##

Result strlenDiet 826.736862 ##

Result strlenStandard 1050.510424 ##

—————————-

Result strlen 0.000000 ##

Result strlenBSD 0.165407 ##

Result strlenVC 1030.929523 ##

Result strlenDiet 836.285049 ##

Result strlenStandard 1057.499975 ##

 

无优化设置版本两次测试结果如下:

Result strlen 1166.623783 ##

Result strlenBSD 1438.473774 ##

Result strlenVC 1265.279138 ##

Result strlenDiet 1456.994396 ##

Result strlenStandard 1546.674976 ##

—————————-

Result strlen 1166.989685 ##

Result strlenBSD 1480.218605 ##

Result strlenVC 1033.686648 ##

Result strlenDiet 1239.002409 ##

Result strlenStandard 1450.543506 ##

 

得到什么结论呢?除了我比较无聊,好像没有什么科学性的结论。如果硬要想,可以说两个:一个是内嵌汇编未必很快,因为编译器没法做优化。另外是,如果你想写一个优化版本strlen,delphij实现的FreeBSD版本是非常好的例子,而dietlibc的实现几乎没有什么改进,反而因为代码复杂容易引入bug。

有几个问题其实可以好好研究的,比如为何delphij的版本会如此快?VC++以及GCC优化选项哪个比较有用?该如何写一个类似CRT这样的strlen(也就是汇编代码编译为so或者lib然后连接进来)。只是这些话题有些超出我水平,就不乱说了。

updated:

新测试代码在这里,增加了一个没对齐情况的测试(p+1),另外测试字符串个数增加到300000,对testbyte,增加一个版本,直接写testbyte在代码里。

http://gist.github.com/419585

测试结果如下:

———–对齐———————–
      Result strlenVC 84904.335012 ##

Result strlenDiet 82614.256452 ##

Result strlenStandard 99900.620863 ##

Result strlen 0.000000 ##

Result strlenBSD 0.002673 ##

Result strlenBSD2 0.032413 ##

————未对齐————————

Result strlenVC 87593.624963 ##

Result strlenDiet 83682.625534 ##

Result strlenStandard 99746.446413 ##

Result strlen 0.002339 ##

Result strlenBSD 0.002673 ##

Result strlenBSD2 0.015037 ##

可以看到对齐没对齐差别不是很大,至于0.000000,那是因为太快了,计时器没法计算出差别。

dietlibc中的strcpy算法浅析

我们将代码稍作修改,让一些宏定义变成函数更容易理解一些:

为了不和标准库的strcpy名字冲突,我将其改为strcpy2.

如果你把上面的程序编译运行一下就会发现,快的原因在于strcpy2这个函数最后一部分while循环里面的这几行:

*(unsigned long *) s1 = l;

s2 += sizeof(unsigned long);

s1 += sizeof(unsigned long);

对C语言指针了解的朋友都知道,第一行是把l这个unsigned long类型变量值赋值给s1为地址的一个unsigned long型指针指向的内容。

在我的i386cpu PC机上,第二第三行分别是将s2以及s1指针增加了4(而不是通常函数实现里面的++)。这也就实现了每次拷贝4个char(也就是一个unsigned long)而不是只拷贝一个char。

而strcpy2前面的函数就是确保这个拷贝可以正确执行。

我们先看MyUnaligned这个函数(在dietlibc中原为UNALIGNED宏)。

先取了一个值是sizeof(unsigned long) – 1,然后将源字符串指针以及目标字符串指针都与这个值做与操作(xPtr & valN1),最后两个结果做一个异或xor操作(xVal ^ yVal)。

其实说白了很简单,xPtr & valN1相当于一个取模操作,i386 cpu上valN1的值为3,也就是与的结果可能为0,1,2,3,当xPtr或者yPtr的值为4的倍数时候,与操作得到结果为0。两个与操作结果做一下异或,只有都为0或者都为1的时候,返回为0。也就是只要有一个指针没对齐,就老老实实的做一个个char的拷贝(*s1++ = *s2++),然后从strcpy2返回。

这个算法就是为了保证xPtr以及yPtr指针都是在内存上是对齐的(aligned),如果没有对齐还要一次赋值4个char,那可能导致写入内存出错(参考这篇http://en.wikipedia.org/wiki/Data_structure_alignment)。

有的同学已经看出来了,如果源指针目标指针都没对齐,xor结果也是零,那不就错了么?

OK,不还有一段代码么,在STRALIGN里面,会对目标字符串指针地址取模,然后将余数返回,比如我们运行时人为地修改s1以及s2地址将其+1。debug运行如下图,得到p以及str地址,可以看到都是对齐在unsigned long边界上的( p & 3 一定是0)。

image

我们在Autos窗口里直接修改地址,让其加一,如下图:

image

这样两个指针就都没有对齐了。继续运行:

image

果然如我们预计的retVal的值为0。

image

xRet返回值为4 – 1,也就是3。

image

3个字符串(“aaa”)被拷贝到目标字符串里面,这时候目标字符串指针位置是对齐的了。

这是如果有编程经验的朋友可能已经有疑问,开头有可能没对齐,也有可能结尾部分没对齐啊,也就是尾巴部分一定是4的倍数么?未必,这时候这一段代码就起作用了。

unsigned long key1 = MKW(0x1ul);

        unsigned long key2 = MKW(0x80ul);

运算结果key1是0x01010101,key2结果是0x80808080,如果你看过Tony Bai写的strlen源码分析http://bigwhite.blogbus.com/logs/37753065.html ,就会发现这两个有意思的数字同样出现在glibc标准库当中。

((l – key1) & ~l) & key2我就不分析了,可以猜测到,这是对源字符串中NULL结尾符的检测。当检测到有结尾符的时候,就做按char拷贝,然后返回。感兴趣的可以参考TonyBai那篇文章,然后自己写几个test case测试一下。

整个函数就是这样,分析完毕。