c++学习经验交流

第一篇：c++学习经验交流

曾经因为自己的一些帖子在网上引起了大家对C++学习和使用的讨论，再回想起自己接触C++三年多，一年前鼓足勇气重新开始再次学习的情景，现在的我心中多了几份感慨，更多的是觉得自己学习的过程颇具普遍性，几次想把自己的一些心得写下来，对自己算是个总结和回顾，对别人即使谈不上帮助但相信也能算是个学习C++的案例分析吧。但开始几次提笔总是过于追求完美，想把所有的东西都写下来，但几次提笔和几次放弃后，我终于打消了“完美”的这个想法，等一下还要和自己女朋友打电话，就这一个小时内，能说多少算多少吧，毕竟我是说出来写下来了。

接触C++是在99年，那个时候自己已经有一些C语言的基础了，刚开始会用的关键字比起C来说也许只多了Class吧，那个时候在学校，也学了VC++，写了几个很简单的游戏程序，然后就因为很多琐事没有再在C++上有更多的深入，这也是我现在非常遗憾的事情，也许那个时候我能够投入进去，现在应该是能颇有小成了。02年开始了一个新的里程，我自己有充足的来支配时间。就在那一年的暑假，开始了新的C++学习，我知道我以前的基础对于学习C++来说，几乎不会有什么更大的帮助，所以我选择了重新开始，从IF….ELSE这样的语法开始。选择的第一本书是好友友情赠送的《C++ PRIMER》，当时我只是看了不到三天，我就没有继续看了，我知道这本书非常不错，但是肯定不适合当时的我，因为从一开始就有过多的东西给我困惑，类，模板，重载……，这样东西几乎让我放弃学习C++，因为我那个时候觉得自己C还是有一定功力的，就把C搞透对我来说那个时候也是个不错的选择，但毕竟C的内涵无法让我有更多的激情，重复的东西我向来就不喜欢。然后我开始考虑++这个两种语言唯一的标示区别到底意味和蕴涵着什么？同时我开始考虑到底程序设计语言是什么？随后我在图书馆借了本书《程序设计语言的概念和实现》，无论别人如何看待这本书让我明白了很多，因为这本书最大的特点是抽象出了现代程序设计语言的各种语义和其中蕴涵的思想，让我对语言本身这个概念有了更深刻的认识，让我建立去了各种语言自身的不同的语法都代表实现一种对于所有语言都共有的语义，而一个富有逻辑的语义系列却反映出了更一般的程序设计思想。在有了这个概念后，我接触到了《C++设计与演化》这本书，在学习C++过程中这本书对我的帮助是最大的，这本书让我明白了C++的设计理念和各种语言设施所代表的实现语义，既各种纷繁的C++语言特性都是为了实现某种功能并且在不违反C++设计哲学基础上建立起来的。这样的对于C++的宏观基础，让我在以后的学习日子里受益非浅，而《C++设计与演化》这本书我也同时具有中英两种版本，每当我对很多关于C++特性困惑的时候我都会把英文版（随便炫耀一下，这本书上有B.S的亲笔签名：））拿出来，再好好的看看。就象前阵子对于C++的学习，可谓讨论颇多，我自己也再次把这本书拿出来，评价自己所持有的观点是否正确。从此我认为自己算是走入了学习C++正确道路。

10月B.S来到中国，那个时候的我对于C++可以说只是个完全初学者（呵呵，给大家举个例子，那个时候我在杭州碰到了cber，他开始告诉我他的网名，我却说你的姓名是什么？后来他写下他的名字和联系方式我却还不知道我对面站着的是个C++顶尖高手，幸亏那个时候的我还和他合影了一张相片，这算是我比较明智的地方吧，至少没有留下遗憾。）我虽然是个初学者，但我不认为我应该错过这次和大师亲密接触的机会（尤其是在反复拜读过他 的书和大部分论文后），自费来到杭州（其实也花了不少那里同学的钱：））听了B.S在浙大的报告，我很早就去了，坐在第一排，整个报告会也是我第一个问问题，回想那个时候我的问题多少显的幼稚，但我告诉自己无论自己现在怎么样，这样的机会一辈子也许不会有了，所以我始终保持了十分积极，B.S的答复十分详细以至与我到后面就基本处于假听的状态：》但B.S的大师风范却让我颠倒，从此对于C++的学习我也不再功利。

学习就是积累，期间我看过《C++编程思想》，又对C++有了更感性的了解，三个月后再次拿出《C++ PIRMER》，这个时候我已经能非常明白LIPPMAN这本经典大作的巧妙用心了，它绝对不是给初学者看的，但对于入门后完全的学习和理解C++效果却十分明显，从书的一开始就直接进入C++的主题，前面五章都用类设计一个数据结构，让读者完全明白了各种用户定义类型所代表的抽象能力，然后直接进入第六章标准库中的容器类，这样的设计让读者十分清楚的建立容器和类这两个C++中十分重要的概念，之后的学习自然是非常富有满足感。以前学习编程的经验告诉我，写程序才是学习的中心，所以并且我把《C++ PRIMER》中的大部分代码都调试通过了，样例的代码连贯性也是这本书的最大的特点，而另外一大特点就是代码没有一个是可以直接通过的，都需要自己的调试，在调试这样的代码过程中更加深了我多C++的认识。不到两个月的时间就把《C++ PRIMER》初看了一遍，加之在CSDN上面和大家的交流，感觉已经建立起了对C++的完整的基本认识。

没有看过《C++程序设计语言》，算是学过C++吗？在我眼里，如果连语言的创作者的书都没有读过，如何去理解这本语言？去年12月我花了整整一个月把这本书好好的看了两遍，唯一的感觉是这本书才是真正有资格称为《C++编程思想》的。书和《C++ PRIMER》是完全的不同风格，后者告诉你的是完整C++的语法和其支持的语义。而前者是真正告诉你如何去用C++思考问题和编写符合C++设计理念的代码。你能明白C++的设计理念极其理念下的程序设计思路和代码编写规范。到今年元旦，感觉自己比起当初已经是进步不小，所以没有继续看书，而是在寒假看了几个大点规模的C++程序源代码。

之后，我也读了一些C++大家的作品，在这里需要提出来的是《C++标准程序库》和《C++沉思录》，前者写作方式通俗易懂，但全书内容却十分丰富，对于学习标准库可以说是最佳表现的作品。而后者，阅读感觉和《C++程序设计语言》一样，思想性非常强，读这样的书很累，脑子必须一直思考问题，思考作者里面提出的问题和他提出的解决方式。这本书最大的特点是非常直接的把C++语言的核心暴露出来-----三种抽象模型和极其语言设施本身对这三种抽象模型的支持。而《C++沉思录》给我的更深层思考是什么才是运用C++最合理的方式，这也是后来我发帖说明自己对于C++的学习和使用的一些见解的原始思想来源。

再后来，自己慢慢的用C++实现了一些小程序，有的是书本上的，有的是自己想的，写程序和调试的过程给我的感觉就是烦恼和满足的交替过程也许就是这样的反复过程才是程序员追求的。文章至此，多数记载了自己的历程，对很多看到这里的读者来说相信并没有什么帮助，下面我非常直接的说出自己的学习C++感受，从前面我的经历大家都可以看的出来我不是什么高手，但我保证我下面写的东西对于初学C++的是十分有帮助的，毕竟我刚刚走过那一段时的灰暗日子。

☆━━━━━━━━━━━━━━━━━━━━━━━━☆

即学即用就够了，只是一门语言而已，而且同样是语言，C++远远不如english重要。

☆━━━━━━━━━━━━━━━━━━━━━━━━☆

xor 的发言如下:

☆━━━━━━━━━━━━━━━━━━━━━━━━☆

其实我的建议是……，趁着中C++的毒不深，学Java先。

【 在 Ace(孤鸿·无双)的大作中提到: 】

:学习C++重在理解其各种语言设施所代表的语义，以及C++所能表示的语义所代表的设计思想。首先从宏观上入手，你需要明白的是C++是程序设计语言的本质。在此我把C++最重要的性质写下来：C++是一门静态类型检查，基于C内存模式，支持四种基本程序设计范型的语言。注意，这里说明了三个本质特性，静态说明了语言的类型检查性质，基于C内存模式告诉我们在C++中所有与内存有关的操作都需要程序员自己来负责，这样就带来了很多设计程序时的需要注意的地方，而理解支持的四种基本范型却是理解各种语言设施的基础。然后记住C++的最大的一点设计哲学，也是其贯穿应用C++的一条本质，我引用《C++ PRIMER

☆━━━━━━━━━━━━━━━━━━━━━━━━☆

DonaldDuck 的发言如下:

☆━━━━━━━━━━━━━━━━━━━━━━━━☆

我看过的国人写的书几乎无一例外的老旧，C++标准化已有5年，居然还有一些书连STL都没有提到，用这样的书学到的也只能是老的C++你们也许会说，C++没有这些内容也能用，但我认为学技术就要向前看，这就和现在几乎已经没用人用汇编写应用软件一个道理

第二篇：C++学习步骤

学习C++有那些步骤：

1。学习C++基本语法，参考书籍《C++程序设计》》钱能著，或《C++程序设计教程》DEITEL著，我看的是后者；

2。学习数据结构，参考书籍《数据结构C++语言描述——应用标准模板库（STL）》William Ford著；

3。学习STL，参考书籍《C++标准程序库》候捷译；

4。学习模板，参考书籍《泛型编程与STL》候捷译；

5。深入STL内部，直到能自己写出STL的源码，参考书籍《STL源码剖析》候捷译；

6。学习I/O方面的知识，参考书籍《Standard C++ IOStream and Locales》；

7。重温整个C++体系，参考书籍《C++ PRIMER》和《the c++ programming language》；

8。学习前人的技巧和方法，参考书籍〈effective c++>，；

9。再往上走，从宏观上把握C++程序设计体系，参考书籍<设计模式>,《深入探索C++对象模型》,<大规模C++程序设计>;

接下来就可以分2条路走了：

一、偏理论的道路，考研，注意，不是考计算机系，是考数学系，学习集合论，图论等知识，有一套书叫〈计算机程序设计艺术〉一至三卷，等你把他们都看完了，理解透了，就可以直接去微软投简历了。

二、偏应用的道路，学习windows编程，学习MFC，COM，ATL，以及整个.NET体系。

第三篇：c++学习感想

C++的学习感想

06光信2班赵飞学号：060105021106记得大一下学期学习C语言的时候，我们都有这样的困惑：课堂和教材的内容基本上都能接受和理解，但真要实际动手编写程序又感到脑袋一片空白而无从下手；其二，整个课程的所有内容好不容易学完了，但对编写实用化的程序，总感到眼花缭乱而无法下手，真个儿“欲起平之恨无力”。以至于在很长一段时间里在我的内心里产生了一种学习C语言和c++的恐惧感，认为自己不是学C语言和c++的料，将来打死我也不会朝C语言和c++的方向发展。

到了大二后，看着我周围的同学一个个地去参加计算机等级考试，拿了很多证书，一种羡慕感油然而生，决定也要像他们那样多掌握些计算机方面的知识和技术。在我的视野里消失了一年多的C语言和c++又在我的心目中占有了一席之地。我开始决心学好它。恰逢本学期开设了选修课c++，我便毅然决然的报了名，在这门课程快要结束的时候，我也参加报名了计算机等级考试二级c++，看看我这个学期是否真的学了一些东西。

崭新的21世纪，以现代电子信息产业为龙头的全球经济一体化浪潮正席卷世界。此时的我们面临着巨大的挑战和机遇。而以IT技术为基础的信息产业正深入到人类社会生活的方方面面，无论是生产制造、国防和科技等领域，还是第三产业，计算机软件现已成为担任重任的核心力量，互联网和软件已成为新经济发展的重要基础。因此，计算机软件技术将是各类专业的大专生、本科生和研究生必备的基础知识。

c++是著名的C语言的面向对象的扩展。C语言最初设计时是作为一种面向系统软件（操作系统Operating System和语言处理系统）的开发语言，即是用来代替汇编语言的，但是由于它强大的生命力，在事务处理、科学计算、工业控制和数据库技术等几个方面都得到了广泛的应用。即便进入到以计算机网络为核心的信息时代，C语言仍然是作为通用的汇编语言使用，用以开发软件、硬件结合的程序，如实时监控程序、控制程序和设备驱动程序等。而c++是C语言的超集，它保留了C语言的所有组成部分而与之兼容，既可以做传统的结构化程序设计，又能进行面向对象程序设计，也是当今世界上比较流行的程序设计语言。因此，学好c++对我们未来找工作大有裨益。

对于c++的学习，我有一些学习方法可以和大家分享，并认为通过这些方法可以使我们的编程技术获得较大提高：

