gp编程思想

‘壹’ 小弟初学C++，想请教一个问题，请各位大侠指点，谢谢。

提供C++资料下载地址： http://jian.blog.itchina8.com/blog.php?uid-148-dirid-2.html

http://tanjieyi.91i.net/C++teaching.htm
上面有下载课件

一个学习STL的地方
参考资料：http://www.stlchina.org/

http://club.cnfan.net/forums/2020/ShowPost.aspx

可以下

最经典的c＋＋书： c++ primer.无论在哪里都会被称为圣经！

清华大学出版社的钱能编的C++的书

http://www.7351.cn/Soft/shipxiazai/200507/392.html

http://wstatic.xunlei.com/index2.htm?search=C++视频教程
http://www.521n.com/Software/Catalog53/471.html
自己下载吧试试看

<<essential C++>>是本好书, 作者Stan Lippman, 现任Microsoft Visual C++ 开发组的系统架构师, 此书简短, 非常适合入门,中文版侯捷翻译的如何,由于我没看过, 不好乱说, 不过其他侯捷译的书还是不错的.
另外,可以配合<<primer C++>>看, 同一作者, 中文版好像是潘爱民译(他译的书都很好)的吧, 很厚, 很全面, 可以作参考
另外, <<Thingking in C++>> 也很好, 可惜中文版译的不怎么样, 我看的是原版, 很不错.
<<the C++ programming language>>C++圣经, C++之父写,中文版裘宗燕译的, 我认为译的很好,此书较深, 不适合入门, 用来精通
另外<<C++沉思录>>也不错, 经典, 不是入门的, 以后学习.
学C++, 看这些书足以!~~~~~~~~都是大家写的, 十分优秀.
推荐: <<C++ primer>> + <<the C++ programming language>>+课外读物<<C++沉思录>> = C++牛人
呵呵!~~ 看自己需要了~~~

有人认为后期的C++趋向学院派风格,走进了一味追求技术和难度的误区,
逐渐脱离主流的Programmers.
有人认为C++由于复杂度导致在现代软件工程中的地盘不断缩水.
也有人认为,C++无任对特定领域应用还是研究来说,都足够的优秀.

一、面对Object-Pascal、java、C#等语言,还需要C++ ?

首先,就方法学来说,不可否认,OO方法学本身具有构造的系统随着工程的进行复杂
度膨胀速度惊人.而且,对于上点规模的工程,为了构建OO系统,在OOA、OOD阶段,设计
者需要极高的水准.而以OOP为一典范亦作为OOP代表的C++在语法语义的设计上明显采用为了功能而不惜增加设计复杂度的策略.然而这一切的复杂,自然带来了好处,包括系统的可扩展性、可重用性等.这里好象存在一层很微妙的关系,上规模的系统为了可扩展性、可重用性等优点选择OO方法学,然而在OOA、OOD阶段就需要极大的投入(也许在00方法学中,A和D在软件工程中的地位体现的更明显吧~).

这个世界关于语言之间的讨论可能时刻进行着,个人一直认为：
1.首先每种语言有自己的适用领域,就应用而言,没有必要将语言勉强的拿到一起比较.
构建企业信息系统,自然会选择Java、dotNET或其它的方案(事实上,这种系统一般应
该多种语言协同开发,以获得部件性能最佳).可能多种语言同适合某个项目,那么具体就自己裁决了.譬如做一个信息管理系统,选择C++环境的绝对很少,PB或Delphi、VB都是不错的选择.在初学习阶段"因爱而选(更多的具有偶然性或者与身处环境有关)"、对于开发者基本是"因用而选".在成熟后,"因用而学"我感觉是根本也是最实际的指导原则.

2.关于语言复杂度的问题:语言是工具,是不需要也不能太复杂的.我一直支持语言应该朝专业化(这里指针对义务和特定应用场合)和简单化方向发展.这才是语言的本质之所在.业务是软件实施的根本.对于软件开发着来说很多情况下,业务是最难搞定的,或者说,用软件来真实细致安全的模拟业务是很困难的.前几天,学籍管理科的老师还跟我说,他们的一个学籍管理软件让两个研究生不断的完善,三年才算[完全符合他的业务要求].如果你只是耳闻某某语言何等的复杂、难学而学之,那么可能你错了~就个人而言,为了技术而技术是不可取的:)

3.然而这个世界是现实的,不如你想象的那样.并不是所有领域都有简单、强大、贴近业务 的语言.在这个层次上说,对于献身企业级信息应用系统开发者,Java、C#、Object-Pascal等的确是福音~~然而在系统软件和其它对性能、控制程度要求较高的如
工控系统、高性能计算，实时系统，军用软件等领域可就缺不了C++(C)(不过这些领域 明显的专业知识占绝对部分的重量).可见,紧从语言上说,C++(C)依然占据着一片天地. 严格来讲,C是作为C++的一竞争对手出现的(不管这些了:)).

二、C++是否真的走进了追求技术的误区

自从,GP思想在C++上的第一个作品STL正式纳入标准库,关于C++走进技术误区的流言便没有停止过,Boost、作为GP领军人物之一的Andrei Alexandrescu提倡并实践着(Loki)的编译时编程、将设计模式思想引入库设计,使得流言快被提上日程讨论了:).
然而,GP真的只是技术吗?我一直认为,就OO来说,本人曾经作过这样的思考：
-----------------------------------------------------------------------------
真正的对象应该至少能够具有：自主的适应环境(维护足够的"意识")
1.自发行为的意识更强
2.反应能力更强
3.对外有足够的独立性
现在的OO,更像是建立在PO上的,不过是对象代替了函数.
但事实上,无论对象能力多高,过程表现绝对少不了.

Agent ：我想是表达和反应能力最强的.
COM ： 比Object-Based手法构造出的对象表达、反应、适应能力高很多.
不过There is no magic.还不过是一般的技巧构造出来的,看透了什么都没有了:)
GP ：不能将它看作无谓的技术追求,[从我们谈论的这个节点看来,它的实质我认为[至
少]是]：提高了构造的对象的适应能力(不是自发行为能力)的一种手段.
Andrei Alexandrescu的《Generic Programming ：类型的else-if-then机制》
这篇文章可作为一精彩的证明.
-----------------------------------------------------------------------------

三、C++怎么学?

首先声明：本人对之也只能说略之一二(C++太博大了:))
孟岩先生曾经提过"C++需要自由的心",我要说"C++需要自由的心和手",我敢肯定我想的自由和孟岩先生的自由是不同的.
因为我的自由就个人诠释是 ："用自己的思路来自由的写验证性的usecase"
就个人的学习心得而言 ：

1.在你学习C++的过程中,你首先需要扎实的实践一本C++基础教程,这个教程不在深而在全.使你能够全览之.最好结合基本数据结构来练习.不要整天Hello World~~Hello MM的.

2.再下来你需要《(More)Effective C++》,它使你可以对C++也多了份思考,也了解到一些技巧和误区,不过,你需要同步实践,不然可能一时你并不能真正掌握这些技巧、避开误区.

3.提高,你需要：(下面的书可能已经讲烂了:))

《Design Pattern》 ：个人感觉,设计模式虽说是一种思维方式,具体实现上,只是
对OOP语言的发掘和巧妙组合而已.而且这里组合是主要的,
特性是有限的,这本书中有几个模式没用虚特性的?
C++ Standard Document: 在你用它来做专项研究的时候,就会体会到什么才叫真正的
全而深 (自然指在语法和语义的阐述上).
《STL源码剖析》 ：没有深厚的功底,想来个闭门造车独挑STL源码是不可能的.
不过,这本说也重在关键技术的讲解和引导罢了~~
这里关于GP和STL的名着不少，本人没看过。不做品评。
《 Inside The C++ Object Model》：最具价值的一本书,没了它,C++永远是个迷,哪怕
你浸淫之N载~~
《Moden In C++ Design》 ：这里的很多思路是你自己的思维很难接触到的~~：)
我不得不佩服Andrei Alexandrescu.

市面上其它的C++书籍可牛车载,我感觉除了《The Design And Evolution Of C++》是异品,值得一读.其它的不建议花太多的时间,哪怕是Bjarne Stroustrup、Stanley B.Lippman等的作品.自然,你有时间读更好,反正我现在有点后悔,当初只顾多,不顾深读,反复读.经典的书不在本数多,在于每本读的遍数多.一经验之谈,BBS上经常有人,在介绍COM技术书籍时,想也不想的指出,入门级<<Inside The COM>>.是这样的吗?我想,正如Dale Rogerson所说,将这本书完全看懂,你就是COM专家了~~书中,作者很多话可能你没有注意到,因为你还不懂之,对之没感觉,一遍翻下来,感觉 哦~~简单~全看了 :) 这些书,跟国内的很多书籍最大的不同就是
国内书籍的作者写的出,可能自己还不懂:)Copy什么资料上的:)??

4.浸淫一门语言本身的语法语义再久,你不一定能够深入它的精妙之处.
你需要学习应用这门语言的实作品(技术),你可以研究一些FrameWork或是一些具体的技术 如CORBA、COM等.就个人而已,有心接触C++十个月左右,对于Virtual的认识有过几次较大的的改变.在《 Inside The C++ Object Model》中算第一次,在《COM本质论》中关于COM对二进制兼容布局需求而用虚机制来解决是第二次,到目前为止,使我对virtual流下最深刻印象的是在Automation技术中组件由于环境是否有能力分析virtual结构而导致是否需要分发接口的问题.如果,整天抱着《C++语法语义深入》这样的书,我不知你何时才能真正了解C++很多的特性.
即使你可以对别人说上一大套,这行啊~那不行啊~~云云~~:)

