鬼の领地 » C/C++/C# http://blog.upsuper.org the place where there are some ghost appearing... Wed, 19 Oct 2011 13:21:47 +0000 en hourly 1 http://wordpress.org/?v=3.3 今天写了个小小的 vc-fix http://blog.upsuper.org/write-a-little-vc-fix-today/ http://blog.upsuper.org/write-a-little-vc-fix-today/#comments Sun, 21 Mar 2010 02:39:51 +0000 upsuper http://blog.upsuper.org/?p=1119 我们的 C++ 老师给我布置了 C++ 的大作业来替代其他同学交的无聊题目。大作业的第一题就是完整的高精度库，并且要求使用运算符重载。因为原来用 C 写过，这次写，思路上没有太大问题，不过全部程序被我 C++ 化了，代码看过去很诡异……呃……

我自己的机子上，自然使用 g++ 编译，不过我猜老师会要求 VC6 能够编译……我就用上次安装的 VC6 编译了一下，发现好几个错误和无数警告……其实也是我意料之中的。

其中我觉得最讨厌的莫过于 for 循环的循环变量不被视为 for 循环的局部变量这一点，导致大量变量被其认为是重复定义，这个是 VC6 和标准就语言上相去最远的问题了……不想每个都去改，麻烦死了。

在网上一找，还真找到一个简单的方法：

1

#define for if(0) ; else for

其实我也不知道这个是什么机理，不过真的很管用！

另外一个就是 VC6 的标准库中没有 max 和 min 函数，这个也很囧，于是也自己写了一个。

以前做网页的时候经常写 ie-fix.css 文件，今天我弄 VC6 遇到这些问题，于是我也写了个 vc-fix.h 文件。M$ 真是一个需要 fix 的公司，什么时候出一个 m$-fix.com 好了……

最后贴出我的 vc-fix.h，主要解决 VC6 下 for 循环变量的问题和 max、min 函数未定义的问题：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

#ifndef _H_UPSUPER_VC_FIX_
#define _H_UPSUPER_VC_FIX_
 
#ifdef _MSC_VER
#   if _MSC_VER <= 1200
#       define for if (0); else for
 
template <class T>
inline const T& max(const T& a, const T& b) {
    return a > b ? a : b;
}
 
template <class T>
inline const T& min(const T& a, const T& b) {
    return a < b ? a : b;
}
 
template <class T, class Compare>
inline const T& max(const T& a, const T& b, Compare comp) {
    return comp(a, b) ? b : a;
}
 
template <class T, class Compare>
inline const T& min(const T& a, const T& b, Compare comp) {
    return comp(a, b) ? a : b;
}
 
#   endif
#endif
 
#endif // _H_UPSUPER_VC_FIX_

最后要解决的就是警告的问题。其实我很无语的是，所有的警告都是在 VC6 自己的头文件里面的……VC6 自己提示可以添加 /GX 来消除那些警告。于是我不得不再次修改我的编译脚本：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

#!/bin/bash
# - * - coding: UTF-8 - * -
 
VC6_DIR="这里写上VC6的安装地址"
 
BIN="$VC6_DIR/VC98/Bin"
export INCLUDE="$VC6_DIR/VC98/Include"
export LIB="$VC6_DIR/VC98/Lib" 
 
ARGS=
 
while getopts "o:cG:" optname
do
    case "$optname" in
    "o")
        ARGS="$ARGS /o$OPTARG"
    ;;
    "c")
        ARGS="$ARGS /c"
    ;;
    "G")
        ARGS="$ARGS /G$OPTARG"
    ;;
    esac
done
 
wine "$BIN/CL.EXE" $ARGS ${@:$OPTIND}

到了最后，再补充一点点吧。VC6 发现了两个额外的错误，我觉得应该不是不兼容的问题。就是我重载的 operator++ 和 operator– 不小心忘记写 return *this; 了，g++ 没有给我任何提示的编译通过了，而 VC6 则将这个视为错误。

在这个问题上，我同意 VC6 的看法，虽然我怀疑可能 g++ 自己加上了那句话，不过我觉得这个应该至少给出一个警告而非什么都不说。当然，可能一个 fatal error 太过了点……

参考资料：

]]> http://blog.upsuper.org/write-a-little-vc-fix-today/feed/ 2 跨编译器的 C 语言 NaN 支持 (纠正) http://blog.upsuper.org/nan-support-for-cross-compiler-of-c/ http://blog.upsuper.org/nan-support-for-cross-compiler-of-c/#comments Mon, 18 Jan 2010 11:19:59 +0000 upsuper http://blog.upsuper.org/?p=933 之前的版本犯了一个重大的错误！我错了……没有经过认真的实验就贴出来……

正文开始前，先看一个式子：

1

x != x

大家觉得，这个东西的返回可能为 true 么？事实上是可能的，只要这个 x 是 NaN，并且这个 C 编译器符合 IEEE 754 的标准。

所谓 NaN，即 Not A Number，不是一个数。这是 IEEE 754 国际浮点数运算标准当中规定的一个特殊值，这个值由于不是一个数，所以有很多奇怪的特性，比如上面这个不等于其本身。

虽然有这么个东西，而且是国际标准，不过我们也知道，这世界上总有那么些公司是不喜欢理会国际标准的，邪恶的 M$ 就是其中之一。而 Visual C++ 6.0 的 C 编译器也就“有幸”成为了少有的不能完全兼容 IEEE 754 的编译器之一。

至此，我们发现一个问题：邪恶的 M$ 的东西中，总是最垃圾的流传的最广，IE6 如此，VC6 也是如此。另外，在此声明一下，这里讲的全部是 C，不是 C++，在 C++ 中另外有一些比较符合标准的方式同时被各个编译器兼容。

OK，回归正题，既然 VC6 的编译器是个渣，可我们有的时候还是不得不让自己的代码与之兼容，于是就有了各种解决办法。

首先明确一下，我们现在需要两样东西，一是一个可以用于赋值的 NaN (在我的程序中作为一个标记值使用)，另一个是一个用于判断一个数是否为 NaN 的函数或宏。基于上面对 NaN 的介绍，在一个符合标准的编译器上，我们可以很容易地给出如下宏：

1
2

#define NaN (0.0 / 0.0)
#define IsNaN(x) ((x) != (x))

对于上面这样的 NaN 定义，VC6 不同寻常的会发生编译错误：

1

error C2124: divide or mod by zero

可能也有人会问，难道除 0 不应该是错误么？事实上 IEEE 754 里面就是规定 0.0 / 0.0 = NaN。这里我给出一个我个人的理解：学过高等数学的人大约都会知道，一个无穷小除以一个无穷小，他们的极限可能是无穷大或任何实数，而由于浮点数的精度限制，这里的 0 可能不是真的 0，而是一个很小很小极其趋近于 0 的数，类似无穷小，于是有这样的规定吧。再来看看 IsNaN，这个宏就更无敌了，VC6 的编译器会自作聪明的直接把它优化为 false……

那么对于 VC6 我们该怎么办呢？

查阅了许多资料，最后我们在 MSDN 中翻出了一份年代久远的文档：_isnan。这里的 _isnan 是 VC6 在 float.h 中定义的一个函数，用于校验一个数是否为 NaN。现在的问题就剩下，我们如何生成 NaN，以及如何判断编译器呢？

那么我们来思考一下，除了用零除零，还有什么方法可以生成 NaN 呢？翻看了 IEEE754 标准文档，看到了开平方一个负数也应该是 NaN。这一点应该很好理解，开平方一个负数应该得到一个虚数，而虚数不是一个实数，所以也就 Not a Number 了~于是最后形成了下面一段预处理指令：

1
2
3
4
5
6
7
8

#ifdef _FPCLASS_SNAN
#include <math.h>
#define NaN sqrt(-1)
#define IsNaN(x) _isnan(x)
#else
#define NaN (0.0 / 0.0)
#define IsNaN(x) ((x) != (x))
#endif

虽然调用 sqrt 可能有效率问题，而且额外的需要引用 math 头文件，不过还算几乎完美地解决了 NaN 跨编译器的兼容性问题~事实证明，这段代码可以通过 VC6 的编译器正确地编译并执行。

另外说一点东西，就是如何在 Linux 下用 VC6 的编译器呢？这个问题我想我解决的其实是不完美的，不过也留在这里吧。

首先我下载了一个免安装版的 VC6，然后解压。接着找到了 VC6/VC98/Bin 目录，里面有非常著名的 VC6 编译器的主程序 CL.EXE 以及连接器 LINK.EXE。对于编译器这种纯运算的程序，wine 的兼容性还是比较优美的。不过需要一个额外的 dll 文件支持：mspdb60.dll，这个文件很容易载到，解压到 wine 的系统目录 (~/.wine/drive_c/windows/system32) 就可以了。

接下去就是如何编译了……我的方法比较老土，是将待编译的文件复制到编译器目录，然后执行类似下面命令：