第一，是要加强实践。C++程序设计语言是一门实践性非常强的课程，若要真正掌握编程技术，使编程能力有较大的实质性的提高，必须在认真听课勤做笔记并读懂教材的基础上，通过上机实验加强开发软件的基本技能训练。只有勤学苦练才能积累宝贵的编程经验，悟出编程技术的要领，牢固地掌握像Borland C++和Visual C++这样优秀的应用程序开发工具，快速冲向计算机应用领域的前沿。

其二，便是要学习掌握相关的程序库（c++当然首先要掌c++标准程序库）、相关的平台技术（eg.NET）,因为这些都是学习c++应掌握的辅助知识。在众多的计算机学科中，有很多都出现了内容的交叉现象。我们在学习c++的时候，如果能多看看有关这方面的书和查查相关的资料，对我们地学习也不无裨益。在这些程序库和平台技术上，我们还要锻炼自己对目标问题的分析和归纳能力，做到能够知其然且知其所以然，并能举一反三，扎实、灵活和系统地掌握编程要点。

第三，便是要多看有关c++的资料书。选取一两本自己能够容易看懂的c++方面的书，进行精读，和细读。在学校的图书馆阅览室有很多关于c++编程方面的书籍和资料，我们可以借几本过来，对照着看看，对我们的学习是一定有帮助的。

最后，便是要持之以恒，锲而不舍。罗马的建成不是一日之功，任何学问的从熟练到精通都不是三天两天的事。我们必须明白这个浅显的道理。学习c++本身就是一项艰苦的历程。浮躁的人、没有忍性的人，是肯定学不好c++的。我们必须有狂热的编程热情，否则是很难坚持下去的。我们也必须学会自信，因为有些时候尽管我们花了相当多的时间和精力，我们也不能写出一个程序。写程序确实是很麻烦的，有时需要顿悟，有时需要渐悟。当我们真正学好了，学精通了，便会有“一览众山小” 的感慨了。我们就会因此而有一种莫言的自豪感。

如今美国的次贷危机引发的全球经济危机正袭击着中国的沿海地区，许多的工厂在经济危机的打击下倒闭了，我们的就业压力变得更大了。能否在未来的激烈竞争中脱颖而出、出人头地完全要靠我们的真才实学。在软件技术行业，我们必须掌握好c++。通过对c++的学习达到精通后，我们还可以进一步学习Java、c#等，这时学习这些语言就相对较轻松了。其实只要我们能真正地把c++程序设计语言学精、学透，是不愁找不到工作的。

对我们光信息科学与技术专业，通过学习c++程序设计语言，我们可以用它来进行光学计算、光学设计等，将那些不能通过手工计算设计的，可以通过c++编程算出来，尤其是关于卷积积分、傅里叶变换、拉普拉斯变换等关于高等数学方面的数学物理方程。还有Zemax的光路设计等。可以说，学好c++对我们学光信息科学这一专业的，意义非凡。

因此，我必须努力掌握好它，为自己能够在以后找份好工作打下坚实的基础。

2008.12.16

第四篇：C++“指针”学习建议

一.对于众多人提出的c/c++中指针难学的问题做个总结：

指针学习不好关键是概念不清造成的，说的简单点就是书没有认真看，指针的学习犹如人在学习饶口令不多看多学多练是不行的，下面是两个很经典的例子，很多书上都有,对于学习的重点在于理解*x和x的理解，他们并不相同，*x所表示的其实就是变量a本身，x表示的是变量a在内存中的地址，如果想明白可以输出观察cout<<*x“|”x;，当定义了int *x;后对x=&a的理解的问题。仔细阅读和联系下面的两个例子我想指针问题就不是难点了！

#include main(){ int a,b;/* 定义a,b两个整形变量用于输入两个整数 */ int *point_1,*point_2,*temp_point;/* 定义三个指针变量 */ scanf(“%d,%d”,&a,&b);/* 格式化输入a,b的值 */

point_1=&a;/* 把指针变量point_1的值指向变量a的地址 */ point_2=&b;/* 把指针变量point_2的值指向变量b的地址 */ if(a main(){ int a,b;/* 定义a,b两个整形变量用于输入两个整数 */ int *point_1,*point_2;/* 定义三个指针变量 */ scanf(“%d,%d”,&a,&b);/* 格式化输入a,b的值 */

point_1 = &a;/* 把指针变量point_1的值指向变量a的地址 */ point_2 = &b;/* 把指针变量point_2的值指向变量b的地址 */

compositor(point_1,point_2);/* 调用自定义的排序涵数,把a,b的地址传递给point_1和point_2 */ printf(“%d,%d”,a,b);/* 打印出a,b的值 */ } static compositor(p1,p2)int *p1,*p2;/* 定义形式参数p1,p2为指针变量 */ { int temp;/* 建立临时存储变量 */

if(*p1<*p2)/* 如果*p1

*p1 = *p2;/* 将*p1的值也就是a的值换成*p2的值也就是b的值,等价于a=b */ *p2 = temp;/* 将*p2的值也就是temp的值等价于b=temp */ } } /* 注意:此题与上题不同的是,直接改变了a于b的值达到真实改变的目的 */

二．C++指针使用方法解惑

“void ClearList(LNode * & HL)”

仔细看一下这种声明方式，确实有点让人迷惑。

下面以void func1（MYCLASS *&pBuildingElement）； 为例来说明这个问题。在某种意义上，“*”和“&”是意思相对的两个东西，把它们放在一起有什么意义呢？。为了理解指针的这种做法，我们先复习一下C/C++编程中无所不在的指针概念。我们都知道MYCLASS*的意思：指向某个对象的指针，此对象的类型为MYCLASS。Void func1（MYCLASS *pMyClass）；

// 例如： MYCLASS* p = new MYCLASS； func1（p）；

上面这段代码的这种处理方法想必谁都用过，创建一个MYCLASS对象，然后将它传入func1函数。现在假设此函数要修改pMyClass： void func1（MYCLASS *pMyClass）{ DoSomething（pMyClass）； pMyClass = // 其它对象的指针 }

第二条语句在函数过程中只修改了pMyClass的值。并没有修改调用者的变量p的值。如果p指向某个位于地址0x008a00的对象，当func1返回时，它仍然指向这个特定的对象。（除非func1有bug将堆弄乱了，完全有这种可能。）

现在假设你想要在func1中修改p的值。这是你的权利。调用者传入一个指针，然后函数给这个指针赋值。以往一般都是传双指针，即指针的指针，例如，CMyClass**。MYCLASS* p = NULL； func1（&p）；

void func1（MYCLASS** pMyClass）； { *pMyClass = new MYCLASS； „„ }

调用func1之后，p指向新的对象。在COM编程中，你到处都会碰到这样的用法--例如在查询对象接口的QueryInterface函数中： interface ISomeInterface { HRESULT QueryInterface（IID &iid, void** ppvObj）； „„ }；

LPSOMEINTERFACE p=NULL；

pOb->QueryInterface（IID_SOMEINTERFACE, &p）；

此处，p是SOMEINTERFACE类型的指针，所以&p便是指针的指针，在QueryInterface返回的时候，如果调用成功，则变量p包含一个指向新的接口的指针。

如果你理解指针的指针，那么你肯定就理解指针引用，因为它们完全是一回事。如果你象下面这样声明函数： void func1（MYCLASS *&pMyClass）； { pMyClass = new MYCLASS； „„ } 其实，它和前面所讲得指针的指针例子是一码事，只是语法有所不同。传递的时候不用传p的地址&p，而是直接传p本身：

MYCLASS* p = NULL；

func1（p）；

在调用之后，p指向一个新的对象。一般来讲，引用的原理或多或少就象一个指针，从语法上看它就是一个普通变量。所以只要你碰到*&，就应该想到**。也就是说这个函数修改或可能修改调用者的指针，而调用者象普通变量一样传递这个指针，不使用地址操作符&。

至于说什么场合要使用这种方法，我会说，极少。MFC在其集合类中用到了它--例如，CObList，它是一个Cobjects指针列表。

Class CObList : public Cobject { „„

// 获取/修改指定位置的元素

Cobject*& GetAt（POSITION position）； Cobject* GetAt（POSITION position）const； }；

这里有两个GetAt函数，功能都是获取给定位置的元素。区别何在呢？

区别在于一个让你修改列表中的对象，另一个则不行。所以如果你写成下面这样： Cobject* pObj = mylist.GetAt（pos）；

则pObj是列表中某个对象的指针，如果接着改变pObj的值： pObj = pSomeOtherObj；

这并改变不了在位置pos处的对象地址，而仅仅是改变了变量pObj。但是，如果你写成下面这样： Cobject*& rpObj = mylist.GetAt（pos）；

现在，rpObj是引用一个列表中的对象的指针，所以当改变rpObj时，也会改变列表中位置pos处的对象地址--换句话说，替代了这个对象。这就是为什么CObList会有两个GetAt函数的缘故。一个可以修改指针的值，另一个则不能。注意我在此说的是指针，不是对象本身。这两个函数都可以修改对象，但只有*&版本可以替代对象。

在C/C++中引用是很重要的，同时也是高效的处理手段。所以要想成为C/C++高手，对引用的概念没有透彻的理解和熟练的应用是不行的。

三．数据指针

在C/C++语言中一直是很受宠的；几乎找不到一个不使用指针的C/C++应用。用于存储数据和程序的地址，这是指针的基本功能。用于指向整型数，用整数指针(int*)；指向浮点数用浮点数指针(float*)；指向结构，用对应的结构指针(struct xxx *)；指向任意地址，用无类型指针(void*)。

有时候，我们需要一些通用的指针。在C语言当中，(void*)可以代表一切；但是在C++中，我们还有一些比较特殊的指针，无法用(void*)来表示。事实上，在C++中，想找到一个通用的指针，特别是通用的函数指针简直是一个“不可能任务”。

C++是一种静态类型的语言，类型安全在C++中举足轻重。在C语言中，你可以用void*来指向一切；但在C++中，void*并不能指向一切，就算能，也失去了类型安全的意义了。类型安全往往能帮我们找出程序中潜在的一些BUG。

下面我们来探讨一下，C++中如何存储各种类型数据的指针。

C++指针探讨

（一）数据指针 沐枫网志

1.数据指针

数据指针分为两种：常规数据指针和成员数据指针

1.1 常规数据指针

这个不用说明了，和C语言一样，定义、赋值是很简单明了的。常见的有：int*, double* 等等。

如：

int value = 123;int * pn = &value;

1.2 成员数据指针

有如下的结构： struct MyStruct { int key;int value;};

现在有一个结构对象: MyStruct me;MyStruct* pMe = &me;

我们需要 value 成员的地址，我们可以： int * pValue = &me.value;//或

int * pValue = &pMe->value;

当然了，这个指针仍然是属于第一种范筹----常规数据指针。

好了，我们现在需要一种指针，它指向MyStruct中的任一数据成员，那么它应该是这样的子： int MyStruct::* pMV = &MyStruct::value;//或

int MyStruct::* pMK = &MyStruct::key;

这种指针的用途是用于取得结构成员在结构内的地址。我们可以通过该指针来访问成员数据： int value = pMe->*pMV;// 取得pMe的value成员数据。

int key = me.*pMK;// 取得me的key成员数据。

那么，在什么场合下会使用到成员数据指针呢？

确实，成员指针本来就不是一种很常用的指针。不过，在某些时候还是很有用处的。我们先来看看下面的一个函数： int sum(MyStruct* objs, int MyStruct::* pm, int count){ int result = 0;for(int i = 0;i < count;++i)result += objs[i].*pm;return result;}

这个函数的功能是什么，你能看明白吗？它的功能就是，给定count个MyStruct结构的指针，计算出给定成员数据的总和。有点拗口对吧？看看下面的程序，你也许就明白了：

MyStruct me[10] = { {1,2},{3,4},{5,6},{7,8},{9,10},{11,12},{13,14},{15,16},{17,18},{19,20} };int sum_value = sum(me, &MyStruct::value, 10);//计算10个MyStruct结构的value成员的总和： sum_value 值 为 110(2+4+6+8+ int sum_key = sum(me, &MyStruct::key, 10);//计算10个MyStruct结构的key成员的总和： sum_key 值 为 100(1+3+5+7+

+19)+20)也许，你觉得用常规指针也可以做到，而且更易懂。Ok，没问题： int sum(MyStruct* objs, int count){ int result = 0;for(int i = 0;i < count;++i)result += objs[i].value;return result;}

你是想这么做吗？但这么做，你只能计算value，如果要算key的话，你要多写一个函数。有多少个成员需要计算的话，你就要写多少个函数，多麻烦啊。指针

四．C++指针使用

在下列函数声明中，为什么要同时使用*和&符号？以及什么场合使用这种声明方式?