在这整个的过程中,我喜欢这样对学弟说,你需要经常将C++的各种特性在脑中反复混合酝踉,这也是我强调学基础时,要求教材知识点全的原因.经常的,为了研究某些特性而自由的写、修改、增加UseCase,是我自认为很好的一个习惯.整天记他人的经验之言,不知几个月后还记得几层:)?

也许上面的叙述是概括了些:)?

总之,我认为学习C++,需要多思考(譬如你想想为什么模板类继承不支持virtual、模板
类继承,基类实例和继承类实例产生的关系是什么样的)、
多写usecase、
多将一堆特性混合酝晾（譬如模板类
成员签名、多种嵌套模板类成员签名、嵌套类与包裹类生命期
控制等等)

要尽早选择应用方向(这点很重要,附加个人观点：大多数人认为理论很
难，可是我要说：应用一样是有难度的:)).

将00工程学中的理论适时的来对照自己的行为.

后话：
上面提到,就应用而已,比较语言的是没有什么意义的.然而我想说的是,不敢想象
没有经过C++锤炼的人,可以深入的研究C#(事实上，我一直也不人为C#比C++好学，只是他们的深入点是不同的，冒昧说一句，C++中很多难度是人为制造出来的),就目前的情况来说,还有就是由于C++历史、
社团、资源等因素.

共勉 ：
因用而择、因爱而择
学究其深
勿以善小而不为 :)

‘贰’ gp是什么的缩写

类属编程(generic programming) generic是构成库的另一种方式, 这与传统的oop是不同的.这类程序库一般由类属组件和类属算法组成，组件和算法通过迭代器组装起来，组件则对迭代器提供一定的封装.这种程序库的优点在于能够提供比传统程序库更灵活的组装方式，而不损失效率.

编辑本段其他解释：
GUARDIAN PENGUIN
GP是GUARDIAN PENGUIN(企鹅卫队)的简称，是具历史底蕴、皇室风范的英国国名品牌。英国“企鹅卫队”“GP”品牌彰显皇室高贵气度，是公认的英国“尊贵无比的流行元素”。英国GP休闲内衣系列产品均选用与欧洲同步的进口上等原料，如意大利超细美丽诺羊毛、高支精梳棉、莱卡、天丝、莫代尔、等天然纤维精心编织而成，质感柔软、轻盈，加上运用了精细独特的立体裁剪，使产品与人体完美结合，穿着更加舒适。
GRAND PRIX
GP 是GRAND PRIX的缩写，即“格兰披治”。意思是“大奖赛”、“锦标赛”，在厂家出一款新车后，推出的相应的GP系列中，就是指该车是公路跑车版。一般的车型推出GP版，是指增强发动机性能或配置大功率发动机的高性能公路跑车版。
general purpose
在集装箱标准里面，GP就是平柜/普通箱的意思，即general purpose。例如40'GP就是40'普柜。
Green Partner
GP也是指绿色环境管理体系，是Green Partner的缩写,SONY公司提出来的一技术标准认证 ,即您的产品如要交付给SONY的话,公司必须得符合SS-00259技术标准,SONY公司会按照标准中的要求来对公司进行一个稽核的动作. 就如ISO 9001认证一样,只是对象不一样,ISO属于第三方认证,而GP属于第二方(客户)认证.
GeneticProgrammni
Koza在1989年提出利用层次化的计算机程序来表达和解决问题，而解决问题的最佳方法(程序)可以借助遗传算法思想寻得，这也就是遗传程序设计(GneeticProgrammni，GP)的基本思想。
普通合伙人
私募股权投资基金的主要组织形式是有限合伙制（Limited Partnership），其中私人股权投资公司作为普通合伙人(GP)，基金整体作为有限合伙存在.
GUNDAM-Development Project
GUNDAM-Development Project之简写, 即“高达开发计划”。出自机动战士高达0083星尘的回忆（日文名：机动戦士ガンダム0083 STARDUST MEMORY?，英文名：Mobile Suit GUNDAM0083 STARDUST MEMORY?）是高达系列作品当中的一部OVA动画。一共13集，1991年5月份最先于日本发行，其最后一集在1992年9月份发行完毕。“高达开发计划”是OVA动画《机动战士高达0083 STARDUST MEMORY》当中所提及的一个空想的计划，从这个计划中所开发出来的概念机体都被冠上GP字眼（GUNDAM-Development Project之简写），并且各自有以花朵为名的昵称。这些昵称在地球联邦军正式文件中并没有出现，而是开发者之间的惯用计划代号。在一年战争结束之后，联邦军开始推动重建计划。而本计划为其中之一部分。宇宙世纪0081年10月20日以约翰?高恩中将为总负责人，与阿纳海姆电子（Anaheim Electronics）开始共同进行。高达开发计划的主要目的是为了发展并且验证次世代主力量产MS的各种先进技术，所以本计划产生的概念机可说是集地球联邦与吉恩公国MS技术之大成。阿纳海姆电子公司内的“先进开发事业部”负责1号机与3号机，具有旧吉恩军技术背景的第二研究事业部负责2号机与4号机。但是4号机因为种种原因而没有变成所谓的高达系列机体，而是以另一种姿态出现，并且名字也跟高达不相干。所以狭义的高达GP系列实际上只有三台（含0号机的话共4架）。
GENERAL PAPER
GENERAL PAPER的缩写。为CAMBRIDGE GCE A-LEVEL 的英文考试，新加坡进入大学的必须考试之一。分为comprehension和essay两部分。主要考查英文语言的运用能力
Gross Profit
在财务上GP=Gross Profit（毛利）
Gallup Poll
缩写词，=Gallup Poll(美国)盖洛普民意测验
Gold Point
金币（既Gold Point的缩写，实际意思应该是“黄金点数”），在网络游戏《穿越火线》《战地之王》中。GP指在游戏中可得到的虚拟金钱，金币，叫做GP，通过玩家在游戏中通过游戏在结束时获得。可以购买游戏中的部分道具武器等等。
Gold Peak
GP（Gold Peak）超霸电池 全球十大电池生产商 金山工业(集团)有限公司控股49.8%

‘叁’ 我学了C和C++,把<<Java编程思想>>看了一边，我对网络编程比较感兴趣，我下一步该学什么

先看C++ Primer,之后看
B.S 的The C++ Program language,接再看看关于GP的书，还有侯Sir翻译的 The C++ Object Model,当然其中还看了C++标准库这本书哈，在学习
STL的过程，接下来的猎物是STL源代码解析哈。

‘肆’ 一个程序问题，广大大牛们可不可以用动态代理模式实现（调用method方法后不结束main方法）

当然代理模式中，用的最广泛的，用的最多的是 动态代理模式。

动态代理：就是实现阶段不用关系代理是哪个，而在运行阶段指定具体哪个代理。

抽象接口的类图如下：

--图来自设计模式之禅

所以动态代理模式要有一个InvocationHandler接口 和 GamePlayerIH实现类。其中 InvocationHandler是JD提供的动态代理接口，对被代理类的方法进行代理。

代码实现如下

抽象主题类或者接口：

复制代码
1 package com.yemaozi.proxy.dynamic;
2
3 /*
4 * 动态代理：就是实现阶段不用关系代理是哪个，而在运行阶段指定具体哪个代理。
5 */
6 public interface IGamePlayer {
7 //登录游戏
8 public void login(String username, String password);
9
10 //击杀Boss
11 public void killBoss();
12
13 //升级
14 public void upGrade();
15 }
复制代码

需要被代理类：

复制代码
1 package com.yemaozi.proxy.dynamic;
2
3 public class GamePlayer implements IGamePlayer {
4
5 private String name = "";
6
7 public GamePlayer(String name){
8 this.name = name;
9 }
10
11 public void login(String username, String password) {
12 System.out.println("登录名为 "+username+" 进入游戏，" + name + " 登录成功！");
13 }
14
15 public void killBoss() {
16 System.out.println(this.name + " 击杀了Boss！");
17 }
18
19 public void upGrade() {
20 System.out.println(this.name + "升级了！");
21 }
22
23 }
复制代码

动态代理处理器类：

复制代码
1 package com.yemaozi.proxy.dynamic;
2
3 import java.lang.reflect.InvocationHandler;
4 import java.lang.reflect.Method;
5
6 public class GamePlayerInvocationHandler implements InvocationHandler{
7
8 //被代理的对象
9 private Object obj;
10
11 //将需要代理的实例通过处理器类的构造方法传递给代理。
12 public GamePlayerInvocationHandler(Object obj){
13 this.obj = obj;
14 }
15
16 public Object invoke(Object proxy, Method method, Object[] args)
17 throws Throwable {
18 Object result = null;
19 if("login".equalsIgnoreCase(method.getName())){
20 //这个在主题方法不受任何影响的情况下，在主题方法前后添加新的功能，或者增强主题方法，
21 //从侧面切入从而达到扩展的效果的编程，就是面向切面编程(AOP Aspect Oriented Programming)。
22 //AOP并不是新技术，而是相对于面向对象编程的一种新的编程思想。在日志，事务，权限等方面使用较多。
23 System.out.println("代理登录游戏！");
24 result = method.invoke(this.obj, args);
25 return result;
26 }
27 result = method.invoke(this.obj, args);
28 return result;
29 }
30
31 }
复制代码
由于代理是动态产生的，所以不需要再声明代理类。

动态代理场景类：

复制代码
package com.yemaozi.proxy.dynamic;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;