1

wine CL.EXE 源文件.c /I../Include /o可执行文件.exe /link /LIBPATH:../Lib

其中“源文件.c”和“可执行文件.exe”是很容易理解的，“/I../Include”是使编译器能知道 include 的文件应该去哪里找，而“/link”表示后面的部分是连接器参数，“/LIBPATH:../Lib”就是表示静态链接库的地址了~

最后再说说如何将 GCC 可以编译的程序移植到 VC6 中。GCC 实现了 C99 标准，但 VC6 因为出现在 1998 年 (怎么正好早一年……不过就算是 99 年出也未必会支持 C99 就是了……)，所以不支持 C99，于是所有的变量必须在函数最前面声明，不能混入代码内部。此外，在 VC6 当中，void 指针是不能进行运算的。还有就是不能用“//”开头的行注释，必须使用块注释。这是我移植过程中遇到的主要麻烦。

事实上，在 GCC 当中，可以验证大多数 C89 的限制，只要在编译的时候用如下语句：

1

gcc -ansi -pedantic -o 可执行文件 源文件.c

只要把其中所有的 warning 全部消灭掉就可以啦~

当然，最好的方法莫过于在 VC6 的编译器中直接测试了……

最后最后，M$ 实在是……唉……这个世界上不明真相的孩子果然是占大多数的……

关于修改的部分：之前的版本错误的使用 _FPCLASS_SNAN 这一校验函数 _fpclass 返回值当作 NaN 来使用。既然查到了这个，这里也顺便说一下这个东西吧。在 VC 的 float.h 库里面有 _fpclass 这个函数，用于检验一个浮点数的类型，可能的返回值都在 float.h 里面，如下：

1
2
3
4
5
6
7
8
9
10

#define _FPCLASS_SNAN   0x0001  /* signaling NaN */
#define _FPCLASS_QNAN   0x0002  /* quiet NaN */
#define _FPCLASS_NINF   0x0004  /* negative infinity */
#define _FPCLASS_NN     0x0008  /* negative normal */
#define _FPCLASS_ND     0x0010  /* negative denormal */
#define _FPCLASS_NZ     0x0020  /* -0 */
#define _FPCLASS_PZ     0x0040  /* +0 */
#define _FPCLASS_PD     0x0080  /* positive denormal */
#define _FPCLASS_PN     0x0100  /* positive normal */
#define _FPCLASS_PINF   0x0200  /* positive infinity */
]]> http://blog.upsuper.org/nan-support-for-cross-compiler-of-c/feed/ 3 方便使用 VC6 编译器的小脚本 http://blog.upsuper.org/a-simple-script-for-using-vc6-compiler-conveniently/ http://blog.upsuper.org/a-simple-script-for-using-vc6-compiler-conveniently/#comments Wed, 30 Dec 2009 10:45:56 +0000 upsuper http://blog.upsuper.org/?p=935 昨天的那篇日志跨编译器的 C 语言 NaN 支持当中讲到了如何在 Linux 下用 wine 执行 VC6 编译器编译程序，不过总觉得还是有那么些麻烦，要把待编译的文件复制到 VC6 的安装目录，还要写那么长一串东西。要是能像调用 GCC 那么方便就好了~

于是就有了下面这个小脚本：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

#!/bin/bash
# - * - coding: UTF-8 - * -
 
VC6_DIR="这里写上VC6的安装地址"
 
BIN="$VC6_DIR/VC98/Bin"
export INCLUDE="$VC6_DIR/VC98/Include"
export LIB="$VC6_DIR/VC98/Lib" 
 
ARGS=
 
while getopts "o:c" optname
do
  case "$optname" in
  "o")
    ARGS="$ARGS /o$OPTARG"
    ;;
  "c")
    ARGS="$ARGS /c"
    ;;
  esac
done
 
wine "$BIN/CL.EXE" $ARGS ${@:$OPTIND}

然后把他放在 PATH 里面的某个目录下 (我放在了用户级的 /home/upsuper/bin 里，这个似乎要自己添加就是了)，然后给这个文件加上可执行属性，最后只要在需要的地方执行：

1

vc6 xxx.cpp

就解决了~

不过从这个脚本中也可以看出，它的功能还不太完善，不对，是很不完善。目前支持设置输出文件名和阻止执行连接。我很想加入很多其他的参数，不过不知道该怎么弄……

参考资料：

  • Linux 技巧: Bash 参数和参数扩展
  • vc6.0的INCLUDE 和LIB路径如何修改? – CSDN社区
      • ]]> http://blog.upsuper.org/a-simple-script-for-using-vc6-compiler-conveniently/feed/ 1 两小段 C 的宏 http://blog.upsuper.org/two-pieces-of-macro-of-c/ http://blog.upsuper.org/two-pieces-of-macro-of-c/#comments Sun, 27 Dec 2009 04:21:36 +0000 upsuper http://blog.upsuper.org/?p=930 很久没写 blog 了……大学生活可比高中忙碌多了，哪个混蛋骗我说大学轻松来着……学的东西又难，作业又多，还有学生会活动……啊，我多想回到一中……

      最近忙着帮同学写大项目，用 C。话说，对于让没学过编程的人学 C 实在是一件很残酷的事情，即使我现在写仍然觉得很可怕……不过写着写着，觉得 C 实在是一个很神奇的语言，指针和宏是如此的优美~

      下面贴两个我在写那项目的时候用到的宏：

      1
2
3
4
5
6
7

      #define EXPAND_SPACE(type, p, num, max) { \
  if ((num) + 1 >= (max)) { \
    if ((max) < 16384) (max) <<= 1; \
    else (max) += 512; \
    (p) = (type*)realloc((void*)(p), (max)); \
  } \
}

      这个是我用来动态扩充空间用的宏，可以非常方便的动态增加需要的空间，这样就不需要为应该预分配多少空间烦恼了~

      1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

      #define SORT_RESULT(name, type, get, cmp, c1, c2) \
void SortResult_##name(int l, int r, Row **rows, int start) { \
  int i = l, j = r; \
  type m = get(rows[(i+j)/2], start); \
  Row *tmp; \
  \
  do { \
    while ((cmp)(m, get(rows[i], start)) c1 0) ++i; \
    while ((cmp)(m, get(rows[j], start)) c2 0) --j; \
    if (i <= j) { \
      tmp = rows[i], rows[i] = rows[j], rows[j] = tmp; \
      ++i, --j; \
    } \
  } while (i <= j); \
  \
  if (i < r) SortResult_##name(i, r, rows, start); \
  if (l < j) SortResult_##name(l, j, rows, start); \
}
 
#define SORT_RESULT_CHAR(name, c1, c2) \
  SORT_RESULT(Char##name, char*, GET_CHARS, strcmp, c1, c2)
 
#define SORT_RESULT_FLOAT(name, c1, c2) \
  SORT_RESULT(Float##name, float, GET_FLOAT, MyNumCmp, c1, c2)
 
SORT_RESULT_CHAR ( Asc, >, <)
SORT_RESULT_CHAR (Desc, <, >)
SORT_RESULT_FLOAT( Asc, >, <)
SORT_RESULT_FLOAT(Desc, <, >)

      这个很明显是快排~出于效率考虑，我不得不写4个排序……可是我觉得这样非常不好，代码重用性太低了，就写了个宏，就像上面那样~很偷懒吧~

      ]]>       http://blog.upsuper.org/two-pieces-of-macro-of-c/feed/ 0       闰年判断的优化及其他 http://blog.upsuper.org/optimize-leap-year-checking-and-other/ http://blog.upsuper.org/optimize-leap-year-checking-and-other/#comments Sat, 10 Oct 2009 13:10:37 +0000 upsuper http://blog.upsuper.org/?p=833 今天 Javran 发来短信给了一个短小的论年判断代码，并且问我是否认为有更简单的表达。下面是他最初给的代码：

      1

      return ((y & 3 != 0) ^ (y % 100 == 0) ^ (y % 400 != 0));

      一切的探究就从这个代码开始了。

      当然，这个代码是错的，因为疏忽了运算符的优先级，为达到本来的目的，这段代码大概应该这样改（测试代码3）：

      1

      return (((y & 3) != 0) ^ (y % 100 == 0) ^ (y % 400 != 0));

      接着，我将其中“!=0”和“==0”可以进一步缩短，现在代码现在变成这样（测试代码4）：

      1

      return !!(y & 3) ^ !(y % 100) ^ !!(y % 400);

      OK，对于抑或得到的思路，精简到这里差不多了。Javran 随后又给我了一个代码：

      1

      return !(y & 3) & ((!(y % 25) & !(y & 4)) | !!(y % 25));

      我说这比我的代码长，他解释说这段代码模的规模比较小，应该快一些。我说再快快不过 if 句。话说，经过实验，这条语句似乎是错误的……

      不过，这让我突然想起了对于 && 和 || 这样逻辑运算符的优化，我便想看看这个判断最快能至何~

      我们先看看最传统的判断代码（测试代码1）：

      1