void func1(MYCLASS *&pBuildingElement);论坛中经常有人问到这样的问题。

本文试图通过一些实际的指针使用经验来解释这个问题。

仔细看一下这种声明方式，确实有点让人迷惑。在某种意义上，“*”和“&”是意思相对的两个东西，把它们放在一起有什么意义呢？。为了理解指针的这种做法，我们先复习一下C/C++编程中无所不在的指针概念。我们都知道MYCLASS*的意思：指向某个对象的指针，此对象的类型为MYCLASS。void func1(MYCLASS *pMyClass);

// 例如： MYCLASS* p = new MYCLASS;

func1(p);

上面这段代码的这种处理方法想必谁都用过，创建一个MYCLASS对象，然后将它传入func1函数。现在假设此函数要修改pMyClass： void func1(MYCLASS *pMyClass){ DoSomething(pMyClass);pMyClass = // 其它对象的指针 }

第二条语句在函数过程中只修改了pMyClass的值。并没有修改调用者的变量p的值。如果p指向某个位于地址0x008a00的对象，当func1返回时，它仍然指向这个特定的对象。（除非func1有bug将堆弄乱了，完全有这种可能。）

现在假设你想要在func1中修改p的值。这是你的权利。调用者传入一个指针，然后函数给这个指针赋值。以往一般都是传双指针，即指针的指针，例如，CMyClass**。MYCLASS* p = NULL;func1(&p);void func1(MYCLASS** pMyClass);{ *pMyClass = new MYCLASS;„„ }

调用func1之后，p指向新的对象。在COM编程中，你到处都会碰到这样的用法--例如在查询对象接口的QueryInterface函数中：

interface ISomeInterface { HRESULT QueryInterface(IID &iid, void** ppvObj);„„ };

LPSOMEINTERFACE p=NULL;pOb->QueryInterface(IID_SOMEINTERFACE, &p);

此处，p是SOMEINTERFACE类型的指针，所以&p便是指针的指针，在QueryInterface返回的时候，如果调用成功，则变量p包含一个指向新的接口的指针。

如果你理解指针的指针，那么你肯定就理解指针引用，因为它们完全是一回事。如果你象下面这样声明函数： void func1(MYCLASS *&pMyClass);{ pMyClass = new MYCLASS;„„ } 其实，它和前面所讲得指针的指针例子是一码事，只是语法有所不同。传递的时候不用传p的地址&p，而是直接传p本身：

MYCLASS* p = NULL;func1(p);在调用之后，p指向一个新的对象。一般来讲，引用的原理或多或少就象一个指针，从语法上看它就是一个普通变量。所以只要你碰到*&，就应该想到**。也就是说这个函数修改或可能修改调用者的指针，而调用者象普通变量一样传递这个指针，不使用地址操作符&。

至于说什么场合要使用这种方法，我会说，极少。MFC在其集合类中用到了它--例如，CObList，它是一个CObjects指针列表。

class CObList : public CObject { „„

// 获取/修改指定位置的元素

CObject*& GetAt(POSITION position);CObject* GetAt(POSITION position)const;};这里有两个GetAt函数，功能都是获取给定位置的元素。区别何在呢？

区别在于一个让你修改列表中的对象，另一个则不行。所以如果你写成下面这样： CObject* pObj = mylist.GetAt(pos);

则pObj是列表中某个对象的指针，如果接着改变pObj的值： pObj = pSomeOtherObj;

这并改变不了在位置pos处的对象地址，而仅仅是改变了变量pObj。但是，如果你写成下面这样： CObject*& rpObj = mylist.GetAt(pos);

现在，rpObj是引用一个列表中的对象的指针，所以当改变rpObj时，也会改变列表中位置pos处的对象地址--换句话说，替代了这个对象。这就是为什么CObList会有两个GetAt函数的缘故。一个可以修改指针的值，另一个则不能。注意我在此说的是指针，不是对象本身。这两个函数都可以修改对象，但只有*&版本可以替代对象。

在C/C++中引用是很重要的，同时也是高效的处理手段。所以要想成为C/C++高手，对引用的概念没有透彻的理解和熟练的应用是不行的。

五．新手学习之浅析c/c++中的指针

在学习c/c+过程中，指针是一个比较让人头痛的问题，稍微不注意将会是程序编译无法通过，甚至造成死机。在程序设计过程中，指针也往往是产生隐含bug的原因。下面就来谈谈指针的应用以及需要注意的一些问题，里面也许就有你平时没有注意到的问题，希望能帮助各位读者理解好指针。

一、我们先来回忆一下指针的概念吧，方便下面的介绍

指针是存放地址值的变量或者常量。例如：int a=1;&a就表示指针常量（“&”表示取地址运算符，也即引用）。int *b，b表示的是指针变量（注意，是b表示指针变量而不是*b），*表示要说明的是指针变量。大家注意int *b[2]和int（*b）[2]是不同的，int *b表示一个指针数组，而int（*b）[2]表示含有两个元素的int指针，这里要注意运算优先级问题，有助于理解指针问题。在这里大概介绍基本概念就够了，至于具体使用方法，如赋值等，很多书都有介绍，我就不多说了。

二、应用以及注意的问题

1、理解指针的关键所在——对指针类型和指针所指向的类型的理解

①、指针类型：可以把指针名字去掉，剩下的就是这个指针

例如： int *a;//指针类型为int *

int **a;//指针类型为int **

int *(*a)[8];//指针类型为 int *(*)[8]

②、指针所指向的类型：是指编译器将把那一片内存所看待成的类型。这里只要把指针声明语句中的指针名字和名字右边的“*”号去掉就可以了，剩下的就是指针所指向的类型。

我之所以把他们放在第一位，是因为弄清楚他们是学c/c++指针的重点，正确理解他们才能使你打好c/c++的编程基础。

2、指针的应用——传递参数。

其实它可以相当于隐式的返回值，这就比return的方法更加灵活了，可以返回更多的值，看看下面的例子自然就明白了：

#include “iostream.h”

void example(int *a1,int &b1,int c1)

{

*a1*=3;

++b1;

++c1;

}

void main()

{

int *a;

int b,c;

*a=6;

b=7;c=10;

example(a,b,c);

cout <<“*a=”<<*a<

cout <<“b=”<

cout <<“c=”<

}

输出：*a=18

b=8

c=10

注意到没有，*a和b的值都改变了，而c没有变。这是由于a1是指向*a（=6）的指针，也即与a是指向同一个地址，所以当a1指向的值改变了，*a的值也就改变了。在函数中的参数使用了引用（int &b1），b1是b的别名，也可以把它当作特殊的指针来理解，所以b的值会改变。函数中的参数int c1只是在函数中起作用，当函数结束时候便消失了，所以在main（）中不起作用。

3、关于全局变量和局部变量的一个问题先不废话了，先看看程序：

#include “iostream.h”

int a=5;

int *example1(int b)

{

a+=b;

return &a;

}

int *example2(int b)

{

int c=5;

b+=c;

return &b;

}

void main()

{

int *a1=example1(10);

int *b1=example2(10);

cout <<”a1=”<<*a1<

cout <<”b1=”<<*b1<

}

输出结果：

a1=15

b1=4135

*b1怎么会是4135，而不是15呢？是程序的问题？没错吧？

由于a是全局变量，存放在全局变量的内存区，它一直是存在的；而局部变量则是存在于函数的栈区，当函数example2（）调用结束后便消失，是b指向了一个不确定的区域，产生指针悬挂。

下面是对example1（）和example2（）的反汇编（用TC++ 3.0编译）：

example1（）：

push bp;入栈

mov bp,sp mov ax,[bp+04];传递参数

add [00AA],ax;相加

mov ax,00AA;返回了结果所在的地址

..pop bp；恢复栈，出栈

ret；退出函数

example2（）：

push bp；入栈

mov bp,sp

sub sp,02

mov word ptr [bp-02],0005

mov ax,[bp-02]；传递参数

add [bp+04],ax;相加

lea ax,[bp+04];问题就出在这里

..mov sp,bp

pop bp；恢复栈，出栈

ret；退出函数

对比之后看出来了吧？ax应该是存储的是结果的地址。而在example2（）中，返回的却是[bp+04]的内容，因此指针指向了一个不确定的地方，由此产生的指针悬挂。example1（）中，ax返回了正确的结果的地址。

4、内存问题：使用指针注意内存的分配和边界。使用指针过程中应该给变量一个适当的空间，以免产生不可见的错误。请看以下代码：

#include “iostream.h”

void main()

{

char *a1;

char *a2;

cin >>a1;

cin >>a2;

cout <<”a1=”<

cout <<”a2=”<

}

输入：abc

123

输出：

a1=123

a2=

Null pointer assignment

指针指向了“空”。解决办法就是分配适当的内存给这两个字符串。修正后的代码

如下：

#include “iostream.h”

void main()

{

char *a1;

char *a2;

a1=new char [10];

a2=new char [10];

cin >>a1;

cin >>a2;

cout <<”a1=”<

cout <<”a2=”<

delete(a1);注意,别忘了要释放内存空间

delete(a2);

}

到此就能输出正确的结果了。分配了适当的内存之后要注意释放内参空间，同时还应该注意不要超出所分配的内存的大小，否则会有溢出现象产生，导致不可预料的结果。

5、关于特殊的指针——引用

引用有时候应用起来要比指针要灵活，用它做返回的时候是不产生任何变量的副本的这样减小了内存的占用，提高执行的速度。引用使用起来要比指针好理解，比较直观。当引用作为参数时，不会改变参数的地址，因此可以作为左值。

下面请看一个例子：

#include “iostream.h”

char ch[5]=”ABCD”;

char &example(int b)

{

return ch;

}

void main()

{

cout <<”ch=”<

example(2)=”c”;

cout<<”ch=”<

}

输出结果：

ch=ABCD

ch=ABcD

在实际编程过程中，可以灵活地引用或指针，尽量提高程序的可读性和执行效率。

三、小结：

指针是学习c/c++的重点难点，主要原因是指针较为抽象，不容易理解。使用指针千万要明白让指针指向什么地方，如何让指针指向正确的地方。在深入系统底层之中需要应用到大量的指针，因此需要理解好指针的基本概念，例如：指针类型和指针所指向的类型。平时应该对留心观察，了解程序的工作过程，必要时候可以对程序进行反汇编，加深对指针的理解，这种方法同样适合学别的编程方面的知识。

四、结束：

指针的应用是很广泛的，利用指针可以做很多事情，要成为一个好的程序员，必须对指针有比较深刻的了解。写本文的目的在于让大家对指针有更深一层的了解，提高指针的应用能力，内容大都是我在实际编程中遇到的问题。相信能给大家一定的帮助。

六．C++中关于指针入门的最好的文章

什么是指针？

其实指针就像是其它变量一样，所不同的是一般的变量包含的是实际的真实的数据，而指针是一个指示器，它告诉程序在内存的哪块区域可以找到数据。这是一个非常重要的概念，有很多程序和算法都是围绕指针而设计的，如链表。

开始学习

如何定义一个指针呢？就像你定义一个其它变量一样，只不过你要在指针名字前加上一个星号。我们来看一个例子：下面这个程序定义了两个指针，它们都是指向整型数据。

int* pNumberOne;

int* pNumberTwo;

你注意到在两个变量名前的“p”前缀了吗？这是程序员通常在定义指针时的一个习惯，以提高便程序的阅读性，表示这是个指针。现在让我们来初始化这两个指针：

pNumberOne = &some_number;

pNumberTwo = &some_other_number;

&号读作“什么的地址”，它表示返回的是变量在内存中的地址而不是变量本身的值。在这个例子中，pNumberOne 等于some_number的地址，所以现在pNumberOne指向some_number。如果现在我们在程序中要用到some_number，我们就可以使用pNumberOne。

我们来学习一个例子：

在这个例子中你将学到很多，如果你对指针的概念一点都不了解，我建议你多看几遍这个例子，指针是个很复杂的东西，但你会很快掌握它的。

这个例子用以增强你对上面所介绍内容的了解。它是用C编写的(注：原英文版是用C写的代码，译者重新用C++改写写了所有代码，并在DEV C++ 和VC++中编译通过！）

#include

void main()

{ // 声明变量：

int nNumber;

int *pPointer;

// 现在给它们赋值：

nNumber = 15;

pPointer = &nNumber;

//打印出变量nNumber的值：

cout<<“nNumber is equal to :”<< nNumber<

// 现在通过指针改变nNumber的值：

*pPointer = 25;

//证明nNumber已经被上面的程序改变

//重新打印出nNumber的值:

cout<<“nNumber is equal to :”<

}

通读一下这个程序，编译并运行它，务必明白它是怎样工作的。如果你完成了，准备好，开始下一小节。

陷井！

试一下，你能找出下面这段程序的错误吗？

#include

int *pPointer;

void SomeFunction();

{

int nNumber;

nNumber = 25;

//让指针指向nNumber:

pPointer = &nNumber;

}

void main()

{

SomeFunction();//为pPointer赋值

//为什么这里失败了?为什么没有得到25

cout<<“Value of *pPointer: ”<<*pPointer<

}

这段程序先调用了SomeFunction函数，创建了个叫nNumber的变量，接着让指针pPointer指向了它。可是问题出在哪儿呢？当函数结束后，nNumber被删掉了，因为这一个局部变量。局部变量在定义它的函数执行完后都会被系统自动删掉。也就是说当SomeFunction 函数返回主函数main()时，这个变量已经被删掉，但pPointer还指着变量曾经用过的但现在已不属于这个程序的区域。如果你还不明白，你可以再读读这个程序，注意它的局部变量和全局变量，这些概念都非常重要。

但这个问题怎么解决呢？答案是动态分配技术。注意这在C和C++中是不同的。由于大多数程序员都是用C++，所以我用到的是C++中常用的称谓。

动态分配

动态分配是指针的关键技术。它是用来在不必定义变量的情况下分配内存和让指针去指向它们。尽管这么说可能会让你迷惑，其实它真的很简单。下面的代码就是一个为一个整型数据分配内存的例子：

int *pNumber;

pNumber = new int;

第一行声明一个指针pNumber。第二行为一个整型数据分配一个内存空间，并让pNumber指向这个新内存空间。下面是一个新例，这一次是用double双精型：

double *pDouble;

pDouble = new double;

这种格式是一个规则，这样写你是不会错的。

但动态分配又和前面的例子有什么不同呢？就是在函数返回或执行完毕时，你分配的这块内存区域是不会被删除的所以我们现在可以用动态分配重写上面的程序：

#include

int *pPointer;

void SomeFunction()

{ // 让指针指向一个新的整型

pPointer = new int;

*pPointer = 25;

}

void main()

{

SomeFunction();// 为pPointer赋值

cout<<“Value of *pPointer: ”<<*pPointer<

}

通读这个程序，编译并运行它，务必理解它是怎样工作的。当SomeFunction调用时，它分配了一个内存，并让pPointer指向它。这一次，当函数返回时，新的内存区域被保留下来，所以pPointer始终指着有用的信息，这是因为了动态分配。但是你再仔细读读上面这个程序，虽然它得到了正确结果，可仍有一个严重的错误。

分配了内存，别忘了回收

太复杂了，怎么会还有严重的错误！其实要改正并不难。问题是：你动态地分配了一个内存空间，可它绝不会被自动删除。也就是说，这块内存空间会一直存在，直到你告诉电脑你已经使用完了。可结果是，你并没有告诉电脑你已不再需要这块内存空间了，所以它会继续占据着内存空间造成浪费，甚至你的程序运行完毕，其它程序运行时它还存在。当这样的问题积累到一定程度，最终将导致系统崩溃。所以这是很重要的，在你用完它以后，请释放它的空间，如：

delete pPointer;

这样就差不多了，你不得不小心。在这你终止了一个有效的指针（一个确实指向某个内存的指针）。下面的程序，它不会浪费任何的内存：

#include

int *pPointer;

void SomeFunction()

{ // 让指针指向一个新的整型

pPointer = new int;

*pPointer = 25;

}

void main()

{

SomeFunction();//为pPointer赋值

cout<<“Value of *pPointer: ”<<*pPointer<

delete pPointer;

}

只有一行与前一个程序不同，但就是这最后一行十分地重要。如果你不删除它，你就会制造一起“内存漏洞”，而让内存逐渐地泄漏。(译者:假如在程序中调用了两次SomeFunction，你又该如何修改这个程序呢？请读者自己思考)

传递指针到函数

传递指针到函数是非常有用的，也很容易掌握。如果我们写一个程序，让一个数加上5,看一看这个程序完整吗？：

#include

void AddFive(int Number)

{

Number = Number + 5;

}

void main()

{

int nMyNumber = 18;

cout<<“My original number is ”<

AddFive(nMyNumber);

cout<<“My new number is ”<

}

问题出在函数AddFive里用到的Number是变量nMyNumber的一个副本而传递给函数，而不是变量本身。因此，“ Number = Number + 5” 这一行是把变量的副本加了5，而原始的变量在主函数main()里依然没变。试着运行这个程序，自己去体会一下。要解决这个问题，我们就要传递一个指针到函数，所以我们要修改一下函数让它能接受指针：把'void AddFive(int Number)' 改成 'void AddFive(int*Number)'。下面就是改过的程序，注意函数调用时要用＆号，以表示传递的是指针：

#include

void AddFive(int* Number)

{

*Number = *Number + 5;

}

void main()

{

int nMyNumber = 18;

cout 七．我眼中的指针--学习指针不可少的好文章

我眼中的指针--学习指针不可少的好文章

为初学者服务。这是我的帖子的宗旨。我也是个初学者（强调了无数遍了），我以我的理解把初学者觉得难懂的东西用浅显的语言写出来。由于小学时语文没学好，所以竭尽全力也未必能达到这个目的。尽力而为吧。

指针是c和c++中的难点和重点。我只精通dos下的basic。c语言的其它各种特性，在basic中都有类似的东西。只有指针，是baisc所不具备的。指针是c的灵魂。

我不想重复大多数书上说得很清楚的东西，我只是把我看过的书中说得不清楚或没有说，而我又觉得我理解得有点道理的东西写出来。我的目的是：

1。通过写这些东西，把我脑袋中关于c的模糊的知识清晰化。2。给初学者们一点提示。

3。赚几个经验值。（因为贴这些东西没有灌水之嫌啊）

第一章。指针的概念

指针是一个特殊的变量，它里面存储的数值被解释成为内存里的一个地址。要搞清一个指针需要搞清指针的四方面的内容：指针的类型，指针所指向的类型，指针的值或者叫指针所指向的内存区，还有指针本身所占据的内存区。让我们分别说明。先声明几个指针放着做例子： 例一：(1)int *ptr;(2)char *ptr;(3)int **ptr;(4)int(*ptr)[3];(5)int *(*ptr)[4];如果看不懂后几个例子的话，请参阅我前段时间贴出的文?lt;<如何理解c和c++的复杂类型声明>>。

1。指针的类型。

从语法的角度看，你只要把指针声明语句里的指针名字去掉，剩下的部分就是这个指针的类型。这是指针本身所具有的类型。让我们看看例一中各个指针的类型：(1)int *ptr;//指针的类型是int *(2)char *ptr;//指针的类型是char *(3)int **ptr;//指针的类型是 int **(4)int(*ptr)[3];//指针的类型是 int(*)[3](5)int *(*ptr)[4];//指针的类型是 int *(*)[4] 怎么样？找出指针的类型的方法是不是很简单？

2。指针所指向的类型。

当你通过指针来访问指针所指向的内存区时，指针所指向的类型决定了编译器将把那片内存区里的内容当做什么来看待。从语法上看，你只须把指针声明语句中的指针名字和名字左边的指针声明符 * 去掉，剩下的就是指针所指向的类型。例如：

(1)int *ptr;//指针所指向的类型是int(2)char *ptr;//指针所指向的的类型是char(3)int **ptr;//指针所指向的的类型是 int *(4)int(*ptr)[3];//指针所指向的的类型是 int()[3](5)int *(*ptr)[4];//指针所指向的的类型是 int *()[4] 在指针的算术运算中，指针所指向的类型有很大的作用。指针的类型(即指针本身的类型)和指针所指向的类型是两个概念。当你对C越来越熟悉时，你会发现，把与指针搅和在一起的“类型”这个概念分成“指针的类型”和“指针所指向的类型”两个概念，是精通指针的关键点之一。我看了不少书，发现有些写得差的书中，就把指针的这两个概念搅在一起了，所以看起书来前后矛盾，越看越糊涂。

3。指针的值，或者叫指针所指向的内存区或地址。

指针的值是指针本身存储的数值，这个值将被编译器当作一个地址，而不是一个一般的数值。在32位程序里，所有类型的指针的值都是一个32位整数，因为32位程序里内存地址全都是32位长。指针所指向的内存区就是从指针的值所代表的那个内存地址开始，长度为sizeof(指针所指向的类型)的一片内存区。以后，我们说一个指针的值是XX，就相 当于说该指针指向了以XX为首地址的一片内存区域；我们说一个指针指向了某块内存区域，就相当于说该指针的值是这块内存区域的首地址。

指针所指向的内存区和指针所指向的类型是两个完全不同的概念。在例一中，指针所指向的类型已经有了，但由于指针还未初始化，所以它所指向的内存区是不存在的，或者说是无意义的。

以后，每遇到一个指针，都应该问问：这个指针的类型是什么？指针指向的类型是什么？该指针指向了哪里？ 4。指针本身所占据的内存区。

指针本身占了多大的内存？你只要用函数sizeof(指针的类型)测一下就知道了。在32位平台里，指针本身占据了4个字节的长度。指针本身占据的内存这个概念在判断一个指针表达式是否是左值时很有用。

第二章。指针的算术运算

指针可以加上或减去一个整数。指针的这种运算的意义和通常的数值的加减运算的意义是不一样的。例如： 例二：

1。char a[20];2。int *ptr=a;......3。ptr++;在上例中，指针ptr的类型是int*,它指向的类型是int，它被初始化为指向整形变量a。接下来的第3句中，指针ptr被加了1，编译器是这样处理的：它把指针ptr的值加上了sizeof(int)，在32位程序中，是被加上了4。由于地址是用字节做单位的，故ptr所指向的地址由原来的变量a的地址向高地址方向增加了4个字节。

由于char类型的长度是一个字节，所以，原来ptr是指向数组a的第0号单元开始的四个字节，此时指向了数组a中从第4号单元开始的四个字节。我们可以用一个指针和一个循环来遍历一个数组，看例子： 例三： 例三： int array[20];int *ptr=array;...//此处略去为整型数组赋值的代码。...for(i=0;i<20;i++){(*ptr)++;ptr++； } 这个例子将整型数组中各个单元的值加1。由于每次循环都将

八．指针详解

第一章。指针的概念

指针是一个特殊的变量，它里面存储的数值被解释成为内存里的一个地址。

要搞清一个指针需要搞清指针的四方面的内容：指针的类型，指针所指向的类型，指针的值或者叫指针所指向的内存区，还有指针本身所占据的内存区。让 我们分别说明。先声明几个指针放着做例子： 例一：(1)int*ptr;(2)char*ptr;(3)int**ptr;(4)int(*ptr)[3];(5)int*(*ptr)[4];

1。指针的类型。

从语法的角度看，你只要把指针声明语句里的指针名字去掉，剩下的部分就是这个指针的类型。这是指针本身所具有的类型。让我们看看例一中各个指针的类型：(1)int*ptr;//指针的类型是int*(2)char*ptr;//指针的类型是char*(3)int**ptr;//指针的类型是int**(4)int(*ptr)[3];//指针的类型是int(*)[3](5)int*(*ptr)[4];//指针的类型是int*(*)[4] 怎么样？找出指针的类型的方法是不是很简单？

2。指针所指向的类型。

当你通过指针来访问指针所指向的内存区时，指针所指向的类型决定了编译器将把那片内存区里的内容当做什么来看待。从语法上看，你只须把指针声明语句中的指针名字和名字左边的指针声明符 *去掉，剩下的就是指针所指向的类型。例如：

(1)int*ptr;//指针所指向的类型是int(2)char*ptr;//指针所指向的的类型是char(3)int**ptr;//指针所指向的的类型是int*(4)int(*ptr)[3];//指针所指向的的类型是int()[3](5)int*(*ptr)[4];//指针所指向的的类型是int*()[4] 在指针的算术运算中，指针所指向的类型有很大的作用。

指针的类型(即指针本身的类型)和指针所指向的类型是两个概念。当你对C越来越熟悉时，你会发现，把与指针搅和在一起的“类型”这个概念分成“指针的类型”和“指针所指向的类型”两个概念，是精通指针的关键点之一。我看了不少书，发现有些写得差的书中，就把指针的这两个概念搅在一起了，所以看起书来前后矛盾，越看越糊涂。

3。指针的值，或者叫指针所指向的内存区或地址。

指针的值是指针本身存储的数值，这个值将被编译器当作一个地址，而不是一个一般的数值。在32位程序里，所有类型的指针的值都是一个32位整数，因为32位程序里内存地址全都是32位长。指针所指向的内存区就是从指针的值所代表的那个内存地址开始，长度为sizeof(指针所指向的类型)的一片内存区。以后，我们说一个指针的值是XX，就相当于说该指针指向了以XX为首地址的一片内存区域；我们说一个指针指向了某块内存区域，就相当于说该指针的值是这块内存区域的首地址。指针所指向的内存区和指针所指向的类型是两个完全不同的概念。在例一中，指针所指向的类型已经有了，但由于指针还未初始化，所以它所指向的内存区 是不存在的，或者说是无意义的。以后，每遇到一个指针，都应该问问：这个指针的类型是什么？指针指向的类型是什么？该指针指向了哪里？

4。指针本身所占据的内存区。

指针本身占了多大的内存？你只要用函数sizeof(指针的类型)测一下就知道了。在32位平台里，指针本身占据了4个字节的长度。指针本身占据的内存这个概念在判断一个指针表达式是否是左值时很有用。第二章。指针的算术运算

指针可以加上或减去一个整数。指针的这种运算的意义和通常的数值的加减运算的意义是不一样的。例如： 例二： 1。char a[20];2。int *ptr=a;......3。ptr++;在上例中，指针ptr的类型是int*,它指向的类型是int，它被初始化为指向整形变量a。接下来的第3句中，指针ptr被加了1，编译器是这样处理的：它把指针 ptr的值加上了sizeof(int)，在32位程序中，是被加上了4。由于地址是用字节做单位的，故ptr所指向的地址由原来的变量a的地址向高地址方向增加了4个字节。

由于char类型的长度是一个字节，所以，原来ptr是指向数组a的第0号单元开始的四个字节，此时指向了数组a中从第4号单元开始的四个字节。我们可以用一个指针和一个循环来遍历一个数组，看例子： 例三： int array[20];int *ptr=array;...//此处略去为整型数组赋值的代码。...for(i=0;i<20;i++){(*ptr)++;ptr++； } 这个例子将整型数组中各个单元的值加1。由于每次循环都将指针ptr加1，所以每次循环都能访问数组的下一个单元。再看例子： 例四： 1。char a[20];2。int *ptr=a;......3。ptr+=5;在这个例子中，ptr被加上了5，编译器是这样处理的：将指针ptr的值加上5乘sizeof(int)，在32位程序中就是加上了5乘4=20。由于地址的单位是字节，故现在的ptr所指向的地址比起加5后的ptr所指向的地址来说，向高地址方向移动了20个字节。在这个例子中，没加5前的ptr指向数组a的第0号单元开始的四个字节，加5后，ptr已经指向了数组a的合法范围之外了。虽然这种情况在应用上会出问题，但在语法上却是可以的。这也体现出了指针的灵活性。如果上例中，ptr是被减去5，那么处理过程大同小异，只不过ptr的值是被减去5乘sizeof(int)，新的ptr指向的地址将比原来的ptr所指向的地址向低地址方向移动了20个字节。

总结一下，一个指针ptrold加上一个整数n后，结果是一个新的指针ptrnew，ptrnew的类型和ptrold的类型相同，ptrnew所指向的类型和ptrold所指向的类型也相同。ptrnew的值将比ptrold的值增加了n乘sizeof(ptrold所指向的类型)个字节。就是说，ptrnew所指向的内存区将比ptrold所指向的内存区向高地址方向移动了n乘sizeof(ptrold所指向的类型)个字节。一个指针ptrold减去一个整数n后，结果是一个新的指针ptrnew，ptrnew的类型和ptrold的类型相同，ptrnew所指向的类型和ptrold所指向的类型也相同。ptrnew的值将比ptrold的值减少了n乘sizeof(ptrold所指向的类型)个字节，就是说，ptrnew所指向的内存区将比ptrold所指向的内存区向低地址方向移动了n乘sizeof(ptrold所指向的类型)个字节。

第三章。运算符&和* 这里&是取地址运算符，*是...书上叫做“间接运算符”。&a的运算结果是一个指针，指针的类型是a的类型加个*，指针所指向的类型是a的类型，指针所指向的地址嘛，那就是a的地址。*p的运算结果就五花八门了。总之*p的结果是p所指向的东西，这个东西有这些特点：它的类型是p指向的类型，它所占用的地址是p所指向的地址。例五： int a=12;int b;int *p;int **ptr;p=&a;//&a的结果是一个指针，类型是int*，指向的类型是int，指向的地址是a的地址。

*p=24;//*p的结果，在这里它的类型是int，它所占用的地址是p所指向的地址，显然，*p就是变量a。

ptr=&p;//&p的结果是个指针，该指针的类型是p的类型加个*，在这里是int **。该指针所指向的类型是p的类型，这里是int*。该指针所指向的地址就是指针p自己的地址。

*ptr=&b;//*ptr是个指针，&b的结果也是个指针，且这两个指针的类型和所指向的类型是一样的，所以用&b来给*ptr赋值就是毫无问题的了。

**ptr=34;//*ptr的结果是ptr所指向的东西，在这里是一个指针，对这个指针再做一次*运算，结果就是一个int类型的变量。

第四章。指针表达式。

一个表达式的最后结果如果是一个指针，那么这个表达式就叫指针表达式。下面是一些指针表达式的例子： 例六： int a,b;int array[10];int *pa;pa=&a;//&a是一个指针表达式。

int**ptr=&pa;//&pa也是一个指针表达式。

*ptr=&b;//*ptr和&b都是指针表达式。

pa=array;pa++;//这也是指针表达式。例七： char*arr[20];char**parr=arr;//如果把arr看作指针的话，arr也是指针表达式 char*str;str=*parr;//*parr是指针表达式

str=*(parr+1);//*(parr+1)是指针表达式 str=*(parr+2);//*(parr+2)是指针表达式

由于指针表达式的结果是一个指针，所以指针表达式也具有指针所具有的四个要素：指针的类型，指针所指向的类型，指针指向的内存区，指针自身占据的内存。

好了，当一个指针表达式的结果指针已经明确地具有了指针自身占据的内存的话，这个指针表达式就是一个左值，否则就不是一个左值。在例七中，&a不是一个左值，因为它还没有占据明确的内存。*ptr是一个左值，因为*ptr这个指针已经占据了内存，其实*ptr就是指针pa，既然pa已经在内存中有了自己的位置，那么*ptr当然也有了自己的位置。

第五章。数组和指针的关系

数组的数组名其实可以看作一个指针。看下例： 例八：

int array[10]={0,1,2,3,4,5,6,7,8,9},value;......value=array[0];//也可写成：value=*array;value=array[3];//也可写成：value=*(array+3);value=array[4];//也可写成：value=*(array+4);

上例中，一般而言数组名array代表数组本身，类型是int [10]，但如果把array看做指针的话，它指向数组的第0个单元，类型是int*，所指向的类型是数组单元的类型即int。因此*array等于0就一点也不奇怪了。同理，array+3是一个指向数组第3个单元的指针，所以*(array+3)等于3。其它依此类推。例九： char*str[3]={ “Hello,thisisasample!”, “Hi,goodmorning.”, “Helloworld” };chars[80]；

strcpy(s,str[0]);//也可写成strcpy(s,*str);strcpy(s,str[1]);//也可写成strcpy(s,*(str+1));strcpy(s,str[2]);//也可写成strcpy(s,*(str+2));上例中，str是一个三单元的数组，该数组的每个单元都是一个指针，这些指针各指向一个字符串。把指针数组名str当作一个指针的话，它指向数组的第0号单元，它的类型是char**，它指向的类型是char*。*str也是一个指针，它的类型是char*，它所指向的类型是char，它指向的地址是字符串“Hello,thisisasample!”的第一个字符的地址，即''H''的地址。str+1也是一个指针，它指向数组的第1号单元，它的类型是char**，它指向的类型是char*。*(str+1)也是一个指针，它的类型是char*，它所指向的类型是char，它指向“Hi,goodmorning.”的第一个字符''H''，等等。下面总结一下数组的数组名的问题。声明了一个数组TYPEarray[n]，则数组名称array就有了两重含义：第一，它代表整个数组，它的类型是TYPE[n]；第二，它是一个指针，该指针的类型是TYPE*，该指针指向的类型是TYPE，也就是数组单元的类型，该指针指向的内存区就是数组第0号单元，该指针自己占有单独的内存区，注意它和数组第0号单元占据的内存区是不同的。该指针的值是不能修改的，即类似array++的表达式是错误的。在不同的表达式中数组名array可以扮演不同的角色。在表达式sizeof(array)中，数组名array代表数组本身，故这时sizeof函数 测出的是整个数组的大小。在表达式*array中，array扮演的是指针，因此这个表达式的结果就是数组第0号单元的值。sizeof(*array)测出的是数组单元的大小。表达式array+n（其中n=0，1，2，....。）中，array扮演的是指针，故array+n的结果是一个指针，它的类型是TYPE*，它指向的类型是TYPE，它指向数组第n号单元。故sizeof(array+n)测出的是指针类型的大小。例十： int array[10];int(*ptr)[10];ptr=&array;上例中ptr是一个指针，它的类型是int(*)[10]，他指向的类型是int[10]，我们用整个数组的首地址来初始化它。在语句ptr=&array中，array代表数组本身。

本节中提到了函数sizeof()，那么我来问一问，sizeof(指针名称)测出的究竟是指针自身类型的大小呢还是指针所指向的类型的大小？答案是前者。例如： int(*ptr)[10];则在32位程序中，有： sizeof(int(*)[10])==4 sizeof(int[10])==40 sizeof(ptr)==4 实际上，sizeof(对象)测出的都是对象自身的类型的大小，而不是别的什么类型的大小。

第六章。指针和结构类型的关系 可以声明一个指向结构类型对象的指针。例十一： struct MyStruct { int a;int b;int c;}MyStruct ss={20,30,40};//声明了结构对象ss，并把ss的三个成员初始化为20，30和40。MyStruct*ptr=&ss;//声明了一个指向结构对象ss的指针。它的类型是MyStruct*, //它指向的类型是MyStruct。

int *pstr=(int*)&ss;//声明了一个指向结构对象ss的指针。但是它的 //类型和它指向的类型和ptr是不同的。

请问怎样通过指针ptr来访问ss的三个成员变量？ 答案： ptr->a;ptr->b;ptr->c;又请问怎样通过指针pstr来访问ss的三个成员变量？ 答案：

*pstr；//访问了ss的成员a。*(pstr+1);//访问了ss的成员b。

*(pstr+2)//访问了ss的成员c。

呵呵，虽然我在我的MSVC++6.0上调式过上述代码，但是要知道，这样使用pstr来访问结构成员是不正规的，为了说明为什么不正规，让我们看看怎样通过指针来访问数组的各个单元： 例十二：

int array[3]={35,56,37};int*pa=array;通过指针pa访问数组array的三个单元的方法是： *pa;//访问了第0号单元 *(pa+1);//访问了第1号单元

*(pa+2);//访问了第2号单元

从格式上看倒是与通过指针访问结构成员的不正规方法的格式一样。所有的C编译器在排列数组的单元时，总是把各个数组单元存放在连续的存储区里，单元和单元之间没有空隙。但在存放结构对象的各个成员时，在某种编译环境下，可能会需要字对齐或双字对齐或者是别的什么对齐，需要在相邻两个成员之间加若干个“填充字节”，这就导致各个成员之间可能会有若干个字节的空隙。所以，在例十二中，即使*pstr访问到了结构对象ss的第一个成员变量a，也不能保证*(pstr+1)就一定能访问到结构成员b。因为成员a和成员b之间可能会有若干填充字节，说不定*(pstr+1)就正好访问到了这些填充字节呢。这也证明了指针的灵活性。要是你的目的就是想看看各个结构成员之间到底有没有填充字节，嘿，这倒是个不错的方法。通过指针访问结构成员的正确方法应该是象例十二中使用指针ptr的方法。

第七章。指针和函数的关系

可以把一个指针声明成为一个指向函数的指针。int fun1(char*,int);int(*pfun1)(char*,int);pfun1=fun1;........inta=(*pfun1)(“abcdefg”,7);//通过函数指针调用函数。

可以把指针作为函数的形参。在函数调用语句中，可以用指针表达式来作为实参。例十三： int fun(char*);int a;char str[]=“abcdefghijklmn”;a=fun(str);......int fun(char*s){ int num=0;while(*s!= ''''){ num+=*s;s++;} retur nnum;} 这个例子中的函数fun统计一个字符串中各个字符的ASCII码值之和。前面说了，数组的名字也是一个指针。在函数调用中，当把str作为实参传递给形参s后，实际是把str的值传递给了s，s所指向的地址就和str所指向的地址一致，但是str和s各自占用各自的存储空间。在函数体内对s进行自加1运算，并不意味着同时对str进行了自加1运算。

第八章。指针类型转换

当我们初始化一个指针或给一个指针赋值时，赋值号的左边是一个指针，赋值号的右边是一个指针表达式。在我们前面所举的例子中，绝大多数情况下，指针的类型和指针表达式的类型是一样的，指针所指向的类型和指针表达式所指向 的类型是一样的。例十四： 1。float f=12.3;2。float *fptr=&f;3。int*p;在上面的例子中，假如我们想让指针p指向实数f，应该怎么搞？是用下面的语句吗？ p=&f;不对。因为指针p的类型是int*，它指向的类型是int。

表达式&f的结果是一

个指针，指针的类型是float*,它指向的类型是float。两者不一致，直接赋值的方法是不行的。为了实现我们的目的，需要进行“强制类型转换”： p=(int*)&f;如果有一个指针p，我们需要把它的类型和所指向的类型改为TYEP*和TYPE，那么语法格式是：(TYPE*)p；

这样强制类型转换的结果是一个新指针，该新指针的类型是TYPE*，它指向的类型是TYPE，它指向的地址就是原指针指向的地址。而原来的指针p的一切属性都没有被修改。

一个函数如果使用了指针作为形参，那么在函数调用语句的实参和形参的结合过程中，也会发生指针类型的转换。例十五： void fun(char*);int a=125,b;fun((char*)&a);......void fun(char*s){ char c;c=*(s+3);*(s+3)=*(s+0);*(s+0)=c;c=*(s+2);*(s+2)=*(s+1);*(s+1)=c;}

注意这是一个32位程序，故int类型占了四个字节，char类型占一个字节。函数fun的作用是把一个整数的四个字节的顺序来个颠倒。注意到了吗？在函数调用语句中，实参&a的结果是一个指针，它的类型是int*，它指向的类型是int。形参这个指针的类型是char*，它指向的类型是char。这样，在实参和形参的结合过程中，我们必须进行一次从int*类型到char*类型的转换。结合这个例子，我们可以这样来想象编译器进行转换的过程：编译器先构造一个临时指针char*temp，然后执行temp=(char*)&a，最后再把temp的值传递给s。所以最后的结果是：s的类型是char*,它指向的类型是char，它指向的地址就是a的首地址。

我们已经知道，指针的值就是指针指向的地址，在32位程序中，指针的值其实是一个32位整数。那可不可以把一个整数当作指针的值直接赋给指针呢？就象下面的语句： unsigned int a;TYPE*ptr;//TYPE是int，char或结构类型等等类型。

......a=20345686;ptr=20345686;//我们的目的是要使指针ptr指向地址20345686（十进制）

ptr=a;//我们的目的是要使指针ptr指向地址20345686（十进制）

编译一下吧。结果发现后面两条语句全是错的。那么我们的目的就不能达到了吗？不，还有办法： unsignedinta;TYPE*ptr;//TYPE是int，char或结构类型等等类型。

......a=某个数，这个数必须代表一个合法的地址； ptr=(TYPE*)a；//呵呵，这就可以了。

严格说来这里的(TYPE*)和指针类型转换中的(TYPE*)还不一样。这里的(TYPE*)的意思是把无符号整数a的值当作一个地址来看待。上面强调了a的值必须代表一个合法的地址，否则的话，在你使用ptr的时候，就会出现非法操作错误。

想想能不能反过来，把指针指向的地址即指针的值当作一个整数取出来。完全可以。下面的例子演示了把一个指针的值当作一个整数取出来，然后再把这个整数当作一个地址赋给一个指针： 例十六： inta=123,b;int*ptr=&a;char*str;b=(int)ptr;//把指针ptr的值当作一个整数取出来。

str=(char*)b;//把这个整数的值当作一个地址赋给指针str。

好了，现在我们已经知道了，可以把指针的值当作一个整数取出来，也可以把一个整数值当作地址赋给一个指针。

第九章。指针的安全问题 看下面的例子： 例十七： char s=''a'';int*ptr;ptr=(int*)&s;*ptr=1298；

指针ptr是一个int*类型的指针，它指向的类型是int。它指向的地址就是s的首地址。在32位程序中，s占一个字节，int类型占四个字节。最后一条语句不但改变了s所占的一个字节，还把和s相临的高地址方向的三个字节也改变了。这三个字节是干什么的？只有编译程序知道，而写程序的人是不太可能知道的。也许这三个字节里存储了非常重要的数据，也许这三个字节里正好是程序的一条代码，而由于你对指针的马虎应用，这三个字节的值被改变了！这会造成崩溃性的错误。让我们再来看一例： 例十八： 1。char a;2。int*ptr=&a;......3。ptr++;4。*ptr=115;该例子完全可以通过编译，并能执行。但是看到没有？第3句对指针ptr进行自加1运算后，ptr指向了和整形变量a相邻的高地址方向的一块存储区。这块存储区里是什么？我们不知道。有可能它是一个非常重要的数据，甚至可能是一条代码。而第4句竟然往这片存储区里写入一个数据！这是严重的错误。所以在使用指针时，程序员心里必须非常清楚：我的指针究竟指向了哪里。

在用指针访问数组的时候，也要注意不要超出数组的低端和高端界限，否则也会造成类似的错误。

在指针的强制类型转换：ptr1=(TYPE*)ptr2中，如果sizeof(ptr2的类型)大于sizeof(ptr1的类型)，那么在使用指针ptr1来访问ptr2所指向的存储区时是安全的。如果sizeof(ptr2的类型)小于sizeof(ptr1的类型)，那么在使用指针ptr1 来访问ptr2所指向的存储区时是不安全的。至于为什么，读者结合例十七来想一想，应该会明白的。

第五篇：一个C++程序员的学习经历

正在上网的时候有这个念头的，所以急急忙忙找了一些学习编程的高人的感想：

我开始学VC时就是自己一个人在啃，也没什么人指导，当时没有条件上网，资料特别少，在书店里随便买本书就学了，在学VC的过程中走了许多弯路，现在回想起来觉得做了很多无用功。看见大家在这里畅所欲言，有高手也有新入门的ddmm，我也来谈谈学VC的一点“捷径”吧，这条“捷径”纯粹走的是C/C++的路子，不考虑学习其他语言。（我只会C/C++，略懂VB和Java，所以对于通过其他语言来切入VC的没有体验，不置评论）

1.必须对C/C++非常熟悉

如果C不熟，可以看清华谭浩强的书，经典之作。（学习时间1到2个月，对函数、指针和链表须滚瓜烂熟）

如果C++不熟，可以看电子工业出版社的《面向对象的程序设计于C++教程》，张国锋写的，既讲面向对象的思想又讲C++的语法，是我见过的讲C++最全最好的书，里面的例子都是精心设计的，值得好好体会。好像清华也出过一本张国锋的，不过我没看过。（学习时间2到4个月，关键在于理解OO概念和C++中的多态，对此应挥洒自如）

2.最好/应该对Windows结构相当熟悉。

如果你很牛，非要从MFC下手来了解Windows结构，当然也不是不可以，但我以为从MFC来学习Windows有雾里看花的感觉，很容易陷入迷惘中，我吃过这种苦头，希望后来者不要走这条路。

如果对Windows结构不熟，可以看Microsoft Press的Windosw95 Programing，清华翻译出版了中译本《Windows95程序设计》，后来北大翻译出版了最新的版本。清华版的译得不错，北大版的没看过，好坏不知道。这本书讲的是怎么样用C语言编写Windows程序，不讲什么MFC或OWL的，看过后对Windows能有相当清晰的认识。（学习时间3~6个月，GUI对象和消息很熟，多线程、dll有一定认识）

3.以上两部为准备工作，OK后就可以continue学习VC了。

学VC看Microsoft Press的《Inside Visual C++》清华翻译出版了中译本《Visual C++技术内幕（第四版）》比较容易上手，看《技术内幕》一定要看清华，有一本希望出版社翻译出版的第五版技术内幕翻译的太烂了，看希望的不如直接看英文原版。（学习时间4到7个月）

4.学习VC是为了在Windows平台下做开发，所以当你对一上三步都很熟后应该进一步深入学习Windows体系才能开发出高性能的Windows程序，你也只有在这个时候才会明白为什么说VC是真正程序员用的工具而VB只是玩具。如果你在finish第三步之后已经忘记怎样在Windows下用C语言编写一个Windows程序，那么你应该把第2步Refresh一下。在这一层次应该深入研究Windows操作系统内的进程、线程、虚拟内存等知识，还应该了解Windows网络程序的设计。这一步推荐的书是Microsoft Press的《Advanced Windows》清华翻译出版了此书的中译本《Windows高级程序设计（第三版）》，读此书时很多东西有相见恨晚的感觉。机械工业出版社翻译出版的《Windows核心编程》是这本书的第四版，结构上重新组织过了，内容没有细看过，应该还可以。网络编程有一本也是MicrosoftPress的，好像是叫《Windows Network Program》吧，机械工业出版社翻译出版了此书的中译本《Windows网络编程》还不错的。

5.往后你就看自己需要了，有兴趣可以学习COM/DCOM/COM+，这套东西是现在Windows系统的核心架构。

用VC学VC两年了，自认为不是什么高手，精通更谈不上了，因为VC的功能实在太强大了。我只想谈一谈自己的学习过程和体会，总结一下自己的编程之路。

一开始也和大家一样，对VC、VB、DELPHI、JAVA非常感兴趣，但是学什么好呢？毕业设计来了，导师要求要么用VB要么用VC，听说VC难学但很有用，于是狠狠心用VC吧。对于一个对编程一点都不感兴趣的人我想他是学不好的，没有强烈的动力和恒心也很难掌握一门知识。怎么办呢？你总要毕业吧，这就是我的驱动力，而且编程还可以挣钱：），学吧！

对于一个一点都不懂的人来说，下面的知识应该补一补：程序算法和数据结构，C语言的变量、数组、指针、内存、文件、函数等等基本概念和用法，有的人说学c++可以不用学c，我个人认为还是从C学起好，因为c＋＋对c是兼容的。

有了最根本的编程基础之后，我们就可以学习c＋＋的编程思想，就是面向对象（oo），自然对于什么是类、对象、成员、成员函数、构造函数、析构函数、虚函数、模板，最开始可能用不上析构函数虚函数什么的，但要想精通深入就必须掌握（当然可以以后再学）。可以说面向对象是c＋＋对c的一个最重要的扩展，而这也恰恰是我们理解和深入的基础，这部分越扎实以后理解和掌握就越快。

再下来就是MFC了，MFC是一个很好的封装类库，它诚如大家所说对用户屏蔽了很多实现机制，以致很多人只知其所以然，而不知其然。要想知其所以然，当然是学习windows编程，熟悉windows的消息、窗口、api函数。可惜当初我只是为了快，没有深入地学，留下了现在地恶果，对MFC及其机制仍不甚明了。一则MFC已经封装好了，二则自己觉得麻烦和累，一大堆长长的函数名和长长的函数参数把我吓晕了，大家千万不要学我^-^。基本观点就是如果只求使用，不学api也可以，如果想做得更好精通，非学不可。对于MFC，对我帮助最大是www.xiexiebang.com、程序员大本营、和MSDN，有了这三大法宝加上自己的刻苦钻研，一定可以成为大虾。前提是有一定的英文基础，并且已经知道如MFC frame及application的基本运行机制，对对话框、编辑框、组合框、列表框、进度条、标签.......等控件的基本功能都自己试过。我就是从这些开始学习MFC的，另外还学了一些和数据库打叫道的东东，如ODBC之类的，我觉得如果仅仅是界面开发，这些东西还是可以胜任的，都是些简单易学的在哪里设置什么属性，添加变量和调用成员函数就行了，不笨的人都会，当然如果你不知道在哪里加又会变得很神秘和难于上青天，夸张了呵呵。这时候你就要查书问别人上internet和帮助网站去找了，具体成员函数的用法可以看MSDN。总之对于没有学api耿耿于怀，对于没有了解MFC机制也愧疚于心，因此把自己归于初级水平还是可以的：

VC是一个开发工具和环境，在你需要的时候你可以边学边用。比如你要编网络方面的东东，好！先去看看别人是怎么做的，有哪些基础，另外你自己也要针对需求学一些网络知识。微软的主页还是不错的，英文好的话可以找到很多很好的东东。你要编关于数据库的程序，请先了解一下数据库的基本概念和它们在VC中的使用。你可能还有各种各样的编程需求，如游戏、小程序、动态连接库、静态连接库，COM,ActiveX等等，学习吧，这是唯一的捷径。我的体会是，边学边用，边用边学。学习先打好一定的基础，磨刀不误砍柴功，看似浪费时间实则受益匪浅。学习要利用一切可以利用的资源，书（包括电子的，不过我很少看电子版本）、BBS、网站（比如VChelp）和高手，勤学好问，搜索不倦，想必你肯定也会成为高手的：）。书我是狂看、乱看、瞎看，主要是没有条件和时间，当时也没人指点应该看那一本好书，原则就是找到自己需要的东西的书就可以拿来翻一番（当然我有图书馆这个资源，学生借本书应该没有问题的）。BBS主要去精华区溜达溜达，里面都会有你要问的一般性问题，如果实在找不到答案，请去codeguru，微软网站和MSDN查找搜索，应该可以找到蛛丝马迹。这样还是很费精，如果有高手指点就不一样了，他们做过的话，这可能就是小差一叠，随便说一个关键词就可以帮了你的大忙，可惜高手毕竟是少数，正好碰上做过的高手的概率就更小了。所以各式各样的网站就显得那么的重要，它们一天二十四小时都在，而且可能是很多高手都在，因此在它们身上可以找到一些参考答案。问专家我觉得不错，VChelp更全面和包罗万象。说了这么多，都是自己的胡思乱想了，一点个人体会，不当之处，各位多多批评指正了*^-^*

下面是我的一些建议,如有不对,请批评指正.谢谢!我想现在大部分的初学者都在问,怎么样学C/C++最快?确实,这是个比较重要的问题,但对于初学者来说,最重要的,是你对学习C/C++的恒心!学习C/C++并不容易,我想这是每个初学者很清楚的事情.之所以选中C/C++是因为它的涉及面广,并且强大.但自学想很快掌握C/C++编程那是不太可能的,除非你是个天才,或有专家专门对你进行辅导.如果学习方法和路线正确,的确可以提升学习的速度和效率.下面是我对怎样学习C/C++的一些看法.总共分三步.第一步.系统的学习C/C++语言,(不要涉及MFC.)并且学习操作系统,对操作系统的运作有清楚的概念.这一阶段,可以把重心放到研究算法上.(估计时间将会是一年.如果有人帮助的话,可能会减短.)第二步.开始学习MFC,并选择发展的方向.一个程序员,很难做到各方面的编程技术都精通,所以要有选择的学习你感兴趣或有钱途的技术发展.如果做游戏,则可放弃对于MFC的学习,因为游戏不需要MFC.(估计时间将会是半年.)第三步.开始对各种技术的涉及.因为本人还没有考虑到这一步,所以,不做多提,但如果你已经学到了这一步,也不用我再废话了.(时间未定.)当然,以上的时间估计,是在假设你努力学习的情况下定的,并不具有实际意义.对于书籍的选择,有很多人想用电子书.我提议,如果是初学,最好不要用电子书,来学习.还有些初学者对于编程工具不知如何选择.我想无论是C或者是C++,VC都是一种不错的选择.如果机器配制不高,可以使用版本低的VC.VC1.52版本是个不错的选择.我在工作中，接触到印度软件公司开发出来的软件：整个体系架构非常清晰，按照我们的要求实现了全部功能，而且相当稳定。但是打开具体的代码一看，拖沓冗长，水平不咋样。我们自己的一些程序员就有怪话了，说他们水平真低。

但是！印度人能够把软件整体把握得很好，能够完成软件，并得到相当好的设计文档。而中国人在那里琢磨数据结构、算法，界面人员就还没编码就想着是Outlook式的还是VisualStudio式的界面。到最后就成为Code高手，对某些特定的开发工具精通，但是就是不能保证能够把一个软件稳当、完整的开发出来。

举个简单的例子：软件中需要一个列表，用来表示我们处理的事务。该类表在业务繁忙的时候将变得很大。中国人就用双向链表，抱着《数据结构》书在那里写链表的类。印度人开了一个大数组，然后就开始干。为什么印度人不用链表，他们说：

1、你们给出的设备(小型机)，最少具备512M内存，浪费一些没有什么。

2、数组方式访问方便、效率高。看出了一拿到东西就吭哧吭哧作Code，和好好进行软件分析的不同了吗？ 正好前几天我有几个同事从印度回来和我们交流,那家公司是CMM4级公司.我感受的几点:1,流程重于项目2,QC(就是QA)独立于研发部门,专门检查研发部门的开发流程是不是按照既定流程走.如果QC觉得流程不对,他会直接上报高层,项目定就此停止.3,所谓的项目经理(PC)一般也是从编码人员升上来的,并不是所谓的不懂技术,一般都至少有四年以上的经验4,PC主要就是制定开发计划,负责协调,填写各种表格.5,所有的东西(包括草稿)都有文档.6,详细文档要求达到只有这个文档就可以编码的程度,一般写文档时间占60,编码时间极少7,有各种详细的review(同行评审),项目组内的,项目组之间的,客户的...8,计划很详细,的确能达到小时级,但是实际情况还是误差比较大,所以他们也有加班.先学习UML和Rose以及RU P，不要总是要找着证据。在中国的软件开发水平下，很难给你一个好的例子，OK？中国人总是要看到一个东西有了试验田，而且稻子长得好，才换稻种。要知道在国外上述的软件开发模式的应用，大可以看看Rational网页上的story。Justdoit!一句话，中国的软件开发水平低得很。赶不上印度人，印度的软件公司可以让高中生编代码，它的软件工程水平可想而知。当然，你如果是个很牛的程序员。估计够呛，因为中国的气氛中，很牛的程序员都很难接受软件工程的。你可以测试一下自己，看看自己适不适合现在学习软件工程：

1、你是不是不能忍受一个编程序不如你的人做你的项目经理？

2、你是不是觉得你的老板对客户吹牛皮、夸大自己而感到不舒服?

3、你是不是一个拿到一个需求脑袋里第一念头就是如何实现的人？

4、你是不是很崇拜Stallman，Linus，很讨厌Microsoft?

5、你是不是曾经在深夜编码的时候，突然感觉到一种乏味，对Code的生涯感到一种无趣？以管窥豹──印度神话作者：“Kino”我们现在处于深深的自卑当中，感到中国的软件工程水平的低下已经是牵涉到民族劣根性的问题了。

1、他们的软件教育水平：我们招聘印度人，给应聘者出了一份与国内差不多的试卷，有基础概念和编程题目。等到他们完成后，我们这些中国的自认高手惊呆了！他们的编程题目简直象是抄袭的?nbsp;?nbsp;程序结构，注释，变量命名就不说了吧，全部都是极其类似！反观中国的牛人、高手，每个人有自己的一套。到了新的岗位，先把前任的程序贬损一通，然后自己再开发更多的问题的代码来代替。我的公司统计，一个软件中有4个以上CSocket版本，每个人都觉得别人做得差，自己再搞一套。中国人，就是这个样子，还会辩解说“我们这样有创造性”。

其实软件发展，早就走过了求伯君那个编码英雄的年代，程序员已经是个坐办公室的蓝领了。你具备拧好一个螺丝钉的能力就可以了。Code是最低级的事情 了。

2、他们许多公司的项目经理根本就不懂技术。中国的项目经理如果不能在技术上压服下属，那么下属将与他搞鬼，越是高手越喜欢搞鬼，根本不知道作软件的终极目的是从别人兜里掏钱，而在内部搞不团结。技术高手都会纠集一些对他技术上崇拜的菜鸟，与管理层作对。而印度的软件经理根本就不懂正在做的东西，许多甚至直接就是MBA，或者是领域专家(工业设计、地理专家等)，而不是编码 的专家。但是却能够领导大群素质良好的程序员把工作做好，没有内部不团结的情况。许多印度的程序员加入一个公司很长时间，都不知道自己整天编的代码是干什么用的。给他们的任务可能就是一个函数的声明以及该函数要实现的功能。我们呢？

3、他们的编程人员的流动率达到30!他们的编程人员流动率(包括内部项目之间的流动)高达30，可以想见他们的文档水平如何。他们的产品不依赖任何一个人，谁都可以立即辞职，产品的开发还是会正常进行。而中国，是老板怕总工。技术骨干拥兵自重，抗拒管理。任何制定好的计划，都有可能被技术人员推翻或者跟你消极怠工。

4、他们的开发计划能够做到小时级别。如果一个印度公司的项目经理没有上班，那么他的下属将可能不知道作什么。他们的计划一般都定到天，每个基层开发人员每天的工作量就是8小时。而我们能够给出月度计划的 公司就很少，而给出的月度计划要么不可能实现，要么就可能被取消。开发人员 被初略的给个任务，他在月初，可以慢慢琢磨是做成什么样子，然后上上网，聊聊天。到了月中和月末，就开始熬夜编码。看到每年，从各大高校不尽牛人滚滚来，我们是不得不要召人，同时又是不抱希望。我公司现在有意以后将核心软件开发外包给印度公司，中国人？做做界面吧，中国人做界面会极尽奇技淫巧，搞得花里胡哨的。BTW，我公司非外企，大家不要误会我们有什么种族歧视。但是我们现在就是对自己歧视，自卑得很。中科院那么多研究院，连个能用的操作系统都搞不定。北大开发一些东西，比如什么青鸟CASE，就是给一帮人评职称的。杨芙清院士整天搞来搞去，搞出了什么东西？B大，T大的人最难管理，牛得看不见人。中国的程序员骂微软，追Linux是全世界最狠的，可是我们除了汉化Linux，做了什么东西出来。CDE是瑞典人写的，Linus是芬兰的，GNome是墨西哥人写的。哎，我们曾经是多么的瞧不起印度人。

现在，越来越多的人开始学习VC了，如果能精通VC，就象精通了九阴真经一样，可以天下无敌了。我想很多VC爱好者都有这种追求武学至高境界的心理。

我就是抱着这种心理开始学习VC了，至今已近三年了，其间经历过无数的困惑和磨难.....可是我最终没有放弃，到如今已经有一定的功力 ：

以下就把我修炼中获得的经验与大家分享，一起提升修行！

首先要搞清楚VC能干什么.很多人只是听说VC是最好的开发语言，便去学习，就象大家听说辟邪剑谱厉害，便都去抢着学一样，都是很盲目的。其实语言并没有好坏之分，我在用C之前，一直觉的BASIC 是最好用的语言。现在在WINDOWS平台下编程，VB和DELPHI可以满足大多数的应用，而且速度不会很慢。使用VC主要是用来开发系统软件和大型工具软件以及开发游戏。现在比较流行的操作系统主要是WINDOWS系列和UNIX系列。这些操作系统都是复杂的多任务系统，在设计操作系统的时候就提供了一大堆应用编程接口（API，通常是C语言的函数），编程者使用C语言调用这些API便可以开发该系统下的应用程序了。这与DOS时代的 编程接口是不一样的，那时侯的函数库是由开发环境提供的（如Turbo C)，不具有很好的封装性和设备无关性。

每当新版的WINDOWS操作系统发行，便会提供一个相应的plantform SDK(软件开发包），开发者可以用SDK 编译C程序。在没有VC和VB的时候，WINDOWS程序就是用SDK编出来的。

VC跟这些乱七八糟的东西有什么关系呢？

其实VC的核心就是MFC，MFC是个C++类库，就象结构化程序设计时代的C语言函数库一样，给程序员提供了丰富的编程接口，简化了程序的设计。而MFC就是直接把WINDOWS的C语言编程接口API函数用C++的类封装而成！这样既实现了面向对象的编程思想，又直接使用了WINDOWS的原始编程接口，代码的效率是 最高的！当然很多人不适应C++的编程方法，他们依然使用C语言编写WinMain()和窗口 过程，VC同样为他们提供了很大的便利，因为VC可以很方便的管理资源和代码！

明白了以上关系，学习VC的步骤应该也明确了：首先要学习C语言（如果你还不会的话）！这是非常重要的。如果C语言不懂的话，一切都无从谈起。懂了C语言，你就可以研究 WINDOWS系统的工作原理和WINDOWS应用程序的工作原理了。这也非常重要。VC只能用来 开发WINDOWS系列操作系统下的应用程序，如果不懂WINDOWS下的程序的工作原理就去写WINDOWS 程序，那也是比较盲目的。主要是体会一下WINDOWS的多任务和消息驱动机制。然后就可以使用API编程了。这个过程是比较痛苦的，因为一切都变的复杂起来，你会遇到很多新的方法和概念！比如消息队列，消息发送，窗口过程，GDI，设备上下文，句柄，线程，消息循环，绘图对象......当你可以熟练的使用C语言进行WINDOWS程序设计了，你可以尝试 面向对象的方法了。

这时你需要学习C++语言（最好是ANSI C++），这不是浅尝则止，你要深入的理解C++语言的精髓！经过一定的努力，你可以用面向对象的思想去考虑问题了，这时一切都水道渠成，你可以很自然的使用MFC来编程了，有时你觉的MFC的类不好用，你可以从头作自己的类，而不去继承 MFC！

我每天要收到很多朋友的来信，有很大一部分朋友都询问学习VC的方法和途径，还有相当一些朋友对C/C++语言的前途感到担心，总觉得学习C语言在开发效率上没有赶上其他的开发工具，今天我就借“开发有感”这个栏目谈谈我的一些浅见。

首先来讲我使用C/C++语言开发已经有六年多的时间了，在使用C以前我是用汇编语言的所以我转变到C时就很自然和顺利。但就目前的情况来讲大家都不再需要学习汇编语言了，所以在进入C语言的世界时就会遇到一些困难这主要表现在指针的使用上。由于没有亲身的经历所以我很难想象这个困难有多大，但我在这点上的建议就是开始时尽量避免使用指针，至于一些必须使用指针的C函数只要记住用法就可以了。当然这种情况不会持续太久，因为但你对语言的熟悉程度增加后自然也就会有使用指针进行开发的需求，那时候如果对指针的用法还没有深刻的了解再学习也很容易，这就是主动学习与被动学习的区别。

其次很多朋友都问我如何学好VC，我想对于初学者首先应该掌握的是C/C++，VC只是C/C++的一种开发工具。如果是刚接触C/C++则最好不要使用VC做为开发工具，因为VC的各种特性会分散你的注意力。我建议使用Turbo C++或Boland C++集成平台做为开发工具，这两个平台虽然都是DOS下的但是对于初学者真是在适合不过了（当然MSC也可以）。

此外刚开始时开发一些字符界面的程序（也可以说是DOS程序，Console控制台程序）来加深对语言的熟悉。在掌握了C/C++语言后就可以开始利用VC编写基于Windows的窗口程序了，这时候就是一个转折点，因为这时候Windows系统是基于消息机制的，这和单流程的程序有些区别。所以这时候也不要急着去写学习开发和写代码而是应该先对Windows系统的消息机制做一些了解然后才开始学写程序。其实我的主张是一开始用基本的SDK形式（也就是用WinMain函数的那种，不用MFC功能）来开发几个程序做为入门，然后再使用MFC来开发程序。MFC开发的方式与SDK开发方式的最大区别就是MFC隐藏了很多细节，这是优点也是缺点对于初学者来讲我认为是一个缺点，所以我建议初学者先用WinMain的形式写程序，即使不亲手写也可以看几个基本的程序来加深认识。

上面这些话都是为了说明一个问题“磨刀不误砍柴工”，学习开发一定要打好基础，还有一点就是一定要想办法激发自己的学习积极性让自己进入一个主动学习的境界。

下面我再分析一下C/C++与其他开发语言之间的差别，C/C++，(object)PASCAL，JAVA，PERL都是我认为比较通用而且是比较好的开发语言，但C的语法比PASCAL自由，PASCAL开发比其他结构化强，但这一点上C语言也能够做到。至于JAVA和C++非常类似而且能够跨平台这一点上是很大的优势，但JAVA开发的程序效率差。PERL也是一中我很喜欢的开发语言，虽然PERL没有面向对象的特性（至少我认为它的面向对象很糟糕）但我喜欢PERL中自由的语法和各种时常让人感到惊奇的用法。

如果说到Windows下的可视化开发工具现在大家接触得最多的就是VC，VB，DELPHI，BCB，一些可视化开发的JAVA。其实我觉得VC并不能完全算是一个可视化工具，这表现在VC中编写代码还是占了开发工作的大部分时间。而其他的可视化工具中都在界面设计中耗费了大量的开发时间。我一直使用VC的原因就是因为我能够一直将注意力集中在软件功能开发上而不是界面设计上。我认为这样能够在开发的过程中更加自由和有更多的控制权。而且这种情况下产生的代码维护性更强。举个简单的例子，在维护VB代码时如果没有一份详细的说明和流程就会使维护变得不可能，我想其他的基于界面开发的工具都会或多或少的产生这样的问题，因为在开发过程中开发工具将一个完整的流程分离成为多个部分，在开发完成后这些部分就很难统一起来。

选择什么样的工具的前提是你的开发目标，如果你希望开发一个很大的系统你就不应该选择面向基于界面开发的工具，但你可能会选择VB来开发前端的客户软件，而后台使用VC来实现。

对于一些并不是很复杂的软件来讲，界面和操作方式可能是非常重要的，所以选择VB，CBC都可以缩短开发时间。这时候选择VC就有些不智。

所以我认为使用VC开发的朋友应该将更多的注意力集中在实现软件功能的流程上，多从整体角度看问题。我想这一点来说其他的可视化开发工具是很难达到的，因为VB，CBC等开发的程序在很大程度上都是用各种控件“堆”出来的，这会在后期的维护升级过程中带来很多的不便，例如要替换掉一个控件就可能会对整个程序的结构产生非常大的影响。

最后我想说的是每种开发工具都有它的价值，也各有优缺点，更重要的是如何根据具体的任务选择合适的工具并利用这些工具来完成工作。

软件开发高手：十年磨一剑

要成为武林高手，需要长时间的勤学苦练。要成为软件开发高手，又需要多长时间呢？《Modern C++ Design》的作者Andrei Alexandrescu认为：一个人有可能在２０几岁就成为编程高手，但要成为设计高手却需要熬到３５岁左右。以２３岁大学毕业计算，要经过漫长的１２年时间。

以我个人为例（我尚不敢自认是设计高手），２２岁大学毕业后，在某研究所用８０８６汇编语言写一些小规模的程序，颇觉得心应手。凡是能用流传图表示的问题，都似乎不在话下。工作中，与同事共同切磋结构化程序设计，并能有意识地用于实践中。

三年后，承接一个纵向课题：在Windows上开发一个交互式排版系统。用Windows SDK开发。兴奋之余，自然想起用结构化方法进行设计：把整个系统当成一个黑盒子（black box），输出当然是排版结果，不管是什么格式，输入是···。我卡住了。难道用户操作是输入吗？但用户操作有那么多，怎么表示呢？系统的数据流图该怎么画？数据字典该怎么写？和同事讨论n次后，仍不得其解。懊丧之余，先模仿Quark Express搭个界面吧。然后研究排版算法。程序结构经过至少三次大规模修改，终于能排出一些版式，并在两年后通过了鉴定（鉴定后当然是将其束之高阁）。我从中体会到结构化开发方法不适合开发交互式系统。在开发初期，你不太可能正确地画出数据流图，而结构化设计方法完全依赖数据流图。数据流图发生改变，整个程序结构就要随之改变。

后来，加入一家合资公司，担任开发组长，有五、六个组员。这时我已读过了邵维忠等译的《面向对象的分析》、杨芙清等编译的《面向对象的设计》和《Code Complete》中译本。对面向对象的程序设计虽有所了解但仍是一知半解。

首先，我们用MSVC 1.5开发一个图形编辑软件。我用纸画了20几张对象图，与同事讨论通过后，开始编程。有人负责数据模型，有人负责用户界面，有人负责图形显示。几个月后，老板已可向潜在用户进行展示，反应良好。老板和开发人员都被一种兴奋的心情笼罩着。我们不断地加新功能，老板不时地到展览会上做演示。功能加齐了，开始让潜在用户试用。老板和我们都松了一口气：就剩下改错了，咱们是兵来将挡、水来土屯，没什么可怕的。错误报告来了。我们信心满满地开始查错改错。有些错误很快地被改掉了。但最后我们发现错误源源不断。改了一个错误有可能引起别的错误。软件永远达不到能用的地步。最后，时机被错过。该软件不得不被砍掉。懊丧之余，我们做了反省。大家都认为应尽早改错。同时模模糊糊地觉得数据模型和用户界面的程序一定要严格分开，否则程序极难修改。

后来，我们又开发一个类似Adobe Acrobat Exchange的PDF文件浏览器兼编辑器（当时Acrobat Exchange还不能显示中、日、韩文）。这时，老板带来一些过期的《C/C++ Users’ Journal》《Dr.Dobbs’ Journal》杂志。从书评中，我被几本书吸引住了。一本是James Rumbough等著的《Object-Oriented Modeling and Design》，一本是现在大名鼎鼎的《Design Patterns》，还有就是Scott Meyers著的《Effective C++》和《More Effective C++》。我劝说老板买了这几本书，并撺掇他买了一个CASE（计算机辅助软件工程）工具：Select OMT 仔细研读这几本书后，颇有顿开茅塞之感。最大的收获在于了解到降低类之间耦合度的重要性。一个类的实现细节发生变化，不应该影响使用该类的其它类的内部实现。更妙的是有不少Design Pattern能马上用到我们的软件中。

我用Select OMT软件画了一些高层的类图、状态图和数据流图等，并让同事们审查。同事们都觉得通过这些图对软件的总体设计有了更好的把握。在写程序的过程中，我们不断调整程序结构以尽可能减小类之间的耦合度。老板很早就安排了专职测试人员。发现问题，马上修改。一年后，我们的软件终于通过了用户的试用，卖出去了。当时，我可说是信心满满。

此后，我做了一年半多媒体编程。发现还是对系统开发更感兴趣。于是加入了Quark软件公司，开发一个基于CORBA的文件管理系统。这是我第一次参与异地开发，也是第一次大规模使用STL。我惊叹于STL设计之妙，同时也对自己的信心打了折扣。此后，我阅读了Martin Fowler著的《UML Distilled》、Bertrand Meyer著的《Object Oriented Software Construction》等书籍。并开始使用Rational Rose。Quark公司的技术文档管理、设计复查、代码复查、质量管理以及德国人（Quark公司德国分公司）严谨的工作态度都给我留下了深刻印象。

项目组下分开发组和测试组。开发组中有一个４到５人组成的设计小组负责软件总体设计，其中一个人负责技术文档，确保文档反映最新的设计。定期进行设计复查。复查时，项目组成员全部参加，并可提出问题或建议。得出结论后，马上付诸实施。开发组下又设若干小组。小组内定期进行代码复查。由组长选出每个组员的源文件，交其他组员复查，尽量挑出所有的毛病。如果代码太次，要打回从新写过。代码复查既能保证软件质量，又是大家学习的一个机会。

一年半后，我离开Quark，加盟Sybase，参与PowerBuilder的维护和新版本的开发。这是我第一次参与软件维护，令我认识到软件维护的重要性，认识到编写可维护的代码是软件开发的一个重要课题。Sybase系统化的质量跟踪系统和用户支援系统让我获益匪浅。在此期间，我阅读了《Large-scale Software Development in C++》、Martin Fowler著的《Refectoring》、Andrei Alexandrescu著的《Modern C++ Design》，Herb Sutter著的《Exceptional C++》和《More exceptional C++》，以及Kent Beck著的《Extreme Programming Explained》等书籍。对软件开发与维护有了进一步了解，但同时也更认识到软件开发之难。

回想十几年蹒跚走过的路，好像也略有所悟。试总结出以供参考：

1）要熟练掌握至少一种编程语言。我觉得最好是C++。掌握了C++，学习其它语言如Java或C#等并非难事，因为各种面向对象的程序语言尽管在语法上可能有很大区别，在语义上却大同小异。

2）不要寄希望于一次就把软件设计好。在开发初期，要尽量用最简单的设计实现最基本的功能，以使你的软件尽早地能实际运行，不要过于拘泥于细节。这样你才能尽早得到反馈，才能更直观更全面地理解你所面对的问题。你所关注的重点应依次是Make it work, make it right, make it fast。

3）软件结构要分块分层。低层模块不要依赖于上层模块。一个类、一个接口或一个函数都应只做一件事。没有本质联系的类或接口就不应有耦合关系。举例而言，要用MVC（Model View Controller）Design Pattern切断用户界面与数据模型之间的直接关联。

4）软件设计的主要工作是给类分配责任（responsibilities）。尽量不要把类设计成控制者（controller），而要设计成协调者（coordinator）。控制者凡事自己做，协调者让别人做。控制者的逻辑往往很复杂，难于维护；协调者逻辑简单，易于维护。要站在类的使用者角度设计类的外部行为。要讲究一点软件美学，即简单、清晰、一致、平衡等。

5）了解并运用UML、Design Patterns、Unit Test、Design by Contract等。6）使用代码管理系统和质量跟踪系统。

7）了解各种软件开发过程控制方法，并找出适合你的方法。8）阅读经典书籍，研读经典代码，订阅杂志，与同行切磋。

在这行越久越觉得软件开发难。软件开发历史还很短，才50年，还不是一门系统化的学科。有些人甚至认为软件设计与编程是一门艺术。但软件艺术大师还太少，而且我们很难直接欣赏到他们的杰作，除非所有的设计文档和代码都公开。软件更容易藏污纳垢。一个用户界面很漂亮的软件，内部设计和代码却很可能臭不可闻。一个地板倾斜、墙壁裂缝、屋顶漏水的房子没有人会买。一个设计很烂的软件却可能卖得不错。但这样的软件能撑多久呢？ 软件设计与编程已经很难，而这仅仅是软件开发的一个方面，软件开发过程控制也很难，也许更难。成为软件开发高手要走一条漫长的路，何日才能仗剑走天涯？