public class Client {
public static void main(String[] args) {
IGamePlayer gp = new GamePlayer("张三");
InvocationHandler gpHandler = new GamePlayerInvocationHandler(gp);
//获取真实主题类的ClassLoader
ClassLoader classLoader = gp.getClass().getClassLoader();
//动态产生一个代理者。
Class<?>[] cls = new Class[]{IGamePlayer.class};
IGamePlayer proxyGp = (IGamePlayer) Proxy.newProxyInstance(classLoader, cls, gpHandler);
proxyGp.login("zhangsan", "123456");
proxyGp.killBoss();
proxyGp.upGrade();
}
}

执行结果：
代理登录游戏！
登录名为 zhangsan 进入游戏，张三 登录成功！
张三 击杀了Boss！
张三升级了！

//在此，我们没有创建代理类，但是确实有代理类帮我们完成事情。
复制代码
其中，在此代理模式中，不仅代理是动态产生的(即在运行的时候生成)，而且还在代理的时候，也增加了一些处理。在此处增加的处理，其实就是另一种编程思想-----面向切面编程思想(AOP Aspect Oriented Programming)。

带有AOP的动态代理模式类图：

--图来自设计模式之禅

从上图中，可以看出有两个相对独立的模块(Subject和InvocationHandler)。动态代理实现代理的职责，业务逻辑Subject实现相关的逻辑功能，两者之间没有必然的相互耦合的关系。然而，通知Advice从另一个切面切入，最终在上层模块就是Client耦合，完成逻辑的封装。

代码清单如下

抽象主题或者接口：

复制代码
1 package com.yemaozi.proxy.dynamic_aop;
2
3 public interface Subject {
4 public void doSomething(String str);
5 //...可以多个逻辑处理方法。。。
6 }
复制代码

真实主题：

复制代码
1 package com.yemaozi.proxy.dynamic_aop;
2
3 public class RealSubject implements Subject{
4
5 public void doSomething(String str) {
6 //do something...
7 System.out.println("do something..." + str);
8 }
9
10 }
复制代码

通知接口：

复制代码
1 package com.yemaozi.proxy.dynamic_aop;
2
3 //通知接口及定义、
4 public interface IAdvice {
5 public void exec();
6 }
复制代码

前置通知：

复制代码
1 package com.yemaozi.proxy.dynamic_aop;
2
3 public class BeforeAdvice implements IAdvice {
4 //在被代理的方法前来执行，从而达到扩展功能。
5 public void exec() {
6 System.out.println("前置通知被执行！");
7 }
8 }
复制代码

后置通知：

复制代码
1 package com.yemaozi.proxy.dynamic_aop;
2
3 public class AfterAdvice implements IAdvice {
4
5 //在被代理的方法后来执行，从而达到扩展功能。
6 public void exec() {
7 System.out.println("后置通知被执行！");
8 }
9 }
复制代码

动态代理的处理器类：

所有的方法通过invoke方法类实现。

复制代码
1 package com.yemaozi.proxy.dynamic_aop;
2
3 import java.lang.reflect.InvocationHandler;
4 import java.lang.reflect.Method;
5
6 public class MyInvocationHandler implements InvocationHandler {
7
8 //被代理的对象
9 private Subject realSubject;
10 //通过MyInvocationHandler的构造方法将被代理对象传递过来。
11 public MyInvocationHandler(Subject realSubject){
12 this.realSubject = realSubject;
13 }
14 //执行被代理类的方法。
15 public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
16 //在执行方法前，执行前置通知。
17 IAdvice beforeAdvice = new BeforeAdvice();
18 beforeAdvice.exec();
19 Object result = method.invoke(this.realSubject, args);
20 //在执行方法后，执行后置通知。
21 IAdvice afterAdvice = new AfterAdvice();
22 afterAdvice.exec();
23 //前置通知，和后置通知，都是要看具体实际的业务需求来进行添加。
24 return result;
25 }
26
27 }
复制代码

动态代理类：

复制代码
1 package com.yemaozi.proxy.dynamic_aop;
2
3 import java.lang.reflect.InvocationHandler;
4 import java.lang.reflect.Proxy;
5
6 public class DynamicProxy {
7
8 /**
9 * public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces,InvocationHandler handler)
10 * loader：
11 * 一个ClassLoader对象，定义了由哪个ClassLoader对象，来对生产的代理进行加载。
12 * interfaces：
13 * 一个Interfaces数组，表示我将要给我所代理的对象提供一组什么样的接口，
14 * 如果提供一组接口给它，那么该代理对象就宣称实现了该接口，从而可以调用接口中的方法。
15 * 即，查找出真是主题类的所实现的所有的接口。
16 * handler：
17 * 一个InvocationHandler对象，表示当我这个动态代理对象在调用方法时，会关联到该InvocationHandler对象。
18 * 该InvocationHandler与主题类有着关联。
19 */
20 public static <T> T newProxyInstance(ClassLoader classLoader, Class<?>[] interfaces, InvocationHandler handler){
21 @SuppressWarnings("unchecked")
22 T t = (T) Proxy.newProxyInstance(classLoader, interfaces, handler);
23 return t;
24 }
25 }
复制代码
从动态的产生动态代理类。

动态代理场景类：

复制代码
1 package com.yemaozi.proxy.dynamic_aop;
2
3 import java.lang.reflect.InvocationHandler;
4
5 public class AOPClient {
6
7 public static void main(String[] args) {
8 Subject realSubject = new RealSubject();
9 InvocationHandler handler = new MyInvocationHandler(realSubject);
10 ClassLoader classLoader = realSubject.getClass().getClassLoader();
11 Class<?>[] interfaces = realSubject.getClass().getInterfaces();
12 Subject proxySubect = DynamicProxy.newProxyInstance(classLoader, interfaces, handler);
13 proxySubect.doSomething("这是一个Dynamic AOP示例！！！");
14 }
15 }
16
17 执行结果：
18 前置通知被执行！
19 do something...这是一个Dynamic AOP示例！！！
20 后置通知被执行！
复制代码
动态代理中invoke的动态调用：

动态代理类DynamicProxy是个纯粹的动态创建代理类通用类。

所以在具体业务中，可以在进一步封装具体的具有业务逻辑意义的DynamicProxy类。

代码如下

具体业务的动态代理：

复制代码
1 package com.yemaozi.proxy.dynamic_aop;
2
3 import java.lang.reflect.InvocationHandler;
4 //具体业务的动态代理。
5 public class SubjectDynamicProxy extends DynamicProxy {
6 public static <T> T newProxyInstance(Subject subject){
7 ClassLoader classLoader = subject.getClass().getClassLoader();
8 Class<?>[] interfaces = subject.getClass().getInterfaces();
9 InvocationHandler handler = new MyInvocationHandler(subject);
10 T t = newProxyInstance(classLoader, interfaces, handler);
11 return t;
12 }
13 }

‘伍’ C++中，什么是GP

泛型编程也就是GP(Generic Programming),推崇与类型无关的编程思想。简单来说，就是将针对不同数据类型的相同算法从数据结构<类>中剥离出来，
这与传统的C++的继承和多态截然不同。
可以说泛型思想中没有多少继承和多态的成分。甚至有背道而驰的味道。

在C++实现上，泛型严重依赖于模板机制，事实上如果没有模板的引入，泛型绝对不会在C++语言中获得如此巨大的成功!

泛型代码由C++编译器在编译期解释成二进制代码。也就是说，泛型的代码编译起来可能会使程序的二进制代码变大，但这一点也保证了程序在运行的时候不会损失效率...
当然泛型不是万能的，滥用泛型也许一样会使你的代码缓慢...
工具毕竟还是工具，思想和方法总有其局限性的。
如果没接触过，学习泛型编程，对你是一个全新的体验 。

‘陆’ 学C++的准备工作!