2
3
4

      if (y % 4 != 0) return 0;
else if (y % 400 == 0) return 1;
else if (y % 100 == 0) return 0;
else return 1;

      然后我们做点小小的优化（测试代码2）：

      1
2
3
4

      if (y & 3) return 0;
else if (!(y % 400)) return 1;
else if (y % 100) return 1;
else return 0;

      接着我就按着这个的判断方式的思路进行一点缩减：

      1

      return (y & 3) != 0 && (y % 100 == 0 || y % 400 != 0);

      然后根据前面的方式缩短行（测试代码5）：

      1

      return !(y & 3) && (y % 100 || !(y % 400));

      可以看出，这是目前最短的一个判断方式。

      下面我做了30轮，每轮每个代码执行2,000,000次，取最短时间，得到如下结果：

      1
2
3
4
5

      1: 0.043275
2: 0.043562
3: 0.093261
4: 0.093184
5: 0.036421

      首先我们观察到，我最后推出的那个最短的式子是最快的，为什么？这是源于逻辑运算符的运算规则：对于 &&，如果前面项为假则不计算后项；对于 ||，如果前项为真则不计算后项。这就像 if 语句的递推作用：不做无谓的计算。而很显然，3和4的速度很慢，因为使用了异或运算，由于异或运算本身无法预测结果，必须把每一项都计算出来才行，因此慢了很多（比传统算法慢了一倍）。事实上按位运算应该都是这样。

      接着我们看到，我对 Javran 最初代码的优化版本效率有一定提高，可能是因为将减法（比较运算实质是做减法）化为了位操作吧。而对传统代码的优化却反而减慢了它，或许是修改规则导致的副作用吧……不过我的最终优化代码还是快了不少，原因不明，或许 if 并不快？

      应该有人会觉得奇怪，为什么要取最短时间，而不是平均值呢？事实上，我想在进行效率测试的时候，应该看最短时间。我们考虑测量效率时引入的误差出现在什么地方：CPU 肯定不会因为某个函数突然超频加速。那么有什么问题呢？因为我们用的都是分时系统，系统会不断的调度不同的线程使用 CPU。误差就在这里：时间会因为任务的切换而变长！因此测量结果只可能比实际值长，不可能比实际值短。所以要取最短时间。

      OK，对闰年的探索暂告一段落。我们突然想起前面 Javran 所给出的“缩小模的规模带来效率提升”的论断。

      因此我的测试程序增加了3个测试代码（测试代码6-8）：

      1
2
3

      return y % 25;
return y % 100;
return y % 400;

      得到的结果让人吃惊：

      1
2
3

      6: 0.106022
7: 0.098434
8: 0.098487

      模25最慢，400次之，而100最快，一样原因不明。看起来难道模的速度和模的数有关系？

      嗯，讨论了这么多，其实最初的问题——闰年判断的简化和优化——比较无聊，因为这段代码本身就不长，也几乎不可能被用于热点处。不过从这个过程中，我们看到了一些有趣的优化方式，虽然不能如算法改进那样降低复杂度，但这里有的时候常数也很重要，不是么？此外，还有一些关于效率测试的讨论。最后，我们还看到了一点神奇的结果，有待进一步探究咯~

      最后贴出测试代码：

      1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119

      #include <stdio.h>
#include <sys/time.h>
 
#define TRUE  1
#define FALSE 0
 
#define CHECK(NUM)  if (check##NUM(i) != a) printf(#NUM)
 
#define YEAR_AMOUNT 2000000
#define TEST(NUM) \
  gettimeofday(&tv_s, &tz); \
  for (j = 1; j <= YEAR_AMOUNT; ++j) \
    check##NUM(j); \
  gettimeofday(&tv_e, &tz); \
  timeval_subtract(&tv_d, &tv_e, &tv_s); \
  if (mtime[NUM].tv_sec == 0 && \
      mtime[NUM].tv_usec == 0 || \
      tv_d.tv_sec < mtime[NUM].tv_sec || \
      tv_d.tv_sec == mtime[NUM].tv_sec && \
      tv_d.tv_usec < mtime[NUM].tv_usec) \
    mtime[NUM] = tv_d; \
  printf(#NUM " ")
 
int y;
struct timeval mtime[10];
struct timezone tz;
 
int check1(int y) {
  if (y % 4 != 0) return FALSE;
  else if (y % 400 == 0) return TRUE;
  else if (y % 100 == 0) return FALSE;
  else return TRUE;
}
 
int check2(int y) {
  if (y & 3) return FALSE;
  else if (!(y % 400)) return TRUE;
  else if (y % 100) return TRUE;
  else return FALSE;
}
 
int check3(int y) {
  return ((y & 3) != 0) ^ (y % 100 == 0) ^ (y % 400 != 0);
}
 
int check4(int y) {
  return !!(y & 3) ^ !(y % 100) ^ !!(y % 400);
}
 
int check5(int y) {
  return !(y & 3) && (y % 100 || !(y % 400));
}
 
int check6(int y) {
  return y % 25;
}
 
int check7(int y) {
  return y % 100;
}
 
int check8(int y) {
  return y % 400;
}
 
// 时间减法
int timeval_subtract(result, x, y)
       struct timeval *result, *x, *y;
{
  if (x->tv_usec < y->tv_usec) {
    int nsec = (y->tv_usec - x->tv_usec) / 1000000 + 1;
    y->tv_usec -= 1000000 * nsec;
    y->tv_sec += nsec;
  }
  if (x->tv_usec - y->tv_usec > 1000000) {
    int nsec = (x->tv_usec - y->tv_usec) / 1000000;
    y->tv_usec += 1000000 * nsec;
    y->tv_sec -= nsec;
  }
 
  result->tv_sec = x->tv_sec - y->tv_sec;
  result->tv_usec = x->tv_usec - y->tv_usec;
 
  return x->tv_sec < y->tv_sec;
}
 
int main() {
  int i, j;
 
  // 验证代码正确性
  for (i = 1; i <= YEAR_AMOUNT; ++i) {
    int a;
    a = check1(i);
    CHECK(2); CHECK(3); CHECK(4); CHECK(5);
  }
  printf("\nCheck complete!\n");
 
  // 开始计时
  struct timeval tv_s, tv_e;
  struct timeval tv_d;
  for (i = 0; i < 100; ++i) {
    printf("%d: ", i);
    TEST(1);
    TEST(2);
    TEST(3);
    TEST(4);
    TEST(5);
    TEST(6);
    TEST(7);
    TEST(8);
    printf("\n");
  }
 
  // 输出结果
  for (i = 1; i <= 8; ++i)
    printf("%d: %ld.%06ld\n", i, mtime[i].tv_sec, mtime[i].tv_usec);
 
  return 0;
}

      很久没写这种东西了……唉……

      ]]>       http://blog.upsuper.org/optimize-leap-year-checking-and-other/feed/ 1       OpenGL 的小试验（三） http://blog.upsuper.org/opengl-small-test-3/ http://blog.upsuper.org/opengl-small-test-3/#comments Sat, 21 Feb 2009 15:53:01 +0000 upsuper http://blog.upsuper.org/?p=695 screenshot-opengl今天回家本想在我的 Ubuntu 上玩玩 OpenGL，结果花了一个下午，终于研究出些东西了……

      在 NeHe 的源代码中似乎有 Linux 的，不过一个是用 glut、一个是用 SDL、一个是用 GLX，原本看到 glut 是 OpenGL 官方的一个夸平台的简单窗口系统，结果发现全屏不能……于是就找到了 GLFW 这个东西，据说比较简单，不过还是研究了一个下午。

      下面说一下研究成果吧，首先，想要用 g++ 编译用 GLFW 写的程序，一定要加这些编译参数： -lglfw -lGL -lGLU -lXrandr，特别是最后一个，是其官方参考中没有的！这个是我查了许多资料，然后瞎猜猜到的……再说说头文件，这次不需要引用3个库了，只有一个 #include <GL/glfw.h> 就可以了，似乎把其他的库自动引用了。另外就是，画完要用 glfwSwapBuffers(); 刷新，不然不仅什么都不会显示，而且还会死机……除此之外，还要注意那个键盘的按键，不要想当然的和 Windows 下拿去类比，根据研究发现，键盘事件交出的 key 最大可以达到 318，而且特殊键都会以这些“大值”返回，所以一定要申请好内存……

      这次主要参考了：
      GLFW Reference
      OpenGL Tutorials – Basics
      以及 NeHe 的 OpenGL 教程。

      这个例子是一个转动的彩色四棱锥，只有 ESC 和 F11 的键盘处理，附加帧数计算。

      1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151

      #include <cstdio>
#include <cstdlib>
#include <cstring>
#include <unistd.h>
#include <GL/glfw.h>
 
