SEMAN

曾经沧海难为水、除却巫山不是云

C++博客 首页 新随笔 联系 聚合 管理
  9 Posts :: 3 Stories :: 24 Comments :: 0 Trackbacks

2005年11月30日 #

[介绍]
gcc and g++分别是gnu的c & c++编译器 gcc/g++在执行编译工作的时候,总共需要4步

1.预处理,生成.i的文件[预处理器cpp]
2.将预处理后的文件不转换成汇编语言,生成文件.s[编译器egcs]
3.有汇编变为目标代码(机器代码)生成.o的文件[汇编器as]
4.连接目标代码,生成可执行程序[链接器ld]
[参数详解]
-x language filename
  设定文件所使用的语言,使后缀名无效,对以后的多个有效.也就是根据约定C语言的后
缀名称是.c的,而C++的后缀名是.C或者.cpp,如果你很个性,决定你的C代码文件的后缀
名是.pig 哈哈,那你就要用这个参数,这个参数对他后面的文件名都起作用,除非到了
下一个参数的使用。
  可以使用的参数吗有下面的这些
  `c', `objective-c', `c-header', `c++', `cpp-output', `assembler', and `a
ssembler-with-cpp'.
  看到英文,应该可以理解的。
  例子用法:
  gcc -x c hello.pig
  
-x none filename
  关掉上一个选项,也就是让gcc根据文件名后缀,自动识别文件类型
  例子用法:
  gcc -x c hello.pig -x none hello2.c
  
-c
  只激活预处理,编译,和汇编,也就是他只把程序做成obj文件
  例子用法:
  gcc -c hello.c
  他将生成.o的obj文件
-S
  只激活预处理和编译,就是指把文件编译成为汇编代码。
  例子用法
  gcc -S hello.c
  他将生成.s的汇编代码,你可以用文本编辑器察看
-E
  只激活预处理,这个不生成文件,你需要把它重定向到一个输出文件里面.
  例子用法:
  gcc -E hello.c > pianoapan.txt
  gcc -E hello.c | more
  慢慢看吧,一个hello word 也要与处理成800行的代码
-o
  制定目标名称,缺省的时候,gcc 编译出来的文件是a.out,很难听,如果你和我有同感
,改掉它,哈哈
  例子用法
  gcc -o hello.exe hello.c (哦,windows用习惯了)
  gcc -o hello.asm -S hello.c
-pipe
  使用管道代替编译中临时文件,在使用非gnu汇编工具的时候,可能有些问题
  gcc -pipe -o hello.exe hello.c
-ansi
  关闭gnu c中与ansi c不兼容的特性,激活ansi c的专有特性(包括禁止一些asm inl
ine typeof关键字,以及UNIX,vax等预处理宏,
-fno-asm
  此选项实现ansi选项的功能的一部分,它禁止将asm,inline和typeof用作关键字。
    
-fno-strict-prototype
  只对g++起作用,使用这个选项,g++将对不带参数的函数,都认为是没有显式的对参数
的个数和类型说明,而不是没有参数.
  而gcc无论是否使用这个参数,都将对没有带参数的函数,认为城没有显式说明的类型

  
-fthis-is-varialble
  就是向传统c++看齐,可以使用this当一般变量使用.
  
-fcond-mismatch
  允许条件表达式的第二和第三参数类型不匹配,表达式的值将为void类型
  
-funsigned-char
-fno-signed-char
-fsigned-char
-fno-unsigned-char
  这四个参数是对char类型进行设置,决定将char类型设置成unsigned char(前两个参
数)或者 signed char(后两个参数)
  
-include file
  包含某个代码,简单来说,就是便以某个文件,需要另一个文件的时候,就可以用它设
定,功能就相当于在代码中使用#include<filename>
  例子用法:
  gcc hello.c -include /root/pianopan.h
  
-imacros file
  将file文件的宏,扩展到gcc/g++的输入文件,宏定义本身并不出现在输入文件中
  
-Dmacro
  相当于C语言中的#define macro
  
-Dmacro=defn
  相当于C语言中的#define macro=defn
  
-Umacro
  相当于C语言中的#undef macro
-undef
  取消对任何非标准宏的定义
  
-Idir
  在你是用#include"file"的时候,gcc/g++会先在当前目录查找你所制定的头文件,如
果没有找到,他回到缺省的头文件目录找,如果使用-I制定了目录,他
  回先在你所制定的目录查找,然后再按常规的顺序去找.
  对于#include<file>,gcc/g++会到-I制定的目录查找,查找不到,然后将到系统的缺
省的头文件目录查找
  
-I-
  就是取消前一个参数的功能,所以一般在-Idir之后使用
  
-idirafter dir
  在-I的目录里面查找失败,讲到这个目录里面查找.
  
-iprefix prefix
-iwithprefix dir
  一般一起使用,当-I的目录查找失败,会到prefix+dir下查找
  
-nostdinc
  使编译器不再系统缺省的头文件目录里面找头文件,一般和-I联合使用,明确限定头
文件的位置
  
-nostdin C++
  规定不在g++指定的标准路经中搜索,但仍在其他路径中搜索,.此选项在创libg++库
使用
  
-C
  在预处理的时候,不删除注释信息,一般和-E使用,有时候分析程序,用这个很方便的

  
-M
  生成文件关联的信息。包含目标文件所依赖的所有源代码你可以用gcc -M hello.c
来测试一下,很简单。
  
-MM
  和上面的那个一样,但是它将忽略由#include<file>造成的依赖关系。
  
-MD
  和-M相同,但是输出将导入到.d的文件里面
  
-MMD
  和-MM相同,但是输出将导入到.d的文件里面
  
-Wa,option
  此选项传递option给汇编程序;如果option中间有逗号,就将option分成多个选项,然
后传递给会汇编程序
  
-Wl.option
  此选项传递option给连接程序;如果option中间有逗号,就将option分成多个选项,然
后传递给会连接程序.
  
-llibrary
  制定编译的时候使用的库
  例子用法
  gcc -lcurses hello.c
  使用ncurses库编译程序
  
-Ldir
  制定编译的时候,搜索库的路径。比如你自己的库,可以用它制定目录,不然
  编译器将只在标准库的目录找。这个dir就是目录的名称。
  
-O0
-O1
-O2
-O3
  编译器的优化选项的4个级别,-O0表示没有优化,-O1为缺省值,-O3优化级别最高 
    
-g
  只是编译器,在编译的时候,产生调试信息。
  
-gstabs
  此选项以stabs格式声称调试信息,但是不包括gdb调试信息.
  
-gstabs+
  此选项以stabs格式声称调试信息,并且包含仅供gdb使用的额外调试信息.
  
-ggdb
  此选项将尽可能的生成gdb的可以使用的调试信息.
-static
  此选项将禁止使用动态库,所以,编译出来的东西,一般都很大,也不需要什么
动态连接库,就可以运行.
-share
  此选项将尽量使用动态库,所以生成文件比较小,但是需要系统由动态库.
-traditional
  试图让编译器支持传统的C语言特性
[参考资料]
-Linux/UNIX高级编程
  中科红旗软件技术有限公司编著.清华大学出版社出版
-Gcc man page
  
[ChangeLog]
-2002-08-10
  ver 0.1 发布最初的文档
-2002-08-11
  ver 0.11 修改文档格式
-2002-08-12
  ver 0.12 加入了对静态库,动态库的参数
-2002-08-16
  ver 0.16 增加了gcc编译的4个阶段的命令
运行 gcc/egcs
**********运行 gcc/egcs***********************
  GCC 是 GNU 的 C 和 C++ 编译器。实际上,GCC 能够编译三种语言:C、C++ 和 O
bject C(C 语言的一种面向对象扩展)。利用 gcc 命令可同时编译并连接 C 和 C++
源程序。
  如果你有两个或少数几个 C 源文件,也可以方便地利用 GCC 编译、连接并生成可
执行文件。例如,假设你有两个源文件 main.c 和 factorial.c 两个源文件,现在要编
译生成一个计算阶乘的程序。
代码:
-----------------------
清单 factorial.c
-----------------------
int factorial (int n)
{
  if (n <= 1)
   return 1;
  else
   return factorial (n - 1) * n;
}
-----------------------
清单 main.c
-----------------------
#include <stdio.h>
#include <unistd.h>
int factorial (int n);
int main (int argc, char **argv)
{
  int n;
  if (argc < 2)
  {
    printf ("Usage: %s n\n", argv [0]);
    return -1;
  }
  else
  {
   n = atoi (argv[1]);
   printf ("Factorial of %d is %d.\n", n, factorial (n));
   }
  return 0;
}
-----------------------
利用如下的命令可编译生成可执行文件,并执行程序:
$ gcc -o factorial main.c factorial.c
$ ./factorial 5
Factorial of 5 is 120.
  GCC 可同时用来编译 C 程序和 C++ 程序。一般来说,C 编译器通过源文件的后缀
名来判断是 C 程序还是 C++ 程序。在 Linux 中,C 源文件的后缀名为 .c,而 C++ 源
文件的后缀名为 .C 或 .cpp。但是,gcc 命令只能编译 C++ 源文件,而不能自动和 C
++ 程序使用的库连接。因此,通常使用 g++ 命令来完成 C++ 程序的编译和连接,该程
序会自动调用 gcc 实现编译。假设我们有一个如下的 C++ 源文件(hello.C):
#include <iostream>
void main (void)
{
  cout << "Hello, world!" << endl;
}
则可以如下调用 g++ 命令编译、连接并生成可执行文件:
$ g++ -o hello hello.C
$ ./hello
Hello, world!
**********************gcc/egcs 的主要选项*********
gcc 命令的常用选项
选项 解释
-ansi 只支持 ANSI 标准的 C 语法。这一选项将禁止 GNU C 的某些特色,
例如 asm 或 typeof 关键词。
-c 只编译并生成目标文件。
-DMACRO 以字符串“1”定义 MACRO 宏。
-DMACRO=DEFN 以字符串“DEFN”定义 MACRO 宏。
-E 只运行 C 预编译器。
-g 生成调试信息。GNU 调试器可利用该信息。
-IDIRECTORY 指定额外的头文件搜索路径DIRECTORY。
-LDIRECTORY 指定额外的函数库搜索路径DIRECTORY。
-lLIBRARY 连接时搜索指定的函数库LIBRARY。
-m486 针对 486 进行代码优化。
-o FILE 生成指定的输出文件。用在生成可执行文件时。
-O0 不进行优化处理。
-O 或 -O1 优化生成代码。
-O2 进一步优化。
-O3 比 -O2 更进一步优化,包括 inline 函数。
-shared 生成共享目标文件。通常用在建立共享库时。
-static 禁止使用共享连接。
-UMACRO 取消对 MACRO 宏的定义。
-w 不生成任何警告信息。
-Wall 生成所有警告信息。
posted @ 2005-11-30 13:36 味全每日C++ 阅读(75169) | 评论 (3)编辑 收藏


Author:sungo
(TW@Javaworld)  文章原文:http://www.javaworld.com.tw/jute/post/view?bid=10&id=53262&sty=1&tpg=1&age=0

Eclipse除了可以開發Java之外,還支援了許多語言,現在先介紹
C、C++的開發環境設定,以後有機會再介紹其它的。Enjoy it!

OS:Windows XP Professional SP1
使用版本:Eclipse 2.1.2

一.首先要下載CDT,Eclipse 2.1.2使用者,請下載這項:
CDT 1.2 Full for Windows R2.1.1 1.2.0 GA - Full - Windows。
Eclipse 2.1.3使用者請下載:CDT 1.2.1。
Eclipse 3.0 M7使用者請下載:CDT 2.0 M7。
Eclipse 3.0 M8使用者請下載:CDT 2.0 M8。
Eclipse 3.0 M9使用者請下載:CDT 2.0 M9。
下載網址:
http://www.eclipse.org/cdt/

安裝:將解壓縮後的features、plugins整個資料夾複製到Eclipse安裝資料
裡,重新開啟Eclipse即可。

二.下載可在Windows上使用的GNU C、C++編譯器,這裡要下載的是:MinGW。
Download頁面很長的一串,請選擇這個版本:
MinGW bin MinGW-3.1.0-1.exe 14863 kb Sep 15, 2003 11:14
下載網址:
http://www.mingw.org/download.shtml

安裝:安裝目錄選C槽,然後狂點下一步(Next)就行了。安裝完後路徑是這
樣->C:\MinGW。

三.先在Command Line模式下測試編譯與執行。先將C:\MinGW\bin底下的
mingw32-make.exe更名為make.exe,因為待會在Eclipse使用時它預設
會抓系統裡make這個檔名而不是mingw32-make。

(註:如果不更名或是還有其他make程式時,也可以在稍後的Eclipse設定
中,在make targets view的地方,新增一個task時,build command 取消
use default , 使用 mingw32-make,或在project properties->make project ->
將make 改為 mingw32-make )
-- 由 snpshu 補充。

在環境變數裡加入下列設定:
PATH : C:\MinGW\bin; (如果系統已經有裝其它C/C++編譯器,請把C:\MinGW\bin加在最前面。)
LIBRARY_PATH :C:\MinGW\lib
C_INCLUDE_PATH :C:\MinGW\include
CPLUS_INCLUDE_PATH :C:\MinGW\include\c++\3.2.3;C:\MinGW\include\c++\3.2.3\mingw32;
C:\MinGW\include\c++\3.2.3\backward;C:\MinGW\include

先使用文字編輯器編寫測試用的原始檔,檔名:main.cpp。
1
2
3
4
5
6
7
8
#include <iostream>
using namespace std;
 
int main(void) {
    cout << "Can You Feel My World?" ;
 
    return 0;
}

在Command Line下編譯指令:
1
C:\g++ main.cpp -O3 -o hello

(O3的O是英文大寫"歐")
編譯成功後:便會產生hello.exe的執行檔。
執行畫面如下:
1
2
3
4
5
6
7
8
9
10
Microsoft Windows XP [版本 5.1.2600]
(C) Copyright 1985-2001 Microsoft Corp.
 
C:\Documents and Settings\Sungo>cd\
 
C:\>g++ main.cpp -O3 -o hello
 
C:\>hello
Can You Feel My World?
C:\>

註:-O3 旗標表示採最高級編譯最佳化,編譯速度最慢,但產生的執行檔
檔案會最小,執行速度會最快;-o 旗標表示將編譯完的*.exe重新更名。

◎步驟一.開啟Eclipse後,首先先開啟C/C++專用視景。
Windows->Open Perspective->C/C++ Development

◎步驟二.建立一個C++用的專案。
File-New->Project->C++->Standard Make C++ Project
(接下來的步驟跟建立一般的Java專案一樣,皆採預設即可)

◎步驟三.把我們剛剛寫的main.cpp import進來,加到專案裡。
File->Import->File System->瀏覽C:\main.cpp

◎步驟四.建立一個makefile。
File->New->File,檔案名稱填:makefile。(不需打副檔名)

makefile內容如下:
1
2
all:
    g++  main.cpp -g -o run

注意:makefile縮排要以Tab鍵作縮排,不能以空格4作縮排,
否則Build會有問題。


◎步驟五.設定Make Targets。
Windows-Show View->Make Targets
在Make Targets視窗裡按滑鼠右鍵,Add Build Target
,name打:編譯。Build Target打:all。

◎步驟六.編譯。
在剛剛建立的Make Targets "編譯" 上點滑鼠2下,即會開始編譯,
此時我們可以發現hello.exe已經產生在我們專案下了。可在底下
C-Build視窗看到以下輸出結果:
1
2
make -k all 
g++  main.cpp -g -o run


◎步驟七. *.exe執行前設定。因為在Windows下Run,所以要先作個設定
,請開啟Project->Properties->C/C++ Make Project->Binary Parser頁面。
Binary Parser下拉式選單,將ELF Parser改成PE Windows Parser。

◎步驟八.執行。
Run->Run as->C Local Application。
在底下Consloe視窗看到hello.exe的執行結果。

註:當原始檔有修改,要重新編譯時,只要滑鼠雙擊我們在步驟五
所建立的Make Targets "編譯",即可Rebuilding。

posted @ 2005-11-30 12:57 味全每日C++ 阅读(1486) | 评论 (0)编辑 收藏

2005年11月23日 #

预处理器(Preprocessor)


1. 用预处理指令#define 声明一个常数,用以表明1年中有多少秒(忽略闰年问题)

#define SECONDS_PER_YEAR (60 * 60 * 24 * 365)UL
我在这想看到几件事情:
1). #define 语法的基本知识(例如:不能以分号结束,括号的使用,等等)
2). 懂得预处理器将为你计算常数表达式的值,因此,直接写出你是如何计算一年中有多少秒而不是计算出实际的值,是更清晰而没有代价的。
3). 意识到这个表达式将使一个16位机的整型数溢出-因此要用到长整型符号L,告诉编译器这个常数是的长整型数。
4). 如果你在你的表达式中用到UL(表示无符号长整型),那么你有了一个好的起点。记住,第一印象很重要。


2. 写一个“标准”宏MIN,这个宏输入两个参数并返回较小的一个。

#define MIN(A,B) ((A) <= (B) (A) : (B))
这个测试是为下面的目的而设的:
1). 标识#define在宏中应用的基本知识。这是很重要的,因为直到嵌入(inline)操作符变为标准C的一部分,宏是方便产生嵌入代码的唯一方法,对于嵌入式系统来说,为了能达到要求的性能,嵌入代码经常是必须的方法。
2). 三重条件操作符的知识。这个操作符存在C语言中的原因是它使得编译器能产生比if-then-else更优化的代码,了解这个用法是很重要的。
3). 懂得在宏中小心地把参数用括号括起来
4). 我也用这个问题开始讨论宏的副作用,例如:当你写下面的代码时会发生什么事?
least = MIN(*p++, b);


3. 预处理器标识#error的目的是什么?

如果你不知道答案,请看参考文献1。这问题对区分一个正常的伙计和一个书呆子是很有用的。只有书呆子才会读C语言课本的附录去找出象这种
问题的答案。当然如果你不是在找一个书呆子,那么应试者最好希望自己不要知道答案。


死循环(Infinite loops)


4. 嵌入式系统中经常要用到无限循环,你怎么样用C编写死循环呢?

这个问题用几个解决方案。我首选的方案是:
while(1) { }
一些程序员更喜欢如下方案:
for(;;) { }
这个实现方式让我为难,因为这个语法没有确切表达到底怎么回事。如果一个应试者给出这个作为方案,我将用这个作为一个机会去探究他们这样做的
基本原理。如果他们的基本答案是:“我被教着这样做,但从没有想到过为什么。”这会给我留下一个坏印象。
第三个方案是用 goto
Loop:
...
goto Loop;
应试者如给出上面的方案,这说明或者他是一个汇编语言程序员(这也许是好事)或者他是一个想进入新领域的BASIC/FORTRAN程序员。

数据声明(Data declarations)

5. 用变量a给出下面的定义
a) 一个整型数(An integer)
b) 一个指向整型数的指针(A pointer to an integer)
c) 一个指向指针的的指针,它指向的指针是指向一个整型数(A pointer to a pointer to an integer)
d) 一个有10个整型数的数组(An array of 10 integers)
e) 一个有10个指针的数组,该指针是指向一个整型数的(An array of 10 pointers to integers)
f) 一个指向有10个整型数数组的指针(A pointer to an array of 10 integers)
g) 一个指向函数的指针,该函数有一个整型参数并返回一个整型数(A pointer to a function that takes an integer as an argument and returns an integer)
h) 一个有10个指针的数组,该指针指向一个函数,该函数有一个整型参数并返回一个整型数( An array of ten pointers to functions that take an integer argument and return an integer )

答案是:
a) int a; // An integer
b) int *a; // A pointer to an integer
c) int **a; // A pointer to a pointer to an integer
d) int a[10]; // An array of 10 integers
e) int *a[10]; // An array of 10 pointers to integers
f) int (*a)[10]; // A pointer to an array of 10 integers
g) int (*a)(int); // A pointer to a function a that takes an integer argument and returns an integer
h) int (*a[10])(int); // An array of 10 pointers to functions that take an integer argument and return an integer


人们经常声称这里有几个问题是那种要翻一下书才能回答的问题,我同意这种说法。当我写这篇文章时,为了确定语法的正确性,我的确查了一下书。
但是当我被面试的时候,我期望被问到这个问题(或者相近的问题)。因为在被面试的这段时间里,我确定我知道这个问题的答案。应试者如果不知道
所有的答案(或至少大部分答案),那么也就没有为这次面试做准备,如果该面试者没有为这次面试做准备,那么他又能为什么出准备呢?


Static

6. 关键字static的作用是什么?

这个简单的问题很少有人能回答完全。在C语言中,关键字static有三个明显的作用:
1). 在函数体,一个被声明为静态的变量在这一函数被调用过程中维持其值不变。
2). 在模块内(但在函数体外),一个被声明为静态的变量可以被模块内所用函数访问,但不能被模块外其它函数访问。它是一个本地的全局变量。
3). 在模块内,一个被声明为静态的函数只可被这一模块内的其它函数调用。那就是,这个函数被限制在声明它的模块的本地范围内使用。
大多数应试者能正确回答第一部分,一部分能正确回答第二部分,同是很少的人能懂得第三部分。这是一个应试者的严重的缺点,因为他显然不懂得本地化数据和代码范围的好处和重要性。


Const

7.关键字const是什么含意?
我只要一听到被面试者说:“const意味着常数”,我就知道我正在和一个业余者打交道。去年Dan Saks已经在他的文章里完全概括了const的所有用法,因此ESP(译者:Embedded Systems Programming)的每一位读者应该非常熟悉const能做什么和不能做什么.如果你从没有读到那篇文章,只要能说出const意味着“只读”就可以了。尽管这个答案不是完全的答案,但我接受它作为一个正确的答案。(如果你想知道更详细的答案,仔细读一下Saks的文章吧。)如果应试者能正确回答这个问题,我将问他一个附加的问题:下面的声明都是什么意思?

const int a;
int const a;
const int *a;
int * const a;
int const * a const;

前两个的作用是一样,a是一个常整型数。第三个意味着a是一个指向常整型数的指针(也就是,整型数是不可修改的,但指针可以)。第四个意思a是一个指向整型数的常指针(也就是说,指针指向的整型数是可以修改的,但指针是不可修改的)。最后一个意味着a是一个指向常整型数的常指针(也就是说,指针指向的整型数是不可修改的,同时指针也是不可修改的)。如果应试者能正确回答这些问题,那么他就给我留下了一个好印象。顺带提一句,也许你可能会问,即使不用关键字const,也还是能很容易写出功能正确的程序,那么我为什么还要如此看重关键字const呢?我也如下的几下理由:
1). 关键字const的作用是为给读你代码的人传达非常有用的信息,实际上,声明一个参数为常量是为了告诉了用户这个参数的应用目的。如果你曾花很多时间清理其它人留下的垃圾,你就会很快学会感谢这点多余的信息。(当然,懂得用const的程序员很少会留下的垃圾让别人来清理的。)
2). 通过给优化器一些附加的信息,使用关键字const也许能产生更紧凑的代码。
3). 合理地使用关键字const可以使编译器很自然地保护那些不希望被改变的参数,防止其被无意的代码修改。简而言之,这样可以减少bug的出现。

Volatile

8. 关键字volatile有什么含意 并给出三个不同的例子。

一个定义为volatile的变量是说这变量可能会被意想不到地改变,这样,编译器就不会去假设这个变量的值了。精确地说就是,优化器在用到这个变量时必须每次都小心地重新读取这个变量的值,而不是使用保存在寄存器里的备份。下面是volatile变量的几个例子:
1). 并行设备的硬件寄存器(如:状态寄存器)
2). 一个中断服务子程序中会访问到的非自动变量(Non-automatic variables)
3). 多线程应用中被几个任务共享的变量
回答不出这个问题的人是不会被雇佣的。我认为这是区分C程序员和嵌入式系统程序员的最基本的问题。嵌入式系统程序员经常同硬件、中断、RTOS等等打交道,所用这些都要求volatile变量。不懂得volatile内容将会带来灾难。
假设被面试者正确地回答了这是问题(嗯,怀疑这否会是这样),我将稍微深究一下,看一下这家伙是不是直正懂得volatile完全的重要性。
1). 一个参数既可以是const还可以是volatile吗?解释为什么。
2). 一个指针可以是volatile 吗?解释为什么。
3). 下面的函数有什么错误:
int square(volatile int *ptr)
{
return *ptr * *ptr;
}
下面是答案:
1). 是的。一个例子是只读的状态寄存器。它是volatile因为它可能被意想不到地改变。它是const因为程序不应该试图去修改它。
2). 是的。尽管这并不很常见。一个例子是当一个中服务子程序修该一个指向一个buffer的指针时。
3). 这段代码的有个恶作剧。这段代码的目的是用来返指针*ptr指向值的平方,但是,由于*ptr指向一个volatile型参数,编译器将产生类似下面的代码:
int square(volatile int *ptr)
{
int a,b;
a = *ptr;
b = *ptr;
return a * b;
}
由于*ptr的值可能被意想不到地该变,因此a和b可能是不同的。结果,这段代码可能返不是你所期望的平方值!正确的代码如下:
long square(volatile int *ptr)
{
int a;
a = *ptr;
return a * a;
}

位操作(Bit manipulation)

9. 嵌入式系统总是要用户对变量或寄存器进行位操作。给定一个整型变量a,写两段代码,第一个设置a的bit 3,第二个清除a 的bit 3。在以上两个操作中,要保持其它位不变。

对这个问题有三种基本的反应
1). 不知道如何下手。该被面者从没做过任何嵌入式系统的工作。
2). 用bit fields。Bit fields是被扔到C语言死角的东西,它保证你的代码在不同编译器之间是不可移植的,同时也保证了的你的代码是不可重用的。我最近不幸看到Infineon为其较复杂的通信芯片写的驱动程序,它用到了bit fields因此完全对我无用,因为我的编译器用其它的方式来实现bit fields的。从道德讲:永远不要让一个非嵌入式的家伙粘实际硬件的边。
3). 用 #defines 和 bit masks 操作。这是一个有极高可移植性的方法,是应该被用到的方法。最佳的解决方案如下:
#define BIT3 (0x1<<3)
static int a;
void set_bit3(void)
{
a |= BIT3;
}
void clear_bit3(void)
{
a &= ~BIT3;
}
一些人喜欢为设置和清除值而定义一个掩码同时定义一些说明常数,这也是可以接受的。我希望看到几个要点:说明常数、|=和&=~操作。

访问固定的内存位置(Accessing fixed memory locations)

10. 嵌入式系统经常具有要求程序员去访问某特定的内存位置的特点。在某工程中,要求设置一绝对地址为0x67a9的整型变量的值为0xaa66。编译器是一个纯粹的ANSI编译器。写代码去完成这一任务。

这一问题测试你是否知道为了访问一绝对地址把一个整型数强制转换(typecast)为一指针是合法的。这一问题的实现方式随着个人风格不同而不同。典型的类似代码如下:
int *ptr;
ptr = (int *)0x67a9;
*ptr = 0xaa55;

一个较晦涩的方法是:
*(int * const)(0x67a9) = 0xaa55;

即使你的品味更接近第二种方案,但我建议你在面试时使用第一种方案。

中断(Interrupts)

11. 中断是嵌入式系统中重要的组成部分,这导致了很多编译开发商提供一种扩展—让标准C支持中断。具代表事实是,产生了一个新的关键字__interrupt。下面的代码就使用了__interrupt关键字去定义了一个中断服务子程序(ISR),请评论一下这段代码的。

__interrupt double compute_area (double radius)
{
    double area = PI * radius * radius;
    printf(" Area = %f", area);
    return area;
}

这个函数有太多的错误了,以至让人不知从何说起了:
1). ISR 不能返回一个值。如果你不懂这个,那么你不会被雇用的。
2). ISR 不能传递参数。如果你没有看到这一点,你被雇用的机会等同第一项。
3). 在许多的处理器/编译器中,浮点一般都是不可重入的。有些处理器/编译器需要让额处的寄存器入栈,有些处理器/编译器就是不允许在ISR中做浮点运算。此外,ISR应该是短而有效率的,在ISR中做浮点运算是不明智的。
4). 与第三点一脉相承,printf()经常有重入和性能上的问题。如果你丢掉了第三和第四点,我不会太为难你的。不用说,如果你能得到后两点,那么你的被雇用前景越来越光明了。

代码例子(Code examples)
12 . 下面的代码输出是什么,为什么?

void foo(void)
{
    unsigned int a = 6;
    int b = -20;
    (a+b > 6) puts("> 6") : puts("<= 6");
}

这个问题测试你是否懂得C语言中的整数自动转换原则,我发现有些开发者懂得极少这些东西。不管如何,这无符号整型问题的答案是输出是“>6”。原因是当表达式中存在有符号类型和无符号类型时所有的操作数都自动转换为无符号类型。 因此-20变成了一个非常大的正整数,所以该表达式计算出的结果大于6。这一点对于应当频繁用到无符号数据类型的嵌入式系统来说是丰常重要的。如果你答错了这个问题,你也就到了得不到这份工作的边缘。

13. 评价下面的代码片断:

unsigned int zero = 0;
unsigned int compzero = 0xFFFF;
/*1's complement of zero */

对于一个int型不是16位的处理器为说,上面的代码是不正确的。应编写如下:

unsigned int compzero = ~0;

这一问题真正能揭露出应试者是否懂得处理器字长的重要性。在我的经验里,好的嵌入式程序员非常准确地明白硬件的细节和它的局限,然而PC机程序往往把硬件作为一个无法避免的烦恼。
到了这个阶段,应试者或者完全垂头丧气了或者信心满满志在必得。如果显然应试者不是很好,那么这个测试就在这里结束了。但如果显然应试者做得不错,那么我就扔出下面的追加问题,这些问题是比较难的,我想仅仅非常优秀的应试者能做得不错。提出这些问题,我希望更多看到应试者应付问题的方法,而不是答案。不管如何,你就当是这个娱乐吧…



动态内存分配(Dynamic memory allocation)



14. 尽管不像非嵌入式计算机那么常见,嵌入式系统还是有从堆(heap)中动态分配内存的过程的。那么嵌入式系统中,动态分配内存可能发生的问题是什么?

这里,我期望应试者能提到内存碎片,碎片收集的问题,变量的持行时间等等。这个主题已经在ESP杂志中被广泛地讨论过了(主要是 P.J. Plauger, 他的解释远远超过我这里能提到的任何解释),所有回过头看一下这些杂志吧!让应试者进入一种虚假的安全感觉后,我拿出这么一个小节目:下面的代码片段的输出是什么,为什么?

char *ptr;
if ((ptr = (char *)malloc(0)) == NULL)
puts("Got a null pointer");
else
puts("Got a valid pointer");

这是一个有趣的问题。最近在我的一个同事不经意把0值传给了函数malloc,得到了一个合法的指针之后,我才想到这个问题。这就是上面的代码,该代码的输出是“Got a valid pointer”。我用这个来开始讨论这样的一问题,看看被面试者是否想到库例程这样做是正确。得到正确的答案固然重要,但解决问题的方法和你做决定的基本原理更重要些。

Typedef

15. Typedef 在C语言中频繁用以声明一个已经存在的数据类型的同义字。也可以用预处理器做类似的事。例如,思考一下下面的例子:
#define dPS struct s *
typedef struct s * tPS;

以上两种情况的意图都是要定义dPS 和 tPS 作为一个指向结构s指针。哪种方法更好呢?(如果有的话)为什么?
这是一个非常微妙的问题,任何人答对这个问题(正当的原因)是应当被恭喜的。答案是:typedef更好。思考下面的例子:
dPS p1,p2;
tPS p3,p4;

第一个扩展为
struct s * p1, p2;

上面的代码定义p1为一个指向结构的指,p2为一个实际的结构,这也许不是你想要的。第二个例子正确地定义了p3 和p4 两个指针。

晦涩的语法

16. C语言同意一些令人震惊的结构,下面的结构是合法的吗,如果是它做些什么?
int a = 5, b = 7, c;
c = a+++b;

这个问题将做为这个测验的一个愉快的结尾。不管你相不相信,上面的例子是完全合乎语法的。问题是编译器如何处理它?水平不高的编译作者实际上会争论这个问题,根据最处理原则,编译器应当能处理尽可能所有合法的用法。因此,上面的代码被处理成:
c = a++ + b;
因此, 这段代码持行后a = 6, b = 7, c = 12。
如果你知道答案,或猜出正确答案,做得好。如果你不知道答案,我也不把这个当作问题。我发现这个问题的最大好处是:这是一个关于代码编写风格,代码的可读性,代码的可修改性的好的话题

posted @ 2005-11-23 20:25 味全每日C++ 阅读(9769) | 评论 (3)编辑 收藏

2005年11月22日 #

地址:http://www.topcoder.com/pl/?module=Static&d1=gccj05&d2=ZH_overview

Google™ Code Jam - 中国编程挑战赛

English Version
 
重要日期

报名开始
11月21日星期一

入围赛
12月12日星期一

总决赛
1月20日星期五
 
价值25万元的
高科技奖品


你有用技术改变世界的梦想吗?你有挑战难度的决心吗?你想和国内计算机精英一决高下吗?全球编程界知名的“Google编程挑战赛Code Jam”即将登陆中国。这项比赛每年都是全球计算机界的一次盛事。今年 Google 首次专门为中国举办这项比赛,旨在弘扬计算机科学的艺术,推进中国计算机编程教育,鼓励并嘉奖中国顶级编程人才。

竞赛的题目具有相当的挑战性,竞赛奖品也非常丰厚。 有志之士可借此机会一展才能,成为脱颖而出的中国最佳。

这里有极富挑战性的题目,高科技的奖品,以及令人赞叹的荣耀,你还在等什么?

赛事运作细则

此次挑战赛以计时赛的形式举行,所有的参赛者都将在限定的时间内在线完成相同的竞赛题目。

参赛者在竞赛过程当中,可以选用以下4种编程语言的一种-Java,C++,C#和VB。

以下是竞赛相关过程说明:

下载竞赛平台
参赛者将从TopCoder®公司的竞赛平台(一个Java程序)开始踏入竞赛的第一步。下载平台程序,仔细阅读竞赛题目,然后将解决方案编写成代码形式,编译并测试方案,最后提交方案代码,得到相应的分数。参赛者可以在正式竞赛前下载竞赛平台,通过提供的样例来体验和熟悉平台的操作环境。

编码阶段
在指定的日期和时间,参赛者进入竞赛平台,以每10人一组被安排进入相应的虚拟房间。所有参赛者都将获得相同的3道竞赛题,3题的难度递增。此阶段竞赛中,竞赛者须在最短时间内完成题目,提供正确的方案代码,代码提交得越早,竞赛者得到的分数越高。在竞赛的整个过程中,排名榜会显示竞赛者的累计分数。

挑战阶段
在挑战阶段,参赛者不但可以看到其他参赛者提交的方案代码,还可以给出测试数据,使其他参赛者提交的程序得到错误的运算结果,从而推翻其他参赛者所提交的方案。这种方式,对于编程人员来说是最直接的竞赛形式。在这个阶段,参赛者的测试数据若能成功推翻他人提交的代码则可得分;反之,将被扣分。

系统测试
在系统测试阶段,系统会自动对每个提交方案代码进行测试,确定其正确程度和可行性,并以此给出参赛者相应的分数。整个评测过程耗时很短,参赛者当场可以知道自己的比赛结果。

参赛须知

报名注册时间:从北京时间2005年11月21日星期一上午9时开始,至北京时间2005年12月12日上午9时结束。报名注册没有人数限制,但是只有通过资格赛的前500名(12月12日举行)可以晋级此次正式比赛的第一轮。第一轮比赛将在12月19日举行。

首轮名次前250名将于12月22日晋级第二轮,第二轮的前50名则将参加在中国举行的冠军赛,争夺总数达25万元的高额奖品。

日期 时间 * 状态
11月21日星期一 9:00 注册开始
12月12日星期一 9:00 注册结束
12月12日星期一 12:00 资格赛开始
12月13日星期二 12:00 资格赛结束
12月19日星期一 21:00 第一轮-500名参赛者
12月22日星期四 21:00 第二轮-250名参赛者
1月20日星期五 待定 冠军赛-50名参赛者
* 上述时间皆为北京时间。冠军赛日期有可能发生变化,请注意届时通知。


奖品

晋级第二轮的250名参赛者将获赠"Google™ Code Jam - 中国编程挑战赛"T恤一件和李开复博士撰写并签名的《做最好的自己》一书。晋级冠军赛的50名参赛者将获得如下的奖项:

参赛者 奖品
第1名 (共价值40,000人民币) 一组高端个人编程工作站
第2至第4名 (每位奖品价值20,000人民币) 一台笔记本电脑, PDA手机, 以及一款全新个人随身听
第5至10名(每位奖品价值8,000人民币) 一台数字相机,PDA手机, 以及一款全新个人随身听
第11至20名(每位奖品价值4,000人民币) PDA手机, 以及一款全新个人随身听
第21至50名 (每位奖品价值2,000人民币) 一款全新个人随身听
posted @ 2005-11-22 14:57 味全每日C++ 阅读(850) | 评论 (0)编辑 收藏

2005年11月21日 #

Introduction   http://www.codeproject.com/cpp/bitbashing.asp

I have noticed that some people seem to have problems with bitwise operators, so I decided to write this brief tutorial on how to use them.

An Introduction to bits

Bits, what are they you may ask?

Well, simply put, bits are the individual ones and zeros that make up every thing we do with computers. All the data you use is stored in your computer using bits. A BYTE is made up of eight bits, a WORD is two BYTEs, or sixteen bits. And a DWORD is two WORDS, or thirty two bits.

 0 1 0 0 0 1 1 1 1 0 0 0 0 1 1 1 0 1 1 1 0 1 0 0 0 1 1 1 1 0 0 0
||                  |                   |                    |                  ||
|+- bit 31       |                    |                    |         bit 0 -+|
|                   |                    |                    |                   |
+-- BYTE 3 ---+--- BYTE 2 ---+--- BYTE 1 ---+-- BYTE 0 ---+
|                                        |                                         |
+----------- WORD 1 --------+----------- WORD 0 ---------+
|                                                                                  |
+--------------------------- DWORD -----------------------+

The beauty of having bitwise operators is that you can use a BYTE, WORD or DWORD as a small array or structure. Using bitwise operators you can check or set the values of individual bits or even a group of bits.

Hexadecimal numbers and how they relate to bits

When working with bits, it is kind of hard to express every number using just ones and zeros, which is known as binary notation. To get around this we use hexadecimal (base 16) numbers.

As you may or may not know, it takes four bits to cover all the numbers from zero to fifteen, which also happens to be the range of a single digit hexadecimal number. This group of four bits, or half a BYTE, is called a nibble. As there are two nibbles in a BYTE, we can use two hexadecimal digits to show the value of one BYTE.

NIBBLE   HEX VALUE
======   =========
 0000        0
 0001        1
 0010        2
 0011        3
 0100        4
 0101        5
 0110        6
 0111        7
 1000        8
 1001        9
 1010        A
 1011        B
 1100        C
 1101        D
 1110        E
 1111        F

So if we had one BYTE containing the letter 'r' (ASCII code 114) it would look like this:

0111 0010    binary
  7    2     hexadecimal

We could write it as '0x72'

Bitwise operators

There are six bitwise operators. They are:
   &   The AND operator
   |   The OR operator
   ^   The XOR operator
   ~   The Ones Complement or Inversion operator
  >>   The Right Shift operator
  <<   The Left Shift operator.

The & operator

The & (AND) operator compares two values, and returns a value that has its bits set if, and only if, the two values being compared both have their corresponding bits set. The bits are compared using the following table

   1   &   1   ==   1
   1   &   0   ==   0
   0   &   1   ==   0
   0   &   0   ==   0

An ideal use for this is to set up a mask to check the values of certain bits. Say we have a BYTE that contains some bit flags, and we want to check if bit four bit is set.

BYTE b = 50;
if ( b & 0x10 )
    cout << "Bit four is set" << endl;
else
    cout << "Bit four is clear" << endl;

This would result in the following calculation

    00110010  - b
 & 00010000  - & 0x10
  ----------
    00010000  - result

So we see that bit four is set.

The | operator

The | (OR) operator compares two values, and returns a value that has its bits set if one or the other values, or both, have their corresponding bits set. The bits are compared using the following table

   1   |   1   ==   1
   1   |   0   ==   1
   0   |   1   ==   1
   0   |   0   ==   0

An ideal use for this is to ensure that certain bits are set. Say we want to ensure that bit three of some value is set

BYTE b = 50;
BYTE c = b | 0x04;
cout << "c = " << c << endl;

This would result in the following calculation

    00110010  - b
  | 00000100  - | 0x04
  ----------
    00110110  - result

The ^ operator

The ^ (XOR) operator compares two values, and returns a value that has its bits set if one or the other value has its corresponding bits set, but not both. The bits are compared using the following table

   1   ^   1   ==   0
   1   ^   0   ==   1
   0   ^   1   ==   1
   0   ^   0   ==   0

An ideal use for this is to toggle certain bits. Say we want toggle the bits three and four

BYTE b = 50;
cout << "b = " << b << endl;
b = b ^ 0x18;
cout << "b = " << b << endl;
b = b ^ 0x18;
cout << "b = " << b << endl;

This would result in the following calculations

    00110010  - b
 ^ 00011000  - ^ 0x18
  ----------
    00101010  - result

    00101010  - b
^ 00011000 - ^ 0x18 ---------- 00110010 - result

The ~ operator

The ~ (Ones Complement or inversion) operator acts only on one value and it inverts it, turning all the ones int zeros, and all the zeros into ones. An ideal use of this would be to set certain bytes to zero, and ensuring all other bytes are set to one, regardless of the size of the data. Say we want to set all the bits to one except bits zero and one

BYTE b = ~0x03;
cout << "b = " << b << endl;
WORD w = ~0x03;
cout << "w = " << w << endl;

This would result in the following calculations

    00000011  - 0x03
    11111100  - ~0x03  b

    0000000000000011  - 0x03
    1111111111111100  - ~0x03  w

Another ideal use, is to combine it with the & operator to ensure that certain bits are set to zero. Say we want to clear bit four

BYTE b = 50;
cout << "b = " << b << endl;
BYTE c = b & ~0x10;
cout << "c = " << c << endl;

This would result in the following calculations

    00110010  - b
 & 11101111  - ~0x10
  ----------
    00100010  - result

The >> and << operators

The >> (Right shift) and << (left shift) operators move the bits the number of bit positions specified. The >> operator shifts the bits from the high bit to the low bit. The << operator shifts the bits from the low bit to the high bit. One use for these operators is to align the bits for whatever reason (check out the MAKEWPARAM, HIWORD, and LOWORD macros)

BYTE b = 12;
cout << "b = " << b << endl;
BYTE c = b << 2;
cout << "c = " << c << endl;
c = b >> 2;
cout << "c = " << c << endl;

This would result in the following calculations

    00001100  - b
    00110000  - b << 2
    00000011  - b >> 2

Bit Fields

Another interesting thing that can be done using bits is to have bit fields. With bit fields you can set up minature structures within a BYTE, WORD or DWORD. Say, for example, we want to keep track of dates, but we want to use the least amount of memory as possible. We could declare our structure this way

struct date_struct {
    BYTE day   : 5,   // 1 to 31
         month : 4,   // 1 to 12
         year  : 14;  // 0 to 9999
    } date;

In this example, the day field takes up the lowest 5 bits, month the next four, and year the next 14 bits. So we can store the date structure in twenty three bits, which is contained in three BYTEs. The twenty fourth bit is ignored. If I had declared it using an integer for each field, the structure would have taken up 12 BYTEs.

|0 0 0 0 0 0 0 0|0 0 0 0 0 0 0 0|0 0 0 0 0 0 0 0|
   |                                   |          |           |
   +------ year -------------+ month + day --+

Now lets pick this declaration apart to see what we are doing.

First we will look at the data type we are using for the bit field structure. In this case we used a BYTE. A BYTE is 8 bits, and by using it, the compiler will allocate one BYTE for storage. If however, we use more than 8 bits in our structure, the compiler will allocate another BYTE, as many BYTEs as it takes to hold our structure. If we had used a WORD or DWORD, the compiler would have allocated a total of 32 bits to hold our structure.

Now lets look at how the various fields are declared. First we have the variable (day, month, and year), followed by a colon that separates the variable from the number of bits that it contains. Each bit field is separated by a comma, and the list is ended with a semicolon.

Now we get to the struct declaration. We put the bit fields into a struct like this so that we can use convention structure accessing notation to get at the structure members. Also, since we can not get the addresses of bit fields, we can now use the address of the structure.

date.day = 12;

dateptr = &date;
dateptr->year = 1852;


posted @ 2005-11-21 08:03 味全每日C++ 阅读(730) | 评论 (0)编辑 收藏

2005年11月14日 #

    今天参加MS2006年度秋季校园招聘会的笔试第三场,有一个算法题,求一个树种两个节点的最低公共节点,在网上Google了一下,看到原题大致这样的:
      Given the values of two nodes in a *binary search tree*, write a c program to find the lowest common ancestor. You may assume that both values already exist in the tree.

The function prototype is as follows: int FindLowestCommonAncestor(node* root,int value1,int value)
           20
          /  \
         8    22
       /   \
      4     12
           /  \
         10    14
    构筑函数: struct TreeNode * FindLowestCommonTreeNode(struct node *pNode,)

Struct TreeNode
{
   int Data;
   TreeNode *pLeft, *pRight;
}

FindLowestAncestor(Struct TreeNode *pRoot, Struct TreeNode *pNode1, Struct TreeNode *pNode2)
{
   if (pRoot==NULL) 
      return NULL;
   if (pRoot==pNode1 && pRoot==pNode2) 
      return pRoot;
   Struct TreeNode *pTemp;
   if (pTemp = FindLowestAncestor(pRoot->pLeft,pNode1,pNode2)) 
      return pTemp;
   if (pTemp = FindLowestAncestor(pRoot->pRight,pNode1,pNode2)) 
      return pTemp;
   if (FindLowestAncestor(pRoot,pNode1,pNode1) && FindLowestAncestor(pRoot,pNo
de2,pNode2)) return pRoot;

   return NULL;
}

posted @ 2005-11-14 02:05 味全每日C++ 阅读(1264) | 评论 (5)编辑 收藏

2005年11月2日 #

 

char ** p1;                                   //    pointer to pointer to char
const char **p2;                           //    pointer to pointer to const char
char * const * p3;                         //    pointer to const pointer to char
const char * const * p4;                //    pointer to const pointer to const char
char ** const p5;                          //    const pointer to pointer to char
const char ** const p6;                 //    const pointer to pointer to const char
char * const * const p7;                //    const pointer to const pointer to char
const char * const * const p8;       //    const pointer to const pointer to const char


注:p1是指向char类型的指针的指针;
        p2是指向const char类型的指针的指针;
        p3是指向char类型的const指针;
        p4是指向const char类型的const指针;
        p5是指向char类型的指针的const指针;
        p6是指向const char类型的指针的const指针;
        p7是指向char类型const指针的const指针;
        p8是指向const char类型的const指针的const指针。

typedef char * a;       // a is a pointer to a char 

typedef a b();            
// b is a function that returns a pointer to a char

typedef b 
*c;            // c is a pointer to a function that returns a pointer to a char 

typedef c d();           
// d is a function returning a pointer to a function that returns a pointer to a char 

typedef d 
*e;           // e is a pointer to a function returning a pointer to a function that a pointer to a char 

e var[
10];               // var is an array of 10 pointers to functions returning pointers to  functions returning pointers to chars.


原文地址:http://www.codeproject.com/cpp/complex_declarations.asp

posted @ 2005-11-02 22:08 味全每日C++ 阅读(2340) | 评论 (9)编辑 收藏

2005年10月27日 #

Yin Feilong

Address: Room 110 Building 11 Nanjing University Hankou Road 22, Nanjing, Jiangsu Province 210093

Phone: (86-25) 8359-4465  +86135-8519-7909

       E-mail: yinfeil@gmail.com             Homepage: http://www.seman.cn

Objective:

C++ Software Design Engineer

Education:

      B.E Department of Information Management, Nanjing University.  Aug.2002 – Present

      GPA: Overall: 3.2/4.0

Academic Main Courses:

Development Tools of Management Information System

Management Information Systems and software Engineering

Information Analysis and Policy Making, Information Retrieval and Storage

Programming Languages (C), Data Structures, Database Systems

Computer Network, System Science and Techniques, Information Organization

Computer Abilities:

      Certification:

           National Computer Rank Examination Grade Three(NCRE-3)

      Qualification of Computer and Software Technology Proficiency: Software Designer

      Skills:

Expert: C/C++, Visual Foxpro, HTML, Asp, CSS

Intermediate: Rational Rose, SQL Server, XML, Java, Project 2003

Beginner: C#, Asp.net, Visual C++, Oracle

English Skills:

Have a good command of both spoken and written English. Past CET-4

Experiences:

      Developer. Lily-Studio of Nanjing University, June 2003 – May 2004

           Designed and implemented the Community of Lily Alumni

              Editor in chief of the magazine Network Guide

       Lab Manager. Information Technology Lab. June 2004 – Present

Supervisor of Network Application, Designed and implemented FTPSMTP-based mail ServerVPN Web Server

Designed and implemented 2 websites of Department of Information Management and School of Public, using ASP and ACCESS

              Designed and implemented the platform of Tech-Learn Information

           Translate some parts of Web-based Analysis for competitive.

Honors:   

       FootballPing pong

posted @ 2005-10-27 16:36 味全每日C++ 阅读(1658) | 评论 (1)编辑 收藏

2005年10月24日 #

     摘要:   #include "iostream.h"#include "stdlib.h"#include "stack.h"#pragma oncetemplate<class T>class CBiTree{    public:    ...  阅读全文
posted @ 2005-10-24 11:06 味全每日C++ 阅读(1454) | 评论 (1)编辑 收藏

仅列出标题