经过十分漫长的C++学习过程，我总算完成了我自己的C++心愿，看完了我想看的所有C++书籍，回
顾我C++的整个学习过程，颇有一些心得和经验，希望与各位分享，也希望给正处在摸索学习阶段的
XDJM一点学习参考。
首先看看我第一次接触编程语言，唔，那可能要追述上到世纪，在我小学4年纪的时候第一次接触到
BASIC，那个时候学习这个东西完全是为了要爸爸给我买一台386，没想到的是，BASIC开启了我对于计算
机的一切兴趣与追求。5年纪的时候参加少年的计算机奥赛，我用BASIC写的一个彩色立体可旋转移动的正
方体拿了一个铜牌，从此计算机编程成为了最大的爱好，现在我还保留着源代码，是保存在一盘普通单放
机的磁带上的，我估计很少有人用过录音机和串口的转换器吧，呵。我用BASIC写的第二个大程序是给我
妈妈用的财务程序，初中二年纪的时候，我妈妈在单位做出纳，我总看到妈妈每天晚上拿个计算机算一堆
表，所以我写了这个程序帮助妈妈快速完成她的工作，其实我的根本目的是为了一台打印机，因为这个程
序，生成了简单的报表，她可以直接打印，当然为了这个便利，她必须花钱给我买一台当时还算价值不低
的打印机。不过现在回顾起来，BASIC虽然是我编程的第一位启蒙老师，但是在我开始C++的学习之后，他
确实使我我思想上产生了很大的困绕，主要是OOP思想，我花费了将近1年多的时间才真正体会到什么是OO！
到了大学，我才真正开始系统的学习编程。在此之间走过一些歪路，比如高中的时候研究HACKING，
之所以说学习hacking是条歪路，原因很简单，因为研究到一定的程度，没有十分稳固的编程基础，根本
的无法继续深入学习。中国**联盟解体前，位列第三的kender给了我这方面很大的打击，从此我就退出了
，从此对于hacking我就不闻不问，从此看到那些下三烂的货色也要学hacking，我就感到可笑。第一次接
触的是C，没什么好说的，我C学的不好，因为我大二的时候经商去了，而且我觉得C能做的，我用BASIC都
能做到，为什么要学C？当然那个时候我成绩真是北大的BBS...然后接触到的就是C++，教材的钱能的
《C++程序设计》,这本书其实还是很不错的，不过很多看了两本名着的朋友都对这本书嗤之以鼻，也许是
我天生很笨，在我看完了《C++PRIMER》后还经常番看《C++程序设计》。《C++程序设计》虽然出书的时
候ANSI C++还没有确定下来，不过它还是含盖了C++所有语法，建议对C++感兴趣却又没有任何基础的人先
从这本书开始，简单而高效，不要认为人家一上来就看《C++ PRIMER》或是《the c++ programming
language》就觉得自己的档次很低，你要确信，你肯定能超过他！这本书课后习题在我看来是典型的结构
化编程，即使到了CLASS，也全部可以用STRUCT代替。不过在这个阶段做习题十分必要，用处我不想敲了
，推荐使用的编译器就是书中所说到的编译器（我忘记叫什么了:P)看完之后，如果你想说C++很简单的话
，建议你在看完了《C++ PRIMER》或是《the c++ programming language》之后再说。这两本书都是基于
标准C++的，十分苛求的说，后者对标准的兼容性稍差:)。对这两本书，我的看法是，如果你确实想仔细
的学习，建议你看《C++ PRIMER》，如果你想跳过我将要写到的下面两本书的话，建议你看
《the c++ programming language》。对这两本书，前者最高到中文第三版，因为第四版，后者到特别版
。对于前者，我看后的感觉是它的优点在于解析，特别是函数，类，模板的解析，但是它并没有含盖C++
的方方面面，后者就不是这样。实际上我并没有仔细看过后者，只是同学总是拿这本书上的问题来与我商
量，所以有机会偷窥了几眼。暂定你选择的是前者继续学习，在看完后，也许你用C++编制普通的程序已
经能够运用自如，但是你仍然应该会有很多问题和遗憾，比如，类继承，虚拟继承，类访问控制，类继承
下的访问控制，还有虽然我已经对如何解析十分清楚，但是我仍然感觉我对语法掌握得不系统，遗憾的是
，书中出现了很多的库函数，我为什么都不知道？这个时候建议你看看《标准C++宝典》，这本书对于语
法正所谓事无巨细，一一道来啊，再就是回顾一下《C++ 程序设计》（钱能），对类的部分讲解的还是十
分精辟的。在掌握了一切牢固的语法基础之后，我选择的下一步不是STL，而是IOSTREAM，原因之一是因
为《C++ PRIMER》并没有把这一部分讲述的很好，对了，《C++ PRIMER》也没有把STL讲述的很好，所以
我看《C++ PRIMER》的时候这些章节都跳过了，我的目标是不求知道，只求精通。对于IOSTREAM，我选的
书是《Standard C++ IOStream and Locales》，我当时还是看的E文原版，事实证明，我错了，这本对于
当时的我，难度突然拔的太高，所以在看完了第一章之后我就放弃了，只是暂时的搁置下来了。对了，忘
记说，对于《C++ PRIMER》或是《the c++ programming language》的学习，你应该十分认真的选择编译
器了，我推荐3个首选dev-cpp最高4.9.9.2,然后是vc.net(千万看清楚，不是vc6.0!),最后就是
borland c++ builder-X,具体我就不介绍了，相信你学习到这一步，自己应该已经掌握很多的信息了.继
续，下一步，我的选择是〈深入探索C++对象模型〉，我是在图书馆借阅的，现在也有电子版了，不过我
看了以下，效果一般，但是可以和E文原版的电子版一起看。这本书看完。如果你是跟我一样，把
《C++ PRIMER》翻烂掉，能把《深入探索C++对象模型》的知识要点全部背出来的话，我恭喜你，你的
C++水平已经到中级了:)接下来，我的选择是对C++这门语言为我提供的所有服务设施通透的学习一边。
说穿了，就是库函数，C++库函数分两部分，一部分来自C语言，一部分就是STL，对于C语言部分，我建议
你可以买一本C++函数库的书，最近好象刚出了一本，不过我还没有机会看，我看的是〈C和C++代码精
粹〉，里面把C语言部分的库函数分为3类，这本书我也就看了这3个章节，其他的东西我知道，看他做
甚？而对于STL，你如果真想成为C++出类拔萃的高手，你应该看3本<<C++标准程序库>> <<泛型编程与
STL>> <<STL源码剖析>>，第一本主要讲的是如何使用STL，第二本将STL的一些设计理念，并指导你进
行泛型设计，所谓泛型说穿了就是指模板。看完这些书，如果你跟我一样，可以把STL全部重写一边的
话，那么恭喜你，你已经成为C++准高手，这个时候我的选择是回过头去看《Standard C++ IOStream
and Locales》，呵，现在才发现原来这本书这么简单！简直是naive!其实，我现在最想做的事情就是能
够把IO全部重写一边，不过还没有找到合适的编译器下手，感觉应该用GCC比较好，还没开始研究，我也
不清楚。好了，既然这么多本讲述C++技术的书籍你都搞完了，也不在乎多两本吧，呵呵。知道你应该看
什么吗？你应该看看<exceotional c++>还有<effective c++>，这两本书都有more版，不算太难，最后可
以看《高质量C++编程》，最后有一套练习题，做做，小菜一样。接下来我的选择是<C++编程思想> 〈设
计模式〉 〈大规模C++程序设计〉（最后一本我最近才看完:P）这3本书可不讲什么语法，第一本实在没
有必要介绍，似乎每一种语言的编程思想的的书籍都是说的如何用这门语言编程，第二本其实并不能说是
针对C++，所有语言通用的一本书，关键是程序设计的方式，第三本被称为〈设计模式〉的C++实践篇，其
意义毋庸多说。看完了吗？好吧，你应该选一个项目锻炼一下。如果你能在一个月内看完这所有的书，欢
迎你加入ISS_SQL开发团队，这个就是我近期想做的事情，我就是想写一个自己的数据库。不过如果你不
是外星人的话，我估计你不可能在一个月的时间内，看完我看了2年的书。对于我刚才说的SQL，我还在选
人，说实在的，现在我的同学里，真的是没有几个人的技术能让我看的上的，哎，得一知己难啊!还是继
续说编程，这个时候，你已经有了顶级的C++基础，想学什么不容易？JAVA，你学了一个月？？开玩笑，
我看了一个星期的书就开始做项目了！其实我觉得到了这个时候是一个面临选择的时候，一个是做UNIX下
的开发，一个是做WINDOWS下的，不过我选择了第三条路，也就是我正在学的，算法，因为我的导师正在
做973计划中的数据挖掘项目，所以我也沾光，因为是基与weka，所以我用java，这个B语言真弱智，我已
经开始讨厌JAVA了，所以我才想用C++重写一个WEKA类的开源软件，不过我感觉用java写算法，的确不
错。前段时间，我一个同学为了一个C#问题苦恼，问题粗略说来是GIS设备返回串，要进行处理，提取数
据，因为串本身的复杂性，具体是怎么样的我也不知道，因为他的这个是商业项目。这个问题在C#下十分
困难，连正则表达式都无能为力，所以我给他的建议是写一个自动机，也不知道他最后的处理方式，不过
在java下，呵，大概不超过五十行代码吧。说远了。
最后说说人的问题。有一点点浮躁的人建议你千万别想学C++，直接学VB或者C#算了，希望在浩方有
个排名的人，我直接告诉你，你不应该学C++。
关于C++的学习，我就说这么多，其实也感觉没有说什么，只是把我学习C++看的每一门书都罗列出来
，虽有显摆之嫌，但也确实希望给那些如曾经的我一样迷茫的摸索者，那些希望学习C++且追求完美技术
的人指一条明路。

下面的是学C++时要注意的。

1.把C++当成一门新的语言学习（和C没啥关系！真的。）；

2.看《Thinking In C++》，不要看《C++变成死相》；

3.看《The C++ Programming Language》和《Inside The C++ Object

Model》,不要因为他们很难而我们自己是初学者所以就不看；

4.不要被VC、BCB、BC、MC、TC等词汇所迷惑——他们都是集成开发环境，而我们要学的是一门语言；

5.不要放过任何一个看上去很简单的小编程问题——他们往往并不那么简单，或者可以引伸出很多知识点；

6.会用Visual C++，并不说明你会C++；

7.学class并不难，template、STL、generic

programming也不过如此——难的是长期坚持实践和不遗余力的博览群书；

8.如果不是天才的话，想学编程就不要想玩游戏——你以为你做到了，其实你的C++水平并没有和你通关的能力一起变高——其实可以时刻记住：学C++是为了编游戏的；

9.看Visual C++的书，是学不了C++语言的；

10.浮躁的人容易说：XX语言不行了，应该学YY；——是你自己不行了吧！？

11.浮躁的人容易问：我到底该学什么；——别问，学就对了；

12.浮躁的人容易问：XX有钱途吗；——建议你去抢银行；

13.浮躁的人容易说：我要中文版！我英文不行！——不行？学呀！

14.浮躁的人容易问：XX和YY哪个好；——告诉你吧，都好——只要你学就行；

15.浮躁的人分两种：a)只观望而不学的人；b)只学而不坚持的人；

16.把时髦的技术挂在嘴边，还不如把过时的技术记在心里；

17.C++不仅仅是支持面向对象的程序设计语言；

18.学习编程最好的方法之一就是阅读源代码；

19.在任何时刻都不要认为自己手中的书已经足够了；

20.请阅读《The Standard C++ Bible》(中文版：标准C++宝典)，掌握C++标准；

21.看得懂的书，请仔细看；看不懂的书，请硬着头皮看；

22.别指望看第一遍书就能记住和掌握什么——请看第二遍、第三遍；