bool fullscreen;
bool active = true;
bool keys[GLFW_KEY_LAST+1]; // 为键盘按键申请空间
 
GLfloat rtri;
 
bool initGLFW(const char*, int, int);
 
// 帧数统计用
double starttime;
int flames = 0;
 
// 绘制代码
void drawGLScene()
{
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
	glLoadIdentity();
 
	glTranslatef(0.0f, 0.0f, -5.0f);
	glRotatef(rtri, 0.0f, 1.0f, 0.0f);
	glBegin(GL_TRIANGLES);
		glColor3f(1.0f, 0.0f, 0.0f); glVertex3f( 0.0f,  1.0f,  0.0f);
		glColor3f(0.0f, 1.0f, 0.0f); glVertex3f(-1.0f, -1.0f,  1.0f);
		glColor3f(0.0f, 0.0f, 1.0f); glVertex3f( 1.0f, -1.0f,  1.0f);
 
		glColor3f(1.0f, 0.0f, 0.0f); glVertex3f( 0.0f,  1.0f,  0.0f);
		glColor3f(0.0f, 0.0f, 1.0f); glVertex3f( 1.0f, -1.0f,  1.0f);
		glColor3f(0.0f, 1.0f, 0.0f); glVertex3f( 1.0f, -1.0f, -1.0f);
 
		glColor3f(1.0f, 0.0f, 0.0f); glVertex3f( 0.0f,  1.0f,  0.0f);
		glColor3f(0.0f, 1.0f, 0.0f); glVertex3f( 1.0f, -1.0f, -1.0f);
		glColor3f(0.0f, 0.0f, 1.0f); glVertex3f(-1.0f, -1.0f, -1.0f);
 
		glColor3f(1.0f, 0.0f, 0.0f); glVertex3f( 0.0f,  1.0f,  0.0f);
		glColor3f(0.0f, 0.0f, 1.0f); glVertex3f(-1.0f, -1.0f, -1.0f);
		glColor3f(0.0f, 1.0f, 0.0f); glVertex3f(-1.0f, -1.0f,  1.0f);
	glEnd();
 
	++flames;
	double dt = glfwGetTime() - starttime;
	if (dt >= 5.0f)
	{
		printf("%d frames in %.1lf seconds = %.3lf FPSn", flames, dt, double(flames) / dt);
		flames = 0;
		st = glfwGetTime();
	}
 
	rtri += 0.15f;
}
 
// 键盘处理
void keyPress(int key, int action)
{
	keys[key] = action;
 
	if (keys[GLFW_KEY_ESC])
	{
		active = false;
		return;
	}
 
	if (keys[GLFW_KEY_F11])
	{
		keys[GLFW_KEY_F11] = GLFW_RELEASE;
		glfwTerminate();
		fullscreen = ! fullscreen;
		initGLFW("Upsuper's OpenGL Test", 640, 480);
	}
}
 
inline void quit(int status)
{
	glfwTerminate();
	exit(status);
}
 
inline void quit() {
	quit(0);
}
 
inline void report_error(const char* info)
{
	puts(info);
	quit(1);
}
 
void resizeGLScene(int width, int height)
{
	if (height <= 0) height = 1;
 
	glViewport(0, 0, width, height);
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
 
	gluPerspective(45.0f, GLfloat(width)/GLfloat(height), 0.1f, 100.0f);
 
	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();
}
 
bool initGL(int width, int height)
{
	glShadeModel(GL_SMOOTH);
	glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
	glClearDepth(1.0f);
	glEnable(GL_DEPTH_TEST);
	glDepthFunc(GL_LEQUAL);
	glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
	return true;
}
 
bool initGLFW(const char* title, int width, int height)
{
	glfwInit();
	if (! glfwOpenWindow(width, height, 8, 8, 8, 8, 24, 0, 
			fullscreen ? GLFW_FULLSCREEN : GLFW_WINDOW))
		report_error("ERROR: Cannot open a window.");
	glfwSetWindowTitle(title);
	glfwEnable(GLFW_AUTO_POLL_EVENTS);
	glfwSetKeyCallback(keyPress);
	glfwSetWindowSizeCallback(resizeGLScene);
 
	initGL(width, height);
}
 
int main(int argc, char** argv)
{
	printf("Would you like to run in fullscreen mode? [Y/n]");
	int c = getchar();
	fullscreen = (c != 'n' && c != 'N');
 
	memset(keys, false, sizeof(keys));
	initGLFW("Upsuper's OpenGL Test", 640, 480);
 
	st = glfwGetTime();
	do
	{
		drawGLScene();
		glfwSwapBuffers();
	}
	while (active);
 
	quit();
	return 0;
}

      代码比 VC++ 的那个短好多，再次证明 Linux 是多么适用于编程……

      同时根据帧数对比，印证了我的猜想——全屏下比较流畅！我这里全屏下 fps 达到了窗口模式的接近3倍。

      附 makefile 文件（这也是我第一次写 makefile）：

      1
2

      all: test1.cpp a.cpp
	g++ test1.cpp -o test1 -lglfw -lGL -lGLU -lXrandr

      最后，我还是十分高兴，那个绘制代码是我自己写出来的，不是抄的了！（虽然以前写过……）

      写 OpenGL 就是爽……

      ]]>       http://blog.upsuper.org/opengl-small-test-3/feed/ 0       OpenGL 的小试验（二） http://blog.upsuper.org/opengl-small-test-2/ http://blog.upsuper.org/opengl-small-test-2/#comments Fri, 20 Feb 2009 11:49:23 +0000 upsuper http://blog.upsuper.org/?p=692 test2今天又玩了玩，感觉到 OpenGL 实在太强大了！我也第一次遭到了买好显卡的重要意义：可以写 OpenGL 的程序！右边是效果图，有半透明、点光源效果。其实动起来会比较炫一点。

      参考了下面教程（其实主要是抄）：
      OpenGL教程之纹理映射
      OpenGL教程之纹理滤波方式
      OpenGL教程之Alpha混合

      除了教程里的功能，我还增加了按空格停止和按回车复位两个无聊功能……

      整个程序也已经由上一篇的将近400行增加到了超过500行。不过和新的的优美效果比起来，这点代码似乎不算什么~

      1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519

      #include <windows.h>
#include <stdio.h>
#include <gl\gl.h>
#include <gl\glu.h>
#include <gl\glaux.h>
 
HGLRC hRC = NULL;
HDC hDC = NULL;
HWND hWnd = NULL;
HINSTANCE hInstance;
 
bool keys[256];
bool active = true;
bool fullscreen = true;
 
bool light, blend, lp, fp, bp, f11p;
 
GLfloat xrot, yrot, zrot;
GLfloat xspeed, yspeed;
GLfloat z = -5.0f;
 
GLfloat lightAmbient[] = { 0.5f, 0.5f, 0.5f, 1.0f };
GLfloat lightDiffuse[] = { 1.0f, 1.0f, 1.0f, 1.0f };
GLfloat lightPosition[] = { 0.0f, 0.0f, 2.0f, 1.0f };
 
GLuint filter;
GLuint texture[3];
 
LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);
 
AUX_RGBImageRec *LoadBMP(char *filename)
{
	FILE *file = NULL;
	if (! filename) return NULL;
	file = fopen(filename, "r");
	if (! file) return NULL;
	fclose(file);
	return auxDIBImageLoad(filename);
}
 
int LoadGLTextures()
{
	int status = false;
	AUX_RGBImageRec *textureImage[1];
	memset(textureImage, 0, sizeof(void*)*1);
 
	if (textureImage[0] = LoadBMP("test2.bmp"))
	{
		status = true;
		glGenTextures(1, &texture[0]);
		glBindTexture(GL_TEXTURE_2D, texture[0]);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
		glTexImage2D(GL_TEXTURE_2D, 0, 3, 
			textureImage[0]->sizeX, textureImage[0]->sizeY,
			0, GL_RGB, GL_UNSIGNED_BYTE, textureImage[0]->data);
 
		glBindTexture(GL_TEXTURE_2D, texture[1]);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
		glTexImage2D(GL_TEXTURE_2D, 0, 3, 
			textureImage[0]->sizeX, textureImage[0]->sizeY,
			0, GL_RGB, GL_UNSIGNED_BYTE, textureImage[0]->data);
 
		glBindTexture(GL_TEXTURE_2D, texture[2]);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST);
		gluBuild2DMipmaps(GL_TEXTURE_2D, 3,
			textureImage[0]->sizeX, textureImage[0]->sizeY,
			GL_RGB, GL_UNSIGNED_BYTE, textureImage[0]->data);
	}
 
	if (textureImage[0])
	{
		if (textureImage[0]->data)
			free(textureImage[0]->data);
		free(textureImage[0]);
	}
 
	return status;
}
 