23.请看《Effective C++》和《More Effective C++》以及《Exceptional C++》；

24.不要停留在集成开发环境的摇篮上，要学会控制集成开发环境，还要学会用命令行方式处理程序；

25.和别人一起讨论有意义的C++知识点，而不是争吵XX行不行或者YY与ZZ哪个好；

26.请看《程序设计实践》，并严格的按照其要求去做；

27.不要因为C和C++中有一些语法和关键字看上去相同，就认为它们的意义和作用完全一样；

28.C++绝不是所谓的C的“扩充”——如果C++一开始就起名叫Z语言，你一定不会把C和Z语言联系得那么紧密；

29.请不要认为学过XX语言再改学C++会有什么问题——你只不过又在学一门全新的语言而已；

30.读完了《Inside The C++ Object Model》以后再来认定自己是不是已经学会了C++；

31.学习编程的秘诀是：编程，编程，再编程；

32.请留意下列书籍：《C++面向对象高效编程（C++ Effective Object-Oriented Software Construction）》《面向对象软件构造(Object-Oriented Software Construction)》《设计模式（Design Patterns）》《The Art of Computer Programming》；

33.记住：面向对象技术不只是C++专有的；

34.请把书上的程序例子亲手输入到电脑上实践，即使配套光盘中有源代码；

35.把在书中看到的有意义的例子扩充；

36.请重视C++中的异常处理技术，并将其切实的运用到自己的程序中；

37.经常回顾自己以前写过的程序，并尝试重写，把自己学到的新知识运用进去；

38.不要漏掉书中任何一个练习题——请全部做完并记录下解题思路；

39.C++语言和C++的集成开发环境要同时学习和掌握；

40.既然决定了学C++,就请坚持学下去，因为学习程序设计语言的目的是掌握程序设计技术，而程序设计技术是跨语言的；

41.就让C++语言的各种平台和开发环境去激烈的竞争吧，我们要以学习C++语言本身为主；

42.当你写C++程序写到一半却发现自己用的方法很拙劣时，请不要马上停手；请尽快将余下的部分粗略的完成以保证这个设计的完整性，然后分析自己的错误并重新设计和编写（参见43）；

43.别心急，设计C++的class确实不容易；自己程序中的class和自己的class设计水平是在不断的编程实践中完善和发展的；

44.决不要因为程序“很小”就不遵循某些你不熟练的规则——好习惯是培养出来的，而不是一次记住的；

45.每学到一个C++难点的时候，尝试着对别人讲解这个知识点并让他理解——你能讲清楚才说明你真的理解了；

46.记录下在和别人交流时发现的自己忽视或不理解的知识点；

47.请不断地对自己写的程序提出更高的要求,哪怕你的程序版本号会变成Version 100.XX；

48.保存好你写过的所有的程序——那是你最好的积累之一；

49.请不要做浮躁的人；

50.请热爱C++!

补充:

对c++学习的一点感想，希望对初学者能有些帮助

1.如果你以前从来没有接触过c++，那么选择的第一本c++教程就显得尤为重要，我认为你可以参照以下的标准进行选择：

a.对标准c++进行讲解，毕竟c++比从前发生了很大的变化。

b.要求全面，但不要很深，这要有助于你对于c++有一个全面的认识，打好基础，并且易懂的教材还能加快学习的进度，让自己保持一种成就感。

c.要有完整的范例来讲解每一个知识点如何运用，请注意这里所说的完整，并不是一个个代码片断。因为由于你以前从未接触过用c++进行编程，完整的代码可以使你有一个整体的概念，并且能够很快去进行大量的实践，因为变编程是从模仿开始，完整的代码恰恰告诉你了一个完整的步骤。不必自己去揣测。

d.推荐：《c++ primer plus》

2.当你有了一定的基础以后，就要选择一些书来迅速提高自己。这类书的特点是不仅仅教你如何去运用，而且要叫你如何去思考，并且你读起来也不是那么轻松。它意味深远，并不是你读一遍就能掌握的。

推荐：《thinking in c++》《effective c++》《more effective c++》

《c++ programming language》...《c++ 沉思录》

3.接下来就是对第二步所介绍的书籍进行反复的阅读，并且进行实践。由于这些书一位深远，每个人基于自己的基础都会有不同的收获，例如如果你的基础还没有达到某一高度，那么你就对一些精深的技术视而不见，不信？你可以试试，看看当自己有了一定提高之后再来读从前的一本书，你会发现许多新的东西。

‘柒’ 什么叫oo编程，oo是哪两个英语单词缩写，rss标志是什么意思

OO(Object-Oriented)

什么是OO?
就是面向接口编程。无论你是用vtable, 或gp的function object, 或就是C的函数指针，正交分解也好，各种pattern也罢，都是面向接口编程思想的一种实现。

为什么要面向接口编程？
为了解耦。

什么是解耦？
就是把程序中互相不相关或有限相关的模块分割开来。就象收拾屋子，你希望把不同的东西放到不同的地方。把酱油和醋倒进不同的瓶子里去。
这里，对完全不相关的功能，可以简单地分开实现。
但事实上，很多情况下，不同模块之间是有互相之间的关系的。这时，就需要接口。用接口准确定义模块之间的关系。解耦前，两个模块之间共享所有信息（这个信息包括数据，也包括各自的实现细节）。解耦后，需要共享的信息被准确地定义在接口中。同时，信息的流向也被确定。

解耦的好处是什么呢？
首先，程序变得清晰了。
其次，不该暴露的实现细节被隐藏了。代码的修改变容易了。
再次，结构灵活了，通过静态多态(function object)或动态多态(vtable), 一个模块可以和任意实现接口的模块协作。原来类A只能与类B协作，解耦后可以和所有实现接口IB的类如B1, B2, ... 协作了。扩展性大大增强。自然而然就代码重用了。
编译依赖也没有了。你可以专心写和编译一个模块，不用等待其它模块的完成。
调试容易了。只要模块对一个接口调试成功，其它的接口也没有问题。于是，甚至可以用一个simple naive的实现该接口的mmy类来调试。（这点，使用template的gp不适用）

那么解耦的坏处是什么呢？
接口的定义变得很关键。解耦就是隐藏一些信息，定义一些需要共享的信息。如果接口定义的不好，隐藏了不该隐藏的信息，那么对某些需要这些信息的复杂情况来说，这个解耦就失败了。
而如果没有隐藏一些应该隐藏的信息，那么不该有的耦合仍然存在。

那么怎样解耦，又怎样定义接口呢？
这是一个纯粹业务逻辑的思考过程。这里，对编程语言的知识变得无关紧要。事实上，只要精确掌握需求，严密地分析需求和模块内部子模块之间的需求，任何一个会逻辑思考的人都可胜任这个工作。就象歌星郑智化一样，虽然不识谱，但一样写歌，只不过最后要懂谱的人把歌纪录下来。
解耦的原则很简单：精确定义需求，仔细分析需求。不要隐藏任何“需求”也许会需要的信息。不要放过任何“需求”明显不需要的信息。
而对需求不清楚的情况，宁可错放一千，不能错杀一个。总而言之，决不能隐藏可能需要的信息。
不考虑重用，重用是解耦后的自然结果。不能倒因为果！
http://www.5ivb.net/Info/55/Info15237/

RSS是2004年最热门的互联网词汇之一，不过，相对于博客（BLOG）来说，RSS的知名度相应会低很多，而且至今还没有一个非常贴切的中文词汇，也许以后无需中文名，大家都习惯于直接叫RSS了。RSS之所以同BLOG一样会被认为是热门词汇的一个原因，个人推测，应该是许多分析人士认识到RSS将要对互联网内容的浏览方法所产生的巨大影响。

什么是RSS呢？RSS(Really Simple Syndication)是一种描述和同步网站内容的格式，是目前使用最广泛的XML应用。RSS搭建了信息迅速传播的一个技术平台，使得每个人都成为潜在的信息提供者。发布一个RSS文件后，这个RSS Feed中包含的信息就能直接被其他站点调用，而且由于这些数据都是标准的XML格式，所以也能在其他的终端和服务中使用。

如果从RSS阅读者的角度来看，完全不必考虑它到底是什么意思，只要简单地理解为一种方便的信息获取工具就可以了。RSS获取信息的模式与加入邮件列表（如电子杂志和新闻邮件）获取信息有一定的相似之处，也就是可以不必登录各个提供信息的网站而通过客户端浏览方式（称为“RSS阅读器”）或者在线RSS阅读方式这些内容。例如，通过一个RSS阅读器，可以同时浏览新浪新闻，也可以浏览搜狐或者网络的新闻（如果你采用了RSS订阅的话）。

在许多新闻信息服务类网站，会看到这样的按钮 ,有的网站使用一个图标，有的同时使用两个，这就是典型的提供RSS订阅的标志，这个图标一般链接到订阅RSS信息源的URL。当然，即使不用这样的图标也是可以的，只要提供订阅RSS信息源的URL即可，如网上营销新观察提供的RSS订阅URL是：http://www.marketingman.net/rss.xml

使用RSS获取信息的前提是，先安装一个RSS阅读器，然后将提供RSS服务的网站加入到RSS阅读器的频道即可。大部分RSS阅读器本身也预设了部分RSS频道，如新浪新闻、网络新闻等。

RSS基础知识：
如何利用RSS阅读器订阅RSS新闻内容？如何免费下载RSS阅读器？

常用的RSS阅读器：周博通RSS阅读器 看天下网络资讯浏览器

【RSS实用知识】：关于RSS订阅与RSS阅读的常见问题解答(网上营销新观察 冯英健)