GLvoid ReSizeGLScene(GLsizei width, GLsizei height)
{
	if (height == 0)
		height = 1;
	glViewport(0, 0, width, height);
 
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
 
	gluPerspective(45.0f, (GLfloat)width/(GLfloat)height, 0.1f, 100.0f);
 
	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();
}
 
int InitGL(GLvoid)
{
	if (! LoadGLTextures())
		return false;
 
	glColor4f(1.0f, 1.0f, 1.0f, 0.5f);
	glBlendFunc(GL_SRC_ALPHA, GL_ONE);
 
	glEnable(GL_TEXTURE_2D);
	glShadeModel(GL_SMOOTH);
	glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
	glClearDepth(1.0f);
	glEnable(GL_DEPTH_TEST);
	glDepthFunc(GL_LEQUAL);
	glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
 
	glLightfv(GL_LIGHT1, GL_AMBIENT, lightAmbient);
	glLightfv(GL_LIGHT1, GL_DIFFUSE, lightDiffuse);
	glLightfv(GL_LIGHT1, GL_POSITION, lightPosition);
	glEnable(GL_LIGHT1);
 
	return true;
}
 
int DrawGLScene(GLvoid)
{
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
	glLoadIdentity();
	glTranslatef(0.0f, 0.0f, z);
	glRotatef(xrot, 1.0f, 0.0f, 0.0f);
	glRotatef(yrot, 0.0f, 1.0f, 0.0f);
	//glRotatef(zrot, 0.0f, 0.0f, 1.0f);
	glColor3f(1.0f, 1.0f, 1.0f);
	glBindTexture(GL_TEXTURE_2D, texture[filter]);
	glBegin(GL_QUADS);
		glNormal3f(0.0f, 0.0f, 1.0f);
		glTexCoord2f(0.0f, 0.0f);
		glVertex3f(-1.0f, -1.0f,  1.0f);
		glTexCoord2f(1.0f, 0.0f);
		glVertex3f( 1.0f, -1.0f,  1.0f);
		glTexCoord2f(1.0f, 1.0f);
		glVertex3f( 1.0f,  1.0f,  1.0f);
		glTexCoord2f(0.0f, 1.0f);
		glVertex3f(-1.0f,  1.0f,  1.0f);
 
		glNormal3f(0.0f, 0.0f, -1.0f);
		glTexCoord2f(1.0f, 0.0f);
		glVertex3f(-1.0f, -1.0f, -1.0f);
		glTexCoord2f(1.0f, 1.0f);
		glVertex3f(-1.0f,  1.0f, -1.0f);
		glTexCoord2f(0.0f, 1.0f);
		glVertex3f( 1.0f,  1.0f, -1.0f);
		glTexCoord2f(0.0f, 0.0f);
		glVertex3f( 1.0f, -1.0f, -1.0f);
 
		glNormal3f(0.0f, 1.0f, 0.0f);
		glTexCoord2f(0.0f, 1.0f);
		glVertex3f(-1.0f,  1.0f, -1.0f);
		glTexCoord2f(0.0f, 0.0f);
		glVertex3f(-1.0f,  1.0f,  1.0f);
		glTexCoord2f(1.0f, 0.0f);
		glVertex3f( 1.0f,  1.0f,  1.0f);
		glTexCoord2f(1.0f, 1.0f);
		glVertex3f( 1.0f,  1.0f, -1.0f);
 
		glNormal3f(0.0f, -1.0f, 0.0f);
		glTexCoord2f(1.0f, 1.0f);
		glVertex3f(-1.0f, -1.0f, -1.0f);
		glTexCoord2f(0.0f, 1.0f);
		glVertex3f( 1.0f, -1.0f, -1.0f);
		glTexCoord2f(0.0f, 0.0f);
		glVertex3f( 1.0f, -1.0f,  1.0f);
		glTexCoord2f(1.0f, 0.0f);
		glVertex3f(-1.0f, -1.0f,  1.0f);
 
		glNormal3f(1.0f, 0.0f, 0.0f);
		glTexCoord2f(1.0f, 0.0f);
		glVertex3f( 1.0f, -1.0f, -1.0f);
		glTexCoord2f(1.0f, 1.0f);
		glVertex3f( 1.0f,  1.0f, -1.0f);
		glTexCoord2f(0.0f, 1.0f);
		glVertex3f( 1.0f,  1.0f,  1.0f);
		glTexCoord2f(0.0f, 0.0f);
		glVertex3f( 1.0f, -1.0f,  1.0f);
 
		glNormal3f(-1.0f, 0.0f, 0.0f);
		glTexCoord2f(0.0f, 0.0f);
		glVertex3f(-1.0f, -1.0f, -1.0f);
		glTexCoord2f(1.0f, 0.0f);
		glVertex3f(-1.0f, -1.0f,  1.0f);
		glTexCoord2f(1.0f, 1.0f);
		glVertex3f(-1.0f,  1.0f,  1.0f);
		glTexCoord2f(0.0f, 1.0f);
		glVertex3f(-1.0f,  1.0f, -1.0f);
	glEnd();
 
	//xrot += 0.3f, yrot += 0.2f, zrot += 0.4f;
	xrot += xspeed;
	yrot += yspeed;
 
	return true;
}
 
GLvoid KillGLWindow(GLvoid)
{
	if (fullscreen)
	{
		ChangeDisplaySettings(NULL, 0);
		ShowCursor(true);
	}
 
	if (hRC)
	{
		if (! wglMakeCurrent(NULL, NULL))
			MessageBox(NULL, "Release Of DC And RC Failed.",
				"SHUTDOWN ERROR", MB_OK | MB_ICONINFORMATION);
		if (! wglDeleteContext(hRC))
			MessageBox(NULL, "Release Rendering Context Failed.",
			"SHUTDOWN ERROR", MB_OK | MB_ICONINFORMATION);
		hRC = NULL;
	}
 
	if (hDC && ! ReleaseDC(hWnd, hDC))
	{
		MessageBox(NULL, "Release Device Context Failed.",
			"SHUTDOWN ERROR", MB_OK | MB_ICONINFORMATION);
		hDC = NULL;
	}
 
	if (hWnd && ! DestroyWindow(hWnd))
	{
		MessageBox(NULL, "Could Not Release hWnd.",
			"SHUTDOWN ERROR", MB_OK | MB_ICONINFORMATION);
		hWnd = NULL;
	}
}
 
bool CreateGLWindow(char* title, int width, int height, int bits, bool fullscreenflag)
{
	GLuint PixelFormat;
	WNDCLASS wc;
	DWORD dwExStyle;
	DWORD dwStyle;
 
	RECT windowRect;
	windowRect.left = (long)0;
	windowRect.right = (long)width;
	windowRect.top = (long)0;
	windowRect.bottom = (long)height;
 
	fullscreen = fullscreenflag;
 
	hInstance = GetModuleHandle(NULL);
	wc.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;
	wc.lpfnWndProc = (WNDPROC) WndProc;
	wc.cbClsExtra = 0;
	wc.cbWndExtra = 0;
	wc.hInstance = hInstance;
	wc.hIcon = LoadIcon(NULL, IDI_WINLOGO);
	wc.hCursor = LoadCursor(NULL, IDC_ARROW);
	wc.hbrBackground = NULL;
	wc.lpszMenuName = NULL;
	wc.lpszClassName = "OpenGL";
 
	if (! RegisterClass(&wc))
	{
		MessageBox(NULL, "Failed To Register The Windows Class.",
			"ERROR", MB_OK | MB_ICONEXCLAMATION);
		return false;
	}
 
	if (fullscreen)
	{
		DEVMODE dmScreenSettings;
		memset(&dmScreenSettings, 0, sizeof(dmScreenSettings));
		dmScreenSettings.dmSize = sizeof(dmScreenSettings);
		dmScreenSettings.dmPelsWidth = width;
		dmScreenSettings.dmPelsHeight = height;
		dmScreenSettings.dmBitsPerPel = bits;
		dmScreenSettings.dmFields = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT;
 
		if (ChangeDisplaySettings(&dmScreenSettings, 
			CDS_FULLSCREEN) != DISP_CHANGE_SUCCESSFUL)
		{
			if (MessageBox(NULL, 
				"The Requested Fullscreen Mode Is Not Supported By Your Video Card. Use Windowed Mode Instead?",
				"OpenGL", MB_YESNO | MB_ICONEXCLAMATION) == IDYES)
			{
				fullscreen = false;
			}
			else
			{
				MessageBox(NULL, "Program Will Now Close.",
					"ERROR", MB_OK | MB_ICONSTOP);
				return false;
			}
		}
	}
 
	if (fullscreen)
	{
		dwExStyle = WS_EX_APPWINDOW;
		dwStyle = WS_POPUP;
		ShowCursor(false);
	}
	else
	{
		dwExStyle = WS_EX_APPWINDOW | WS_EX_WINDOWEDGE;
		dwStyle = WS_OVERLAPPEDWINDOW;
	}
	AdjustWindowRectEx(&windowRect, dwStyle, false, dwExStyle);
 
	if (! (hWnd = CreateWindowEx(dwExStyle, "OpenGL", title,
		WS_CLIPSIBLINGS | WS_CLIPCHILDREN | dwStyle, 0, 0,
		windowRect.right - windowRect.left,
		windowRect.bottom - windowRect.top,
		NULL, NULL, hInstance, NULL)))
	{
		KillGLWindow();
		MessageBox(NULL, "Window Creation Error.", "ERROR",
			MB_OK | MB_ICONEXCLAMATION);
		return false;
	}
 
	static PIXELFORMATDESCRIPTOR pfd = 
	{
		sizeof(PIXELFORMATDESCRIPTOR), 1,
		PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER,
		PFD_TYPE_RGBA, bits, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
		16, 0, 0, PFD_MAIN_PLANE, 0, 0, 0, 0
	};
 
	if (! (hDC = GetDC(hWnd)))
	{
		KillGLWindow();
		MessageBox(NULL, "Can't Create A GL Device Context.",
			"ERROR", MB_OK | MB_ICONEXCLAMATION);
		return false;
	}
 
	if (! (PixelFormat = ChoosePixelFormat(hDC, &pfd)))
	{
		KillGLWindow();
		MessageBox(NULL, "Can't Find A Suitable PixelFormat.",
			"ERROR", MB_OK | MB_ICONEXCLAMATION);
		return false;
	}
 
	if (! SetPixelFormat(hDC, PixelFormat, &pfd))
	{
		KillGLWindow();
		MessageBox(NULL, "Can't Set The PixelFormat.", "ERROR",
			MB_OK | MB_ICONEXCLAMATION);
		return false;
	}
 
	if (! (hRC = wglCreateContext(hDC)))
	{
		KillGLWindow();
		MessageBox(NULL, "Can't Create A GL Rendering Context.",
			"ERROR", MB_OK | MB_ICONEXCLAMATION);
		return false;
	}
 
	if (! wglMakeCurrent(hDC, hRC))
	{
		KillGLWindow();
		MessageBox(NULL, "Can't Activate The GL Rendering Context.",
			"ERROR", MB_OK | MB_ICONEXCLAMATION);
		return false;
	}
 
	ShowWindow(hWnd, SW_SHOW);
	SetForegroundWindow(hWnd);
	SetFocus(hWnd);
	ReSizeGLScene(width, height);
 
	if (! InitGL())
	{
		KillGLWindow();
		MessageBox(NULL, "Initialization Failed.", "ERROR",
			MB_OK | MB_ICONEXCLAMATION);
		return false;
	}
 
	return true;
}
 