为了进一步了解RSS及其发展历程的有关背景知识，下面摘录了2003年10月平文胜为时代营销撰写的有关RSS的介绍文章。仅供参考。网上此类介绍文章也不少，有兴趣的请到网上检索更多信息。例如维基网络对于RSS的定义、RSS规范、RSS专用阅读器和RSS在线阅读器、中文RSS搜索引擎等等（http://zh.wikipedia.org/wiki/RSS）

RSS及其发展历程简介 （时代营销 平文胜 2003-10-10）

RSS是一种描述和同步网站内容的格式，是目前使用最广泛的XML应用。RSS应用在国外已经非常普遍，从个人博客（Blog）栏目、企业站点到世界级的门户都提供基于RSS的服务，如IBM公司站点的中文新闻RSS http://www.ibm.com/news/cn/zh/index.rss ，YAHOO站点的http://news.yahoo.com/rss ，微软MSDN站点的http://msdn.microsoft.com/aboutmsdn/rss.asp 等等。

1、 RSS的历史

那么RSS究竟代表什么呢？比较普遍的有两种说法，一种是“Rich Site Summary”或“RDF Site Summary”，另一种是“Really Simple Syndication”，之所以有这些分歧，需要从RSS发展的历史说起。

最初的0.90版本RSS是由Netscape公司设计的，目的是用来建立一个整合了各主要新闻站点内容的门户，但是0.90版本的RSS规范过于复杂，而一个简化的RSS 0.91版本也随着Netscape公司对该项目的放弃而于2000年暂停。

不久，一家专门从事博客写作软件开发的公司UserLand接手了RSS 0.91版本的发展，并把它作为其博客写作软件的基础功能之一继续开发，逐步推出了0.92、0.93和0.94版本。随着网络博客的流行，RSS作为一种基本的功能也被越来越多的网站和博客软件支持。

在UserLand公司接手并不断开发RSS的同时，很多的专业人士认识到需要通过一个第三方、非商业的组织，把RSS发展成为一个通用的规范，并进一步标准化。于是2001年一个联合小组在0.90版本RSS的开发原则下，以W3C新一代的语义网技术RDF（Resource Description Framework）为基础，对RSS进行了重新定义，发布RSS1.0，并将RSS定义为“RDF Site Summary”。但是这项工作没有与UserLand公司进行有效的沟通，UserLand公司也不承认RSS 1.0的有效性，并坚持按照自己的设想进一步开发出RSS的后续版本，到2002年9月发布了最新版本RSS 2.0，UserLand公司将RSS定义为“Really Simple Syndication”。

目前RSS已经分化为RSS 0.9x/2.0和RSS 1.0两个阵营，由于分歧的存在和RSS 0.9x/2.0的广泛应用现状，RSS 1.0还没有成为标准化组织的真正标准。

2、 RSS目前的版本和推荐

到目前为止，RSS共有七种版本，推荐使用的是RSS 1.0和RSS 2.0，对于一些基本的站点同步，也可以选用RSS 0.91。

3、 RSS的语法介绍

一个RSS文件就是一段规范的XML数据，该文件一般以rss，xml或者rdf作为后缀。下面我们选择http://msdn.microsoft.com/visualc/rss.xml中的一部分作为例子简单说（略）

4、 RSS的联合（Syndication）和聚合（Aggregation）

发布一个RSS文件（一般称为RSS Feed）后，这个RSS Feed中包含的信息就能直接被其他站点调用，而且由于这些数据都是标准的XML格式，所以也能在其他的终端和服务中使用，如PDA、手机、邮件列表等。而且一个网站联盟（比如专门讨论旅游的网站系列）也能通过互相调用彼此的RSS Feed，自动的显示网站联盟中其他站点上的最新信息，这就叫着RSS的联合。这种联合就导致一个站点的内容更新越及时、RSS Feed被调用的越多，该站点的知名度就会越高，从而形成一种良性循环。

而所谓RSS聚合，就是通过软件工具的方法从网络上搜集各种RSS Feed并在一个界面中提供给读者进行阅读。这些软件可以是在线的WEB工具，如http://my.netscape.com ，http://my.userland.com ， http://www.xmltree.com ，http://www.moreover.com ，http://www.oreillynet.com/meerkat 等，也可以是下载到客户端安装的工具

5、 RSS的未来发展

随着越来越多的站点对RSS的支持，RSS已经成为目前最成功的XML应用。RSS搭建了信息迅速传播的一个技术平台，使得每个人都成为潜在的信息提供者。相信很快我们就会看到大量基于RSS的专业门户、聚合站点和更精确的搜索引擎。
参考资料：http://wm23.com/resource/R01/Internet_1005.htm

‘捌’ 数据结构

何谓数据结构
?
数据结构是在整个计算机科学与技术领域上广泛被使用的术语。它用来反映一个数据的内部构成，即一个数据由那些成分数据构成，以什么方式构成，呈什么结构。数据结构有逻辑上的数据结构和物理上的数据结构之分。逻辑上的数据结构反映成分数据之间的逻辑关系，而物理上的数据结构反映成分数据在计算机内部的存储安排。数据结构是数据存在的形式。 数据结构是信息的一种组织方式，其目的是为了提高算法的效率，它通常与一组算法的集合相对应，通过这组算法集合可以对数据结构中的数据进行某种操作。
?
数据结构主要研究什么？
?
数据结构作为一门学科主要研究数据的各种逻辑结构和存储结构，以及对数据的各种操作。因此，主要有三个方面的内容：数据的逻辑结构；数据的物理存储结构；对数据的操作（或算法）。通常，算法的
?
设计取决于数据的逻辑结构，算法的实现取决于数据的物理存储结构。
?
什么是数据结构？什么是逻辑结构和物理结构？
?
数据是指由有限的符号（比如，"0"和"1"，具有其自己的结构、操作、和相应的语义）组成的元素的集合。结构是元素之间的关系的集合。通常来说，一个数据结构DS 可以表示为一个二元组：
?
DS=(D,S), //i.e., data-structure=(data-part,logic-structure-part) 这里D是数据元素的集合（或者是“结点”，可能还含有“数据项”或“数据域”），S是定义在D（或其他集合）上的关系的集合，S = { R | R : D×D×...}，称之为元素的逻辑结构。 逻辑结构有四种基本类型：集合结构、线性结构、树状结构和网络结构。表和树是最常用的两种高效数据结构，许多高效的算法可以用这两种数据结构来设计实现。表是线性结构的（全序关系），树(偏序或层次关系)和图（局部有序(weak/local orders)）是非线性结构。
?
数据结构的物理结构是指逻辑结构的存储镜像(image)。数据结构 DS 的物理结构 P对应于从 DS 的数据元素到存储区M（维护着逻辑结构S）的一个映射：
?
(PD,S) -- > M 存储器模型：一个存储器 M 是一系列固定大小的存储单元，每个单元 U 有一个唯一的地址 A(U)，该地址被连续地编码。每个单元 U 有一个唯一的后继单元 U'=succ(U)。 P 的四种基本映射模型：顺序（sequential）、链接（linked）、索引（indexed）和散列（hashing）映射。
?
因此，我们至少可以得到4×4种可能的物理数据结构：
?
sequential (sets)
linked lists
indexed trees
hash graphs
?
（并不是所有的可能组合都合理）
?
??? 数据结构DS上的操作：所有的定义在DS上的操作在改变数据元素（节点）或节点的域时必须保持DS的逻辑和物理结构。
?
DS上的基本操作：任何其他对DS的高级操作都可以用这些基本操作来实现。最好将DS和他的所有基本操作看作一个整体——称之为模块。我们可以进一步将该模块抽象为数据类型（其中DS的存储结构被表示为私有成员，基本操作被表示为公共方法），称之为ADT。作为ADT，堆栈和队列都是一种特殊的表，他们拥有表的操作的子集。 对于DATs的高级操作可以被设计为（不封装的）算法，利用基本操作对DS进行处理。
?
好的和坏的DS：如果一个DS可以通过某种“线性规则”被转化为线性的DS（例如线性表），则称它为好的DS。好的DS通常对应于好的（高效的）算法。这是由计算机的计算能力决定的，因为计算机本质上只能存取逻辑连续的内存单元，因此如何没有线性化的结构逻辑上是不可计算的。比如对一个图进行操作，要访问图的所有结点，则必须按照某种顺序来依次访问所有节点（要形成一个偏序），必须通过某种方式将图固有的非线性结构转化为线性结构才能对图进行操作。
?
树是好的DS——它有非常简单而高效的线性化规则，因此可以利用树设计出许多非常高效的算法。树的实现和使用都很简单，但可以解决大量特殊的复杂问题，因此树是实际编程中最重要和最有用的一种数据结构。树的结构本质上有递归的性质——每一个叶节点可以被一棵子树所替代，反之亦然。实际上，每一种递归的结构都可以被转化为（或等价于）树形结构。
?