LRESULT CALLBACK WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
	switch (uMsg)
	{
	case WM_ACTIVATE:
		active = ! HIWORD(wParam);
		return 0;
	case WM_SYSCOMMAND:
		switch (wParam)
		{
		case SC_SCREENSAVE: 
		case SC_MONITORPOWER:
			return 0;
		}
		break;
	case WM_CLOSE:
		PostQuitMessage(0);
		return 0;
	case WM_KEYDOWN:
		keys[wParam] = true;
		return 0;
	case WM_KEYUP:
		keys[wParam] = false;
		return 0;
	case WM_SIZE:
		ReSizeGLScene(LOWORD(lParam), HIWORD(lParam));
		return 0;
	}
	return DefWindowProc(hWnd, uMsg, wParam, lParam);
}
 
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
	LPSTR lpCmdLine, int nCmdShow)
{
	MSG msg;
	bool done = false;
 
	fullscreen = (MessageBox(NULL, 
		"Would You Like To Run In Fullscreen Mode?",
		"Start Fullscreen?", MB_YESNO | MB_ICONQUESTION) == IDYES);
	if (! CreateGLWindow("OpenGL Test", 640, 480, 16, fullscreen))
		return 0;
 
	while (! done)
	{
		if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
		{
			if (msg.message == WM_QUIT)
				done = true;
			else
			{
				TranslateMessage(&msg);
				DispatchMessage(&msg);
			}
		}
		else
		{
			if (active)
			{
				if (keys[VK_ESCAPE])
					done = true;
				else
				{
					DrawGLScene();
					SwapBuffers(hDC);
					if (keys['L'] && !lp)
					{
						lp = true;
						light = ! light;
						if (! light)
							glDisable(GL_LIGHTING);
						else
							glEnable(GL_LIGHTING);
					}
					else if (! keys['L'])
						lp = false;
 
					if (keys['F'] && !fp)
					{
						fp = true;
						filter += 1;
						if (filter > 2) filter = 0;
					}
					else if (! keys['F'])
						fp = false;
 
					if (keys['B'] && !bp)
					{
						bp = true;
						blend = ! blend;
						if (blend)
						{
							glEnable(GL_BLEND);
							glDisable(GL_DEPTH_TEST);
						}
						else
						{
							glDisable(GL_BLEND);
							glEnable(GL_DEPTH_TEST);
						}
					}
					else if (! keys['B'])
						bp = false;
 
					if (keys[VK_F11] && !f11p)
					{
						f11p = true;
						KillGLWindow();
						fullscreen = ! fullscreen;
						if (! CreateGLWindow("OpenGL Test", 640, 480, 16, fullscreen))
							return 0;
					}
					else if (!keys[VK_F11])
						f11p = false;
 
					if (keys[VK_PRIOR]) z -= 0.02f;
					if (keys[VK_NEXT]) z += 0.02f;
 
					if (keys[VK_UP]) xspeed -= 0.01f;
					if (keys[VK_DOWN]) xspeed += 0.01f;
					if (keys[VK_RIGHT]) yspeed += 0.01f;
					if (keys[VK_LEFT]) yspeed -= 0.01f;
 
					if (keys[' ']) xspeed = 0.0f, yspeed = 0.0f;
					if (keys[13]) z = -5.0f;
				}
			}
		}
	}
 
	KillGLWindow();
	return (msg.wParam);
}
      ]]>       http://blog.upsuper.org/opengl-small-test-2/feed/ 0       OpenGL 的小试验（一） http://blog.upsuper.org/opengl-small-test-1/ http://blog.upsuper.org/opengl-small-test-1/#comments Thu, 19 Feb 2009 13:17:10 +0000 upsuper http://blog.upsuper.org/?p=686 test1今天突然心血来潮想看看 OpenGL。找了个 OpenGL 的教程，看起来不错。不过这个教程着实吓了我一跳，第一篇的代码就超过了300行！先来一个效果图~

      我参考的教程有：
      OpenGL教程之新手上路
      OpenGL教程之第一个多边形
      OpenGL教程之着色
      OpenGL教程之旋转
      OpenGL教程之向3D进军

      然后写了段小程序（不过大部分代码是直接抄的……而且我一点也不觉得小……398行……）：

      1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398

      #include <windows.h>
#include <glgl.h>
#include <glglu.h>
#include <glglaux.h>
 
HGLRC hRC = NULL;
HDC hDC = NULL;
HWND hWnd = NULL;
HINSTANCE hInstance;
 
bool keys[256];
bool active = true;
bool fullscreen = true;
 
GLfloat rtri;
GLfloat rquad;
 
LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);
 
GLvoid ReSizeGLScene(GLsizei width, GLsizei height)
{
	if (height == 0)
		height = 1;
	glViewport(0, 0, width, height);
 
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
 
	gluPerspective(45.0f, (GLfloat)width/(GLfloat)height, 0.1f, 100.0f);
 
	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();
}
 
int InitGL(GLvoid)
{
	glShadeModel(GL_SMOOTH);
	glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
	glClearDepth(1.0f);
	glEnable(GL_DEPTH_TEST);
	glDepthFunc(GL_LEQUAL);
	glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
	return true;
}
 