从机器语言到高级语言的抽象
?
我们知道，算法被定义为一个运算序列。这个运算序列中的所有运算定义在一类特定的数据模型上，并以解决一类特定问题为目标。这个运算序列应该具备下列四个特征。 有限性，即序列的项数有限，且每一运算项都可在有限的时间内完成;确定性，即序列的每一项运算都有明确的定义，无二义性;可以没有输入运算项，但一定要有输出运算项;可行性，即对于任意给定的合法的输入都能得到相应的正确的输出。这些特征可以用来判别一个确定的运算序列是否称得上是一个算法。 但是，我们现在的问题不是要判别一个确定的运算序列是否称得上是一个算法，而是要对一个己经称得上是算法的运算序列，回顾我们曾经如何用程序设计语言去表达它。
?
算法的程序表达，归根到底是算法要素的程序表达，因为一旦算法的每一项要素都用程序清楚地表达，整个算法的程序表达也就不成问题。
?
作为运算序列的算法，有三个要素。 作为运算序列中各种运算的运算对象和运算结果的数据;运算序列中的各种运算;运算序列中的控制转移。这三种要素依序分别简称为数据、运算和控制。 由于算法层出不穷，变化万千，其中的运算所作用的对象数据和所得到的结果数据名目繁多，不胜枚举。最简单最基本的有布尔值数据、字符数据、整数和实数数据等;稍复杂的有向量、矩阵、记录等数据;更复杂的有集合、树和图，还有声音、图形、图像等数据。 同样由于算法层出不穷，变化万千，其中运算的种类五花八门、多姿多彩。最基本最初等的有赋值运算、算术运算、逻辑运算和关系运算等;稍复杂的有算术表达式和逻辑表达式等;更复杂的有函数值计算、向量运算、矩阵运算、集合运算，以及表、栈、队列、树和图上的运算等:此外，还可能有以上列举的运算的复合和嵌套。 关于控制转移，相对单纯。在串行计算中，它只有顺序、分支、循环、递归和无条件转移等几种。
?
我们来回顾一下，自从计算机问世以来，算法的上述三要素的程序表达，经历过一个怎样的过程。
?
最早的程序设计语言是机器语言，即具体的计算机上的一个指令集。当时，要在计算机上运行的所有算法都必须直接用机器语言来表达，计算机才能接受。算法的运算序列包括运算对象和运算结果都必须转换为指令序列。其中的每一条指令都以编码(指令码和地址码)的形式出现。与算法语言表达的算法，相差十万八千里。对于没受过程序设计专门训练的人来说，一份程序恰似一份"天书"，让人看了不知所云，可读性
?
极差。
?
用机器语言表达算法的运算、数据和控制十分繁杂琐碎，因为机器语言所提供的指令太初等、原始。机器语言只接受算术运算、按位逻辑运算和数的大小比较运算等。对于稍复杂的运算，都必须一一分解，直到到达最初等的运算才能用相应的指令替代之。机器语言能直接表达的数据只有最原始的位、字节、和字三种。算法中即使是最简单的数据如布尔值、字符、整数、和实数，也必须一一地映射到位、字节和字
中，还得一一分配它们的存储单元。对于算法中有结构的数据的表达则要麻烦得多。机器语言所提供的控制转移指令也只有无条件转移、条件转移、进入子程序和从子程序返回等最基本的几种。用它们来构造循环、形成分支、调用函数和过程得事先做许多的准备，还得靠许多的技巧。 直接用机器语言表达算法有许多缺点。
?

大量繁杂琐碎的细节牵制着程序员，使他们不可能有更多的时间和精力去从事创造性的劳动，执行对他们来说更为重要的任务。如确保程序的正确性、高效性。程序员既要驾驭程序设计的全局又要深入每一个局部直到实现的细节，即使智力超群的程序员也常常会顾此失彼，屡出差错，因而所编出的程序可靠性差，且开发周期长。 由于用机器语言进行程序设计的思维和表达方式与人们的习惯大相径庭，只有经过
较长时间职业训练的程序员才能胜任，使得程序设计曲高和寡。因为它的书面形式全是"密"码，所以可读性差，不便于交流与合作。因为它严重地依赖于具体的计算机，所以可移植性差，重用性差。这些弊端造成当时的计算机应用未能迅速得到推广。
?
克服上述缺点的出路在于程序设计语言的抽象，让它尽可能地接近于算法语言。 为此，人们首先注意到的是可读性和可移植性，因为它们相对地容易通过抽象而得到改善。于是，很快就出现汇编语言。这种语言对机器语言的抽象，首先表现在将机器语言的每一条指令符号化:指令码代之以记忆符号，地址码代之以符号地址，使得其含义显现在符号上而不再隐藏在编码中，可让人望"文"生义。其次表现在这种语言摆脱了具体计算机的限制，可在不同指令集的计算机上运行，只要该计算机配上汇编语言的一个汇编程序。这无疑是机器语言朝算法语言靠拢迈出的一步。但是，它离算法语言还太远，以致程序员还不能从分解算法的数据、运算和控制到汇编才能直接表达的指令等繁杂琐碎的事务中解脱出来。 到了50年代中期，出现程序设计的高级语言如Fortran，Algol60，以及后来的PL/l， Pascal等，算法的程序表达才产生一次大的飞跃。
?
诚然，算法最终要表达为具体计算机上的机器语言才能在该计算机上运行，得到所需要的结果。但汇编语言的实践启发人们，表达成机器语言不必一步到位，可以分两步走或者可以筑桥过河。即先表达成一种中介语言，然后转成机器语言。汇编语言作为一种中介语言，并没有获得很大成功，原因是它离算法语
?
言还太远。这便指引人们去设计一种尽量接近算法语言的规范语言，即所谓的高级语言，让程序员可以用它方便地表达算法，然后借助于规范的高级语言到规范的机器语言的"翻译"，最终将算法表达为机器语言。而且，由于高级语言和机器语言都具有规范性，这里的"翻译"完全可以机械化地由计算机来完成，就像汇编语言被翻译成机器语言一样，只要计算机配上一个编译程序。 上述两步，前一步由程序员去完成，后一步可以由编译程序去完成。在规定清楚它们各自该做什么之后，这两步是完全独立的。它们各自该如何做互不相干。前一步要做的只是用高级语言正确地表达给定的算法，产生一个高级语言程序;后一步要做的只是将第一步得到的高级语言程序翻译成机器语言程序。至于程序员如何用高级语言表达算法和编译程序如何将高级语言表达的算法翻译成机器语言表达的算法，显然毫不相干。
?
处理从算法语言最终表达成机器语言这一复杂过程的上述思想方法就是一种抽象。汇编语言和高级语言的出现都是这种抽象的范例。 与汇编语言相比，高级语言的巨大成功在于它在数据、运算和控制三方
?
面的表达中引入许多接近算法语言的概念和工具，大大地提高抽象地表达算法的能力。 在运算方面，高级语言如Pascal，除允许原封不动地运用算法语言的四则运算、逻辑运算、关系运算、算术表达式、逻辑表达式外，还引入强有力的函数与过程的工具，并让用户自定义。这一工具的重要性不仅在于它精简了重复的程序文本段，而且在于它反映出程序的两级抽象。
?
在函数与过程调用级，人们只关心它能做什么，不必关心它如何做。只是到函数与过程的定义时，人们才给出如何做的细节。用过高级语言的读者都知道，一旦函数与过程的名称、参数和功能被规定清楚，那么，在程序中调用它们便与在程序的头部说明它们完全分开。你可以修改甚至更换函数体与过程体，而不影响它们的被调用。如果把函数与过程名看成是运算名，把参数看成是运算的对象或运算的结果，那么
?
，函数与过程的调用和初等运算的引用没有两样。利用函数和过程以及它们的复合或嵌套可以很自然地表达算法语言中任何复杂的运算。
?
在数据方面，高级语言如Pascal引人了数据类型的概念，即把所有的数据加以分类。每一个数据(包括表达式)或每一个数据变量都属于其中确定的一类。称这一类数据为一个数据类型。 因此，数据类型是数据或数据变量类属的说明，它指示该数据或数据变量可能取的值的全体。对于无结构的数据，高级语言如Pascal，除提供标准的基本数据类型--布尔型、字符型、整型和实型外，还提供用户可自定义的枚举类、子界类型和指针类型。这些类型(除指针外)，其使用方式都顺应人们在算法语言中使用的习惯。对于有结构的数据，高级语言如Pascal，提供了数组、记录、有限制的集合和文件等四种标准的结构数据类型。其中，数组是科学计算中的向量、矩阵的抽象;记录是商业和管理中的记录的抽象;有限制的集合是数学中足够小的集合的势集的抽象;文件是诸如磁盘等外存储数据的抽象。
?
人们可以利用所提供的基本数据类型(包括标准的和自定义的)，按数组、记录、有限制的集合和文件的构造规则构造有结构的数据。 此外，还允许用户利用标准的结构数据类型，通过复合或嵌套构造更复杂更高层的结构数据。这使得高级语言中的数据类型呈明显的分层。 高级语言中数据类型的分层是没有穷尽的，因而用它们可以表达算法语言中任何复杂层次的数据。 在控制方面，高级语言如Pascal，提供了表达算法控制转移的六种方式。
?
(1)缺省的顺序控制";"。
?
(2)条件(分支)控制:"if表达式(为真)then S1 else S2;" 。
?
(3)选择(情况)控制:
?
"Case 表达式 of
?
值1: S1
值2: S2
...
值n: Sn
end"
?
(4)循环控制:
?
"while 表达式(为真) do S;" 或
"repeat S until 表达式(为真);" 或
"for变量名:=初值 to/downto 终值do S;"
?
(5)函数和过程的调用，包括递归函数和递归过程的调用。
?
(6)无条件转移goto。