int DrawGLScene(GLvoid)
{
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
	glLoadIdentity();
	glTranslatef(-1.5f, 0.0f, -6.0f);
	glRotatef(rtri, 0.0f, 1.0f, 0.0f);
	glBegin(GL_TRIANGLES);
		glColor3f(1.0f, 0.0f, 0.0f);
		glVertex3f( 0.0f,  1.0f,  0.0f);
		glColor3f(0.0f, 1.0f, 0.0f);
		glVertex3f(-1.0f, -1.0f,  1.0f);
		glColor3f(0.0f, 0.0f, 1.0f);
		glVertex3f( 1.0f, -1.0f,  1.0f);
 
		glColor3f(1.0f, 0.0f, 0.0f);
		glVertex3f( 0.0f,  1.0f,  0.0f);
		glColor3f(0.0f, 1.0f, 0.0f);
		glVertex3f( 1.0f, -1.0f, -1.0f);
		glColor3f(0.0f, 0.0f, 1.0f);
		glVertex3f(-1.0f, -1.0f, -1.0f);
 
		glColor3f(1.0f, 0.0f, 0.0f);
		glVertex3f( 0.0f,  1.0f,  0.0f);
		glColor3f(0.0f, 0.0f, 1.0f);
		glVertex3f(-1.0f, -1.0f, -1.0f);
		glColor3f(0.0f, 1.0f, 0.0f);
		glVertex3f(-1.0f, -1.0f,  1.0f);
 
		glColor3f(1.0f, 0.0f, 0.0f);
		glVertex3f( 0.0f,  1.0f,  0.0f);
		glColor3f(0.0f, 0.0f, 1.0f);
		glVertex3f( 1.0f, -1.0f, 1.0f);
		glColor3f(0.0f, 1.0f, 0.0f);
		glVertex3f( 1.0f, -1.0f, -1.0f);
	glEnd();
 
	glBegin(GL_QUADS);
		glColor3f(0.0f, 1.0f, 0.0f);
		glVertex3f(-1.0f, -1.0f,  1.0f);
		glColor3f(0.0f, 0.0f, 1.0f);
		glVertex3f( 1.0f, -1.0f,  1.0f);
		glColor3f(0.0f, 1.0f, 0.0f);
		glVertex3f( 1.0f, -1.0f, -1.0f);
		glColor3f(0.0f, 0.0f, 1.0f);
		glVertex3f(-1.0f, -1.0f, -1.0f);
	glEnd();
 
	glLoadIdentity();
	glTranslatef(1.5f, 0.0f, -7.0f);
	glRotatef(rquad, 1.0f, 0.0f, 0.0f);
	glBegin(GL_QUADS);
		glColor3f(0.0f, 1.0f, 0.0f);
		glVertex3f( 1.0f,  1.0f, -1.0f);
		glVertex3f(-1.0f,  1.0f, -1.0f);
		glVertex3f(-1.0f,  1.0f,  1.0f);
		glVertex3f( 1.0f,  1.0f,  1.0f);
 
		glColor3f(1.0f, 0.5f, 0.0f);
		glVertex3f( 1.0f, -1.0f,  1.0f);
		glVertex3f(-1.0f, -1.0f,  1.0f);
		glVertex3f(-1.0f, -1.0f, -1.0f);
		glVertex3f( 1.0f, -1.0f, -1.0f);
 
		glColor3f(1.0f, 0.0f, 0.0f);
		glVertex3f( 1.0f,  1.0f,  1.0f);
		glVertex3f(-1.0f,  1.0f,  1.0f);
		glVertex3f(-1.0f, -1.0f,  1.0f);
		glVertex3f( 1.0f, -1.0f,  1.0f);
 
		glColor3f(1.0f, 1.0f, 0.0f);
		glVertex3f( 1.0f, -1.0f, -1.0f);
		glVertex3f(-1.0f, -1.0f, -1.0f);
		glVertex3f(-1.0f,  1.0f, -1.0f);
		glVertex3f( 1.0f,  1.0f, -1.0f);
 
		glColor3f(0.0f, 0.0f, 1.0f);
		glVertex3f(-1.0f,  1.0f,  1.0f);
		glVertex3f(-1.0f,  1.0f, -1.0f);
		glVertex3f(-1.0f, -1.0f, -1.0f);
		glVertex3f(-1.0f, -1.0f,  1.0f);
 
		glColor3f(1.0f, 0.0f, 1.0f);
		glVertex3f( 1.0f,  1.0f, -1.0f);
		glVertex3f( 1.0f,  1.0f,  1.0f);
		glVertex3f( 1.0f, -1.0f,  1.0f);
		glVertex3f( 1.0f, -1.0f, -1.0f);
	glEnd();
 
	rtri += 0.2f;
	rquad -= 0.15f;
 
	return true;
}
 
GLvoid KillGLWindow(GLvoid)
{
	if (fullscreen)
	{
		ChangeDisplaySettings(NULL, 0);
		ShowCursor(true);
	}
 
	if (hRC)
	{
		if (! wglMakeCurrent(NULL, NULL))
			MessageBox(NULL, "Release Of DC And RC Failed.",
				"SHUTDOWN ERROR", MB_OK | MB_ICONINFORMATION);
		if (! wglDeleteContext(hRC))
			MessageBox(NULL, "Release Rendering Context Failed.",
			"SHUTDOWN ERROR", MB_OK | MB_ICONINFORMATION);
		hRC = NULL;
	}
 
	if (hDC && ! ReleaseDC(hWnd, hDC))
	{
		MessageBox(NULL, "Release Device Context Failed.",
			"SHUTDOWN ERROR", MB_OK | MB_ICONINFORMATION);
		hDC = NULL;
	}
 
	if (hWnd && ! DestroyWindow(hWnd))
	{
		MessageBox(NULL, "Could Not Release hWnd.",
			"SHUTDOWN ERROR", MB_OK | MB_ICONINFORMATION);
		hWnd = NULL;
	}
}
 
bool CreateGLWindow(char* title, int width, int height, int bits, bool fullscreenflag)
{
	GLuint PixelFormat;
	WNDCLASS wc;
	DWORD dwExStyle;
	DWORD dwStyle;
 
	RECT WindowRect;
	WindowRect.left = (long)0;
	WindowRect.right = (long)width;
	WindowRect.top = (long)0;
	WindowRect.bottom = (long)height;
 
	fullscreen = fullscreenflag;
 
	hInstance = GetModuleHandle(NULL);
	wc.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;
	wc.lpfnWndProc = (WNDPROC) WndProc;
	wc.cbClsExtra = 0;
	wc.cbWndExtra = 0;
	wc.hInstance = hInstance;
	wc.hIcon = LoadIcon(NULL, IDI_WINLOGO);
	wc.hCursor = LoadCursor(NULL, IDC_ARROW);
	wc.hbrBackground = NULL;
	wc.lpszMenuName = NULL;
	wc.lpszClassName = "OpenGL";
 
	if (! RegisterClass(&wc))
	{
		MessageBox(NULL, "Failed To Register The Windows Class.",
			"ERROR", MB_OK | MB_ICONEXCLAMATION);
		return false;
	}
 
	if (fullscreen)
	{
		DEVMODE dmScreenSettings;
		memset(&dmScreenSettings, 0, sizeof(dmScreenSettings));
		dmScreenSettings.dmSize = sizeof(dmScreenSettings);
		dmScreenSettings.dmPelsWidth = width;
		dmScreenSettings.dmPelsHeight = height;
		dmScreenSettings.dmBitsPerPel = bits;
		dmScreenSettings.dmFields = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT;
 
		if (ChangeDisplaySettings(&dmScreenSettings, 
			CDS_FULLSCREEN) != DISP_CHANGE_SUCCESSFUL)
		{
			if (MessageBox(NULL, 
				"The Requested Fullscreen Mode Is Not Supported By Your Video Card. Use Windowed Mode Instead?",
				"OpenGL", MB_YESNO | MB_ICONEXCLAMATION) == IDYES)
			{
				fullscreen = false;
			}
			else
			{
				MessageBox(NULL, "Program Will Now Close.",
					"ERROR", MB_OK | MB_ICONSTOP);
				return false;
			}
		}
	}
 
	if (fullscreen)
	{
		dwExStyle = WS_EX_APPWINDOW;
		dwStyle = WS_POPUP;
		ShowCursor(false);
	}
	else
	{
		dwExStyle = WS_EX_APPWINDOW | WS_EX_WINDOWEDGE;
		dwStyle = WS_OVERLAPPEDWINDOW;
	}
	AdjustWindowRectEx(&WindowRect, dwStyle, false, dwExStyle);
 
	if (! (hWnd = CreateWindowEx(dwExStyle, "OpenGL", title,
		WS_CLIPSIBLINGS | WS_CLIPCHILDREN | dwStyle, 0, 0,
		WindowRect.right - WindowRect.left,
		WindowRect.bottom - WindowRect.top,
		NULL, NULL, hInstance, NULL)))
	{
		KillGLWindow();
		MessageBox(NULL, "Window Creation Error.", "ERROR",
			MB_OK | MB_ICONEXCLAMATION);
		return false;
	}
 
	static PIXELFORMATDESCRIPTOR pfd = 
	{
		sizeof(PIXELFORMATDESCRIPTOR), 1,
		PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER,
		PFD_TYPE_RGBA, bits, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
		16, 0, 0, PFD_MAIN_PLANE, 0, 0, 0, 0
	};
 
	if (! (hDC = GetDC(hWnd)))
	{
		KillGLWindow();
		MessageBox(NULL, "Can't Create A GL Device Context.",
			"ERROR", MB_OK | MB_ICONEXCLAMATION);
		return false;
	}
 
	if (! (PixelFormat = ChoosePixelFormat(hDC, &pfd)))
	{
		KillGLWindow();
		MessageBox(NULL, "Can't Find A Suitable PixelFormat.",
			"ERROR", MB_OK | MB_ICONEXCLAMATION);
		return false;
	}
 
	if (! SetPixelFormat(hDC, PixelFormat, &pfd))
	{
		KillGLWindow();
		MessageBox(NULL, "Can't Set The PixelFormat.", "ERROR",
			MB_OK | MB_ICONEXCLAMATION);
		return false;
	}
 
	if (! (hRC = wglCreateContext(hDC)))
	{
		KillGLWindow();
		MessageBox(NULL, "Can't Create A GL Rendering Context.",
			"ERROR", MB_OK | MB_ICONEXCLAMATION);
		return false;
	}
 
	if (! wglMakeCurrent(hDC, hRC))
	{
		KillGLWindow();
		MessageBox(NULL, "Can't Activate The GL Rendering Context.",
			"ERROR", MB_OK | MB_ICONEXCLAMATION);
		return false;
	}
 
	ShowWindow(hWnd, SW_SHOW);
	SetForegroundWindow(hWnd);
	SetFocus(hWnd);
	ReSizeGLScene(width, height);
 
	if (! InitGL())
	{
		KillGLWindow();
		MessageBox(NULL, "Initialization Failed.", "ERROR",
			MB_OK | MB_ICONEXCLAMATION);
		return false;
	}
 
	return true;
}
 
LRESULT CALLBACK WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
	switch (uMsg)
	{
	case WM_ACTIVATE:
		active = ! HIWORD(wParam);
		return 0;
	case WM_SYSCOMMAND:
		switch (wParam)
		{
		case SC_SCREENSAVE: 
		case SC_MONITORPOWER:
			return 0;
		}
		break;
	case WM_CLOSE:
		PostQuitMessage(0);
		return 0;
	case WM_KEYDOWN:
		keys[wParam] = true;
		return 0;
	case WM_KEYUP:
		keys[wParam] = false;
		return 0;
	case WM_SIZE:
		ReSizeGLScene(LOWORD(lParam), HIWORD(lParam));
		return 0;
	}
	return DefWindowProc(hWnd, uMsg, wParam, lParam);
}
 
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
	LPSTR lpCmdLine, int nCmdShow)
{
	MSG msg;
	bool done = false;
 
	fullscreen = (MessageBox(NULL, 
		"Would You Like To Run In Fullscreen Mode?",
		"Start Fullscreen?", MB_YESNO | MB_ICONQUESTION) == IDYES);
	if (! CreateGLWindow("OpenGL Test", 640, 480, 16, fullscreen))
		return 0;
 
	while (! done)
	{
		if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
		{
			if (msg.message == WM_QUIT)
				done = true;
			else
			{
				TranslateMessage(&msg);
				DispatchMessage(&msg);
			}
		}
		else
		{
			if (active)
			{
				if (keys[VK_ESCAPE])
					done = true;
				else
				{
					DrawGLScene();
					SwapBuffers(hDC);
				}
			}
		}
	}
 
	KillGLWindow();
	return (msg.wParam);
}
      ]]>       http://blog.upsuper.org/opengl-small-test-1/feed/ 0       ujudger-base 0.1 Released http://blog.upsuper.org/ujudger-base-0-1-released/ http://blog.upsuper.org/ujudger-base-0-1-released/#comments Sun, 29 Jun 2008 14:45:21 +0000 upsuper http://blog.upsuper.org/?p=122 经过我许多的资料查找和编写，终于完成了ujudger-base的第一个版本！

      ujudger 是我准备编写的基于 Linux 的测评程序，采用 GPL 协议。由于一直以来找不到 Linux 下的测评程序，因此准备自己写一个。ujudger 的 u 既是取我网名的第一个字母，也是 ubuntu 的第一个字母，表示这个程序应该会在 ubuntu 下完成编写。而 ujudger-base 是 ujudger 的基础程序，表现 ujudger 的测评核心，即耗时和内存耗用的取得。使用 time 命令和系统监视器监视器的资料对比一下，ujudger-base 获得的信息还是比较体现程序的真实情况的。

      ujudger-base 并不复杂，不过也不简单（自少我这么觉得）。在编写的过程中，开始不知道 Linux 下的进程控制，后来知道了 fork() 函数。开始觉得很奇怪，后来也就慢慢明白了。不就是返回两次么，有什么了不起的~然后就是exec族的函数，成功了就不返回了_-b

      然后就是等待的办法。网上有些人是直接用 wait4 快速返回来等待，但我觉得这样很影响速度，因此采用了 usleep 等待 100ms（有没有一点像 Cena 的方法？）。

      同时，我还查找了有关程序运行数据读取的相关问题，最后采用的是读取 /proc/<pid>/stat 文件的方法。具体采用的一些技术层的资料我准备明天发一篇来讲。

      除此之外就是几乎第一次大规模的采用 C++ 的推荐风格编写程序（以前写OI的程序，为了效率不得不放弃许多 C++ 优美的特性），因此有写丑的地方也请多多指教。

      里面的注释很多了，由于我的英语水平有限（My English is limited!），如果注释有什么语法错误，也请多多指教！

      点击这里下载源代码：ujudger-base-0.1.cpp (3.6 KB)

      ]]>       http://blog.upsuper.org/ujudger-base-0-1-released/feed/ 1       自己写的QuickSearch http://blog.upsuper.org/quicksearch-by-myself/ http://blog.upsuper.org/quicksearch-by-myself/#comments Thu, 14 Feb 2008 05:53:13 +0000 upsuper http://blog.upsuper.org/?p=8 今天研究Discuz!代码的时候要搜索一个函数在哪里被调用，结果不懂怎么办。

      Windows的搜索貌似某个服务被我禁了一直以来都不能用，而Google的Desktop又不收编这些东西……

      花了一点时间写了一个QuickSearch，代码也很短，效率也很高。用法就是“QuickSearch 关键字”。就会遍历当前目录及其子目录下的所有的文件，查找包含关键字的文件。

      如果你也喜欢可以在这里下载：QuickSearch.exe (16KB)

      由于使用VS2005编译，需要.NET Framework 2.0支持。源代码在下方，可以用VS2003编译。

      蛮好用的说，代码也很短：

      1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

      using System;
using System.IO;
 
namespace QuickSearch
{
    class Program
    {
        static string curdir = Directory.GetCurrentDirectory();
        static int lcurdir = curdir.Length + 1;
        static string searchText;
 
        static void Main(string[] args)
        {
            searchText = args[0];
            SearchDir(curdir);
        }
 
        static string filecontent;
 
        static void SearchDir(string path)
        {
            string[] files = Directory.GetFiles(path);
            foreach (string file in files)
            {
                filecontent = File.ReadAllText(file);
                if (filecontent.IndexOf(searchText) > 0)
                    Console.WriteLine(file.Substring(lcurdir));
            }
            string[] dirs = Directory.GetDirectories(path);
            foreach (string dir in dirs)
                SearchDir(dir);
        }
    }
}
      ]]>       http://blog.upsuper.org/quicksearch-by-myself/feed/ 4       瑞星导致Cena测评失误 http://blog.upsuper.org/rising-make-cena-wrong/ http://blog.upsuper.org/rising-make-cena-wrong/#comments Sun, 13 Jan 2008 05:49:00 +0000 upsuper http://blog.upsuper.org/?p=14 生日邀请赛，当然要十分慎重。昨天用C++写完了第一题的标程，生成数据后，拿到Cena上一测，竟然几乎全部显示“无输出” _-b

      经过反复测试，发现如果我不用freopen修改标准流，而用fopen或fstream就没有问题。可是freopen毕竟是我们平常最常用的方法啊？如果不行，测评结果肯定也会有很大误差。不过，说一句，有一个人的C++程序测了竟然不会“无输出”，是我们信息组另一个用C++的，很早以前的程序，同样用freopen，她不会出错，我会……

      一开始怀疑我的Diskeeper，结果关掉以后依旧会。最后开始怀疑瑞星。把瑞星的全部监控关掉，仍然没有解决问题。突然发现，瑞星的伞还是黄色的，发现原来还有主动防御，把主动防御全部关掉，结果就过了。

      最后经过反复排查，发现是瑞星的“恶意行为检测”有问题。

      我也不懂是怎么回事呃，但我已经向瑞星客服报告了这一问题。

      ]]>       http://blog.upsuper.org/rising-make-cena-wrong/feed/ 0       我们的Online Judge http://blog.upsuper.org/our-online-judge/ http://blog.upsuper.org/our-online-judge/#comments Sat, 13 Oct 2007 11:33:28 +0000 upsuper http://blog.upsuper.org/?p=27 和 MRain 开始编写我们信息组内部用的Online Judge。

      这个Online Judge我准备做成类似Cena的网页版，准备使用PHP+MySQL+Apache+Windows2K3作为运行环境，AJAX做界面，C++程序做后台测评程序。采取类似USACO的提交立即测评，在线等待结果的测评方式。

      现在我正在撰写文档，估计正式编写工作从下一周开始。

      ]]>       http://blog.upsuper.org/our-online-judge/feed/ 0