这六种表达方式不仅覆盖了算法语言中所有控制表达的要求，而且不再像机器语言或汇编语言那样原始、那样繁琐、那样隐晦，而是如上面所看到的，与自然语言的表达相差无几。 程序设计语言从机器语言到高级语言的抽象，带来的主要好处是： 高级语言接近算法语言，易学、易掌握，一般工程技术人员只要几周时间的培训就可以胜任程序员的工作；高级语言为程序员提供了结构化程序设计的环境和工具，使得设计出来的程序可读性好，可维护性强，可靠性高；高级语言远离机器语言，与具体的计算机硬件关系不大，因而所写出来的程序可移植性好，重用率高； 由于把繁杂琐碎的事务交给了编译程序去做，所以自动化程度高，开发周期短，且程、序员得到解脱，可以集中时间和精力去从事对于他们来说更为重要的创造性劳动，以提高、程序的质量。
?
数据结构、数据类型和抽象数据类型
?
数据结构、数据类型和抽象数据类型，这三个术语在字面上既不同又相近，反映出它们在含义上既有区别又有联系。
?
数据结构是在整个计算机科学与技术领域上广泛被使用的术语。它用来反映一个数据的内部构成，即一个数据由哪些成分数据构成，以什么方式构成，呈什么结构。数据结构有逻辑上的数据结构和物理上的数据结构之分。逻辑上的数据结构反映成分数据之间的逻辑关系，物理上的数据结构反映成分数据在计算机内的存储安排。数据结构是数据存在的形式。
?
数据是按照数据结构分类的，具有相同数据结构的数据属同一类。同一类数据的全体称为一个数据类型。在程序设计高级语言中，数据类型用来说明一个数据在数据分类中的归属。它是数据的一种属性。这个属性限定了该数据的变化范围。为了解题的需要，根据数据结构的种类，高级语言定义了一系列的数据类型。不同的高级语言所定义的数据类型不尽相同。Pascal语言所定义的数据类型的种类。
?
其中，简单数据类型对应于简单的数据结构;构造数据类型对应于复杂的数据结构;在复杂的数据结构里，允许成分数据本身具有复杂的数据结构，因而，构造数据类型允许复合嵌套;指针类型对应于数据结构中成分数据之间的关系，表面上属简单数据类型，实际上都指向复杂的成分数据即构造数据类型中的数据，因此这里没有把它划入简单数据类型，也没有划入构造数据类型，而单独划出一类。
?
数据结构反映数据内部的构成方式，它常常用一个结构图来描述:数据中的每一项成分数据被看作一个结点，并用方框或圆圈表示，成分数据之间的关系用相应的结点之间带箭号的连线表示。如果成分数据本身又有它自身的结构，则结构出现嵌套。这里嵌套还允许是递归的嵌套。
?
由于指针数据的引入，使构造各种复杂的数据结构成为可能。按数据结构中的成分数据之间的关系，数据结构有线性与非线性之分。在非线性数据结构中又有层次与网状之分。 由于数据类型是按照数据结构划分的，因此，一类数据结构对应着一种数据类型。数据类型按照该类型中的数据所呈现的结构也有线性与非线性之分，层次与网状之分。一个数据变量，在高级语言中的类型说明必须是读变量所具有的数据结构所对应的数据类型。最常用的数据结构是数组结构和记录结构。数组结构的特点是：
?
成分数据的个数固定，它们之间的逻辑关系由成分数据的序号(或叫数组的下标)来体现。这些成分数据按照序号的先后顺序一个挨一个地排列起来。每一个成分数据具有相同的结构(可以是简单结构，也可以是复杂结构)，因而属于同一个数据类型(相应地是简单数据类型或构造数据类型)。这种同一的数据类型称为基类型。所有的成分数据被依序安排在一片连续的存储单元中。 概括起来，数组结构是一个线性的、均匀的、其成分数据可随机访问的结构。
?
由于这、种结构有这些良好的特性，所以最常被人们所采用。在高级语言中，与数组结构相对应的、数据类型是数组类型，即数组结构的数据变量必须说明为array [i] of T0 ，其中i是数组、结构的下标类型，而T0是数组结构的基类型。 记录结构是另一种常用的数据结构。它的特点是:与数组结构一样，成分数据的个数固定。但成分数据之间没有自然序，它们处于平等地位。每一个成分数据被称为一个域并赋予域名。不同的域有不同的域名。不同的域允许有不同的结构，因而允许属于不同的数据类型。与数组结构一样，它们可以随机访问，但访问的途径靠的是域名。在高级语言中记录结构对应的数据类型是记录类型。记录结构的数据的变量必须说明为记录类型。
?
抽象数据类型的含义在上一段已作了专门叙述。它可理解为数据类型的进一步抽象。即把数据类型和数据类型上的运算捆在一起，进行封装。引入抽象数据类型的目的是把数据类型的表示和数据类型上运算的实现与这些数据类型和运算在程序中的引用隔开，使它们相互独立。对于抽象数据类型的描述，除了必须描述它的数据结构外，还必须描述定义在它上面的运算(过程或函数)。抽象数据类型上定义的过程和函
数以该抽象数据类型的数据所应具有的数据结构为基础。
?
泛型设计和数据结构与算法
?
下面我想再说说关于泛型程序设计模型对于数据结构和算法方面的最新推动，泛型思想已经把数据结
?
构和算法方面的基本思想抽象到了一个前所未有的高度，现在有多种程序设计语言支持泛型设计，比如
ADA，C++，而且据说在JAVA的下一版本和C#中也将对泛型设计进行全面的支持。
?
先说说泛型设计的基本思想：泛型编程（generic programming，以下直接以GP称呼）是一种全新的程序设计思想，和OO，OB，PO这些为人所熟知的程序设计想法不同的是GP抽象度更高，基于GP设计的组件之间偶合度底，没有继承关系，所以其组件间的互交性和扩展性都非常高。我们都知道，任何算法都是作用在一种特定的数据结构上的，最简单的例子就是快速排序算法最根本的实现条件就是所排序的对象是存
贮在数组里面，因为快速排序就是因为要用到数组的随机存储特性，即可以在单位时间内交换远距离的对象，而不只是相临的两个对象，而如果用联表去存储对象，由于在联表中取得对象的时间是线性的既O[n]，这样将使快速排序失去其快速的特点。也就是说，我们在设计一种算法的时候，我们总是先要考虑其应用的数据结构，比如数组查找，联表查找，树查找，图查找其核心都是查找，但因为作用的数据结构不同
?
将有多种不同的表现形式。数据结构和算法之间这样密切的关系一直是我们以前的认识。泛型设计的根本思想就是想把算法和其作用的数据结构分离，也就是说，我们设计算法的时候并不去考虑我们设计的算法将作用于何种数据结构之上。泛型设计的理想状态是一个查找算法将可以作用于数组，联表，树，图等各种数据结构之上，变成一个通用的，泛型的算法。这样的理想是不是很诱惑人？
?
泛型编程带来的是前所未有的弹性以及不会损失效率的抽象性，GP和OO不同，它不要求你通过额外的间接层来调用函数：它让你撰写完全一般化并可重复使用的算法，其效率与针对特定数据结构而设计的算法旗鼓相当。我们大家都知道数据结构在C++中可以用用户定义类型来表示，而C++中的模板技术就是以类型作为参数，那么我可以想象利用模板技术可以实现我们开始的GP思想，即一个模板函数可以对于各种传递进来的类型起作用，而这些类型就可以是我们定义的各种数据结构。
?
泛型算法抽离于特定类型和特定数据结构之外，使得其适应与尽可能的一般化类型，算法本身只是为了实现算法其需要表达的逻辑本质而不去被为各种数据结构的实现细节所干扰。这意味着一个泛型算法实际具有两部分。1，用来描叙算法本质逻辑的实际指令；2，正确指定其参数类型必须满足的性质的一组需求条件。到此，相信有不少人已经开始糊涂了，呵呵，不要紧。毕竟GP是一种抽象度非常高的程序设计思想，里面的核心就是抽象条件成为成为程序设计过程中的核心，从而取代了类型这在OO里面的核心地位，正是因为类型不在是我们考虑的重点，类型成为了抽象条件的外衣，所以我们称这样的程序思想为泛型思想------把类型泛化。
这样可以么？

‘玖’ c++ 怎么学,我只要过程就行了,

软件:Visual C++6.0
书籍如果要国内的就是清华大学潭浩强教授的<<C++程序设计>>,这本书说得很容易懂,潭浩强可是一代大师呀,你到网上搜一下就知道了,而且这本书也是很多大学使用的教材,是很多学生的入门教材,我想也会适合你的.

如果要国外的,就用<<C++ primer>>吧,都已经出到第四版了,而且也有中文翻译的.如果嫌太贵了,也可以到图书馆借一本方便初学者入门的书.

入门的时候会碰到很多问题的,要多编程,课后的习题最好都做一片.这对熟悉它的语法使用很重要.就算是书本的例子,你觉得怪怪的,都可以打进电脑运行一片,这都会有助于理解.

把第一本教材弄懂了,以后就好办了.过了这个阶段,你对基础知识已经有了一定的理解,特别对一些难点,如指针,IO操作要真的很熟悉.就可以往高级点的学了.

下一步,可以学一下C++标准库,里面最重要的就是STL了,这有很多模板,使用它对提高效率有很大的帮助.

同时,可以编一二个比较综合的课程设计,如学生管理系统,我想你也看到,接近学期末的时候,在网络知道有很多人叫别人做课程设计的,其实最好就是自己动手了,才能尝到的,这个过程可以得到很多经验,很重要哦.

两次,你可以对C++更深入的了解,有一本书实在太出名了,就是<<C++编程思想>>,看完这本书,可以得到一个升华,(不是随便看一片,至少看懂大部分吧).

如果你还想更深入,可以考虑侯杰的<<STL源码剖析>>,这本书实在太高深了,我也有很多弄不懂的,现在.

不过,你可以学习Windows编程了,确实一点说,就是要会用MFC类库,这样可以编出一些界面很好的程序,Visual C++更是不能缺少的.

到了这个阶段,这想你也可以知道要学什么了,有向网络编程了,有多媒体了,有图形学了.

最后说一下,算法,就是你后期的最需要部分了.这里推荐一本<<算法导论>>.

说了这么多,都是我的亲身体会,希望对你有用.谁还能在别处看到或搜索到我这的内容就算是我复制的了.我相信没有别处比这更早有这内容了.确是我的确体会.