财富论语

张丽洁

心理学课上，周正教授正在授课：“上次下课时，一个男孩递过来一张纸条：我是个比较内向的人，又没有什么特长，不会踢足球，不会打篮球……唯一的爱好就是写作。进入大学以后，看了周围同学在交往，工作中左右逢源。如鱼得水，洒脱干练，很是羡慕。就要步入社会了，我该如何规划自己的前途呢？……周教授，我想我还是当一名作家比较好，一个人，也不错，您说呢？这个问题要不要回答？”周教授杨了扬手中的纸条。

“回——答———”同学兴致大起，作家梦可是不少惮于竞争之人的救命稻草啊！

周教授放下手中的纸条：“好，今天我就当面回答这位同学——我的态度，很简单：凡是作家梦的人，都是逃避现实的，无能的人……”

话音未落，下面已是一片嘘声。                   

“我来问问你们，一支笔，一张纸的事，谁不会？当作家，就是这麽简单，人人都会。我常说，一流人才在军界和商界，二流人才在政界，三流人才在学术界。对军人而言，你领十万人打仗，我领十万人打仗，明天打仗，看本事吧，没本事，死的十万就是你的。这里要的是综合素质，是挑战，所以军界的人是最强的。商界也如此，投入两个亿三个月后，可能家破人亡，你干不干？要的是同样的素质。政界就不同，他可以调整，迂回，政策不行可以再改，是有余地的，但要负责任。而学术界，一次不行两次，两次不行三次……永远不行都可以。军人和商人的成败一目了然，惟有作家可进可退，无所谓胜负成败……”有人若有所思地点点头。

“某著名作家在一所大学做讲座的时候，有同学问他怎样才能当作家？他说：“首先养活你的家，再说当作家！””周教授认真的看着大家，眼神里自然地流露出一种深切的关爱，“《论语》中有记载：一次孔子来到卫国，见卫国人很多，就说‘庶已哉’意思是‘卫国人多啊’。旁边有人问‘既庶已，又何加焉？’，意思是‘人多，怎么办呢？’————问题来了，有人，人多了，怎么办呢？我们该做点什么呢？你们认为孔子会怎么说？”

“教之——”大家很自信，大教育家嘛。

周教授微笑着摇摇头：“子曰：‘富之’。”——孔子说：‘让他们富起来’你们以为有了人就要教育，却不知道在教育之前，首先要人富起来。旁人又问：‘既富已，又何加焉？’——‘人们富足以后，又该如何？’

“教之——”大家会心一笑。

“对，人富足了才有条件接受教育。吃不好穿不暖的时候，教育是句空话，况且对衣食无安的人大谈教育，这种行为本身就不厚道。孔子不愧是大教育家他这‘不富不教’的意义很深远！按照心理学家马斯洛的需求层次理论，人只有满足了基本的生理需求以后，才会去考虑安全，爱与被爱的需要，才会有自我实现的需要。”

“举例而言，勒紧腰带过日子的小两口，到了情人节，丈夫一咬牙，送爱妻一大束玫瑰，这时候妻子什么感觉？”

“浪费吧？”

“是浪费！”同学们争起来。

“还不如送我一双毛皮手套呢！你看看，这个冬天我的手又冻了，净花冤枉钱……”周教授开玩笑似的嗔怪道，大家在嬉笑中亦有所感悟。

“当人过日子都紧张的时候，是不会想着浪漫的，那是有钱人的享受。问你们一个常识：知道雄鸟追求雌鸟的时候，送给雌鸟的是什么？”

“虫子”

“对啊，一送虫子，雌鸟就会意了：这家伙生存能力强，跟着他，以后我们的孩子不会挨饿，这是一个连鸟都懂的道理。”

下面安静极了，生怕漏掉周教授的任何一句话。

“‘仓廪实而知礼节，衣食足而知荣辱’自古以来，人们便说‘饥寒起盗心’。能吃的好，穿的好，生活安定之后才能让晚辈过正常的生活。如果没有东西吃，连父母的东西也会强过来吃，兄弟就更不用提了。在人们陷入最差的生活状态是，就顾不得什么道义。这就是人类真正的本性。中国的先哲早在几千年以前，就已指出了人类的真实形貌。”

“再衣食无法获得满足时，依然能保持礼节，这是凡人作不到的事情。”

“如果希望这种兽性不要出现，期待我们最理想的人性流露，也是为了维持社会秩序，提高道义，彼此能懂得礼貌，并以此幸福生活，就必须确保每一个人都能有自己的收入。换句话说，要让大家都能赚到钱，基于义务，我们必须要赚钱才行。”

必须赚钱——看来，所谓“以人为本”。我们并不比古人懂得多 。

“雄性丧失了生存能力就丧失了天赋雄性只本性。历史表明，男人的不幸，民族的不幸源于贫穷。所谓‘贫困交家’‘穷凶恶极’……因此，你们必须认识到，挣钱是公德，要重视金钱，我这样告诉你，你可以不会踢足球，可以不会打篮球，可以不会做诗，不会谈琴，不会做饭。可以什么都不会，但是必须会挣钱。”

周教授的话字字珠玑，鞭辟入里。我感觉很多男生的眼睛在放光，不知他们看到的是压力还是希望？

“最后，再给你们一个例子，你们用心思考。比如说，快到春节了，太太说：该过春节了，咱爸妈想来深圳这边，看看咱们和小外孙。她先生马上就说：‘来啥来？根本不用来！咱们已经忙的够呛了，再让他们过来，净添乱！再说，这路上，老人多不方便！’这个男人现在是什么状态？”

“气急败坏！”有人笑着回答。

“记住，凡是气急败坏的男人都是穷男人。但是另外一家，太太说：老公啊，快过春节了，老人们都想来看看咱们，一年没见面了！先生说：‘哦，好啊好啊，应该让他们过来。这样，你让他们坐飞机过来。’这个男人就不气急败坏，他很平静。‘还有，你看，咱们家的 房子，这三层七八间，冷冷清清的，孩子也没有人陪着玩。爷爷奶奶来了，或者姥姥老爷来了，家里有生气，这样多好！’他为什么这样说？因为这个男人有钱，他不怕，他有地方住，有钱让父母过来，他有方法显示他的孝心，而且这种男人往往不会发脾气。因为他有很大的控制权，有很好的基础，任何事情到他这里都可以化解，可以平静的对待。然后，一家人高高兴兴的过了春节。老人走的时候，先生问太太：爸妈他们有什么要求没有？‘没有没有，他们都很高兴，一点要求都没有。’先生说：‘听说老三要结婚，没房子住，他们想空出房子去住老房。这怎么可以呢？这样，在老家花六万，我们出三万，三第拿三万，盖一栋二层小楼让他们住，爸妈就不用动了。’听了这话，太太抱着丈夫说不出话来，这样的老公哪个太太不爱不感激呢？好，房子盖成了，弟弟都说姐夫是好人，全村羡慕，父母开心，一家生活幸福。3万块钱，只是他一个月的工资，他愿意拿出这三万块钱。”

周教授最后说：“愿意做哪一个，你们自己选择。但是，要记住：知识不一定会带来金钱，挣钱靠的是能力。”

下面的这些要点是对所有的C++程序员都适用的。我之所以说它们是最重要的，是因为这些要点中提到的是你通常在C++书中或网站上无法找到的。如：指向成员的指针，这是许多资料中都不愿提到的地方，也是经常出错的地方，甚至是对一些高级的C++程序员也是如此。
　　这里的要点不仅仅是解释怎样写出更好的代码，更多的是展现出语言规则里面的东西。很显然，它们对C++程序员来说是永久的好资料。我相信这一篇文章会使你收获不小。

　　首先，我把一些由不同层次的C++程序员经常问的问题归到一起。我惊奇的发现有很多是有经验的程序员都还没意识到 .h 符号是否还应该出现在标准头文件中。

要点1: <iostream.h> 还是 <iostream>?

　　很多C++程序员还在使用<iostream.h>而不是用更新的标准的<iostream>库。这两者都有什么不同呢？首先，5年前我们就开始反对把.h符号继续用在标准的头文件中。继续使用过时的规则可不是个好的方法。从功能性的角度来讲，<iostream>包含了一系列模板化的I/O类，相反地<iostream.h>只仅仅是支持字符流。另外，输入输出流的C++标准规范接口在一些微妙的细节上都已改进，因此，<iostream>和<iostream.h>在接口和执行上都是不同的。最后，<iostream>的各组成都是以STL的形式声明的，然而<iostream.h>的各组成都是声明成全局型的。

　　因为这些实质上的不同，你不能在一个程序中混淆使用这两个库。做为一种习惯，在新的代码中一般使用<iostream>，但如果你处理的是过去编写的代码，为了继承可以用继续用<iostream.h>旧保持代码的一致性。　　

要点2：用引用传递参数时应注意的地方

　　在用引用传递参数时，最好把引用声明为const类型。这样做的好处是：告诉程序不能修改这个参数。在下面的这个例子中函数f()就是传递的引用：   
void f(const int & i);
int main()
{
　f(2); /* OK */
}   
　　这个程序传递一个参数2给f()。在运行时，C++创建一个值为2的int类型的临时变量，并传递它的引用给f().这个临时变量和它的引用从f()被调用开始被创建并存在直到函数返回。返回时，就被马上删除。注意，如果我们不在引用前加上const限定词，则函数f()可能会更改它参数的值，更可能会使程序产生意想不到的行为。所以，别忘了const。

　　这个要点也适用于用户定义的对象。你可以给临时对象也加上引用如果是const类型：   
struct A{};
void f(const A& a);
int main()
{
　f(A()); // OK,传递的是一个临时A的const引用
}    

要点3：“逗号分离”表达形式

　“逗号分离”表达形式是从C继承来的，使用在for-和while-循环中。当然，这条语法规则被认为是不直观的。首先，我们来看看什么是“逗号分离”表达形式。

　　一个表达式由一个或多个其它表达式构成，由逗号分开，如：   
　if(++x, --y, cin.good()) //三个表达式   
　　这个if条件包含了三个由逗号分离的表达式。C++会计算每个表达式，但完整的“逗号分离”表达式的结果是最右边表达式的值。因此，仅当cin.good()返回true时，if条件的值才是true。下面是另一个例子：   
int j=10;
int i=0;
while( ++i, --j)
{
　//直到j＝0时，循环结束，在循环时，i不断自加
}   

要点4，使用全局对象的构造函数在程序启动前调用函数

　　有一些应用程序需要在主程序启动前调用其它函数。如：转态过程函数、登记功能函数都是必须在实际程序运行前被调用的。最简单的办法是通过一个全局对象的构造函数来调用这些函数。因为全局对象都是在主程序开始前被构造，这些函数都将会在main()之前返回结果。如：   
class Logger
{
　public:
　Logger()
　　{
　　　activate_log();//译者注：在构造函数中调用你需要先运行的函数
　　}
};
Logger log; //一个全局实例
int main()
{
　record * prec=read_log();//译者注：读取log文件数据
　//.. 程序代码
}   
　　全局对象log在main()运行之前被构造，log调用了函数activate_log()。从而，当main()开始执行时，它就可以从log文件中读取数据。

　　毫无疑问地，在C++编程中内存管理是最复杂和最容易出现bug的地方。直接访问原始内存、动态分配存储和最大限度的发挥C++指令效率，都使你必须尽力避免有关内存的bug。
　　
要点5：避免使用复杂构造的指向函数的指针

　　指向函数的指针是C++中可读性最差的语法之一。你能告诉我下面语句的意思吗？    
void (*p[10]) (void (*)());   
　　P是一个“由10个指针构成的指向一个返回void类型且指向另一个无返回和无运算的函数的数组”。这个麻烦的语法真是让人难以辨认，不是吗？你其实可以简单的通过typedef来声明相当于上面语句的函数。首先，使用typedef声明“指向一个无返回和无运算的函数的指针”：   
typedef void (*pfv)();   
　　接着，声明“另一个指向无返回且使用pfv的函数指针”：   
typedef void (*pf_taking_pfv) (pfv);   
　　现在，声明一个由10个上面这样的指针构成的数组：   
pf_taking_pfv p[10];   
　　与void (*p[10]) (void (*)())达到同样效果。但这样是不是更具有可读性了！   

要点6：指向成员的指针

　　一个类有两种基本的成员：函数成员和数据成员。同样的，指向成员的指针也有两种：指向函数成员的指针和指向数据成员的指针。后则其实并不常用，因为类一般是不含有公共数据成员的，仅当用在继承用C写的代码时协调结构（struct)和类(class)时才会用到。

　　指向成员的指针是C++语法中最难以理解的构造之一，但是这也是一个C++最强大的特性。它可以让你调用一个类的函数成员而不必知道这个函数的名字。这一个非常敏捷的调用工具。同样的，你也可以通过使用指向数据成员的指针来检查并改变这个数据而不必知道它的成员名字。
　　指向数据成员的指针

　　尽管刚开始时，指向成员的指针的语法会使你有一点点的迷惑，但你不久会发现它其实同普通的指针差不多，只不过是*号的前面多了::符号和类的名字，例：定义一个指向int型的指针：   
int * pi;    
　　定义一个指向为int型的类的数据成员：   
int A::*pmi; //pmi是指向类A的一个int型的成员   
　　你可以这样初始化它：   
class A
{
　public:
　int num;
　int x;
};
int A::*pmi = & A::num;    
　　上面的代码是声明一个指向类A的一个int型的num成员并将它初始化为这个num成员的地址.通过在pmi前面加上*你就可以使用和更改类A的num成员的值：   
A a1, a2;
int n=a1.*pmi; //把a1.num赋值给n
a1.*pmi=5; // 把5赋值给a1.num
a2.*pmi=6; // 把6赋值给6a2.num    
　　如果你定义了一个指向类A的指针，那么上面的操作你必须用 ->*操作符代替：   
A * pa=new A;
int n=pa->*pmi;
pa->*pmi=5;    

　　指向函数成员的指针

　　它由函数成员所返回的数据类型构成，类名后跟上::符号、指针名和函数的参数列表。举个例子：一个指向类A的函数成员（该函数返回int类型）的指针：   
class A
{
　public:
　int func ();
};
int (A::*pmf) ();    
　　上面的定义也就是说pmf是一个指向类A的函数成员func()的指针.实际上，这个指针和一个普通的指向函数的指针没什么不同，只是它包含了类的名字和::符号。你可以在在任何使用*pmf的地方调用这个函数   
func()：
pmf=&A::func;
A a;
(a.*pmf)(); //调用a.func()   
　　如果你先定义了一个指向对象的指针，那么上面的操作要用->*代替：   
A *pa=&a;
(pa->*pmf)(); //调用pa->func()   
　　指向函数成员的指针要考虑多态性。所以，当你通过指针调用一个虚函数成员时，这个调用将会被动态回收。另一个需要注意的地方，你不能取一个类的构造函数和析构函数的地址。
要点7、避免产生内存碎片

　　经常会有这样的情况：你的应用程序每运行一次时就因为程序自身缺陷而产生内存漏洞而泄漏内存，而你又在周期性地重复着你的程序，结果可想而知,它也会使系统崩溃。但怎样做才能预防呢？首先，尽量少使用动态内存。在大多数情况下，你可能使用静态或自动存储或者是STL容器。第二，尽量分配大块的内存而不是一次只分配少量内存。举个例子：一次分配一个数组实例所需的内存，而不是一次只分配一个数组元素的内存。
要点8、是delete还是delete[]

　　在程序员中有个荒诞的说法：使用delete来代替delete[]删除数组类型时是可以的！
　　举个例子吧：   
　int *p=new int[10];
　delete p; //错误，应该是：delete[] p   
　　上面的程序是完全错误的。事实上，在一个平台上使用delete代替delete[]的应用程序也许不会造成系统崩溃，但那纯粹是运气。你不能保证你的应用程序是不是会在另一个编译器上编译，在另一个平台上运行，所以还是请使用delete[]。
要点9、优化成员的排列

　　一个类的大小可以被下面的方式改变：   
struct A
{
　bool a;
　int b;
　bool c;
}; //sizeof (A) == 12   
　　在我的电脑上sizeof (A) 等于12。这个结果可能会让你吃惊，因为A的成员总数是6个字节：1+4+1个字节。那另6字节是哪儿来的？编译器在每个bool成员后面都插入了3个填充字节以保证每个成员都是按4字节排列，以便分界。你可以减少A的大小，通过以下方式：   
struct B
{
　bool a;
　bool c;
　int b;
}; // sizeof (B) == 8   
　　这一次，编译器只在成员c后插入了2个字节。因为b占了4个字节，所以就很自然地把它当作一个字的形式排列，而a和c的大小1+1=2，再加上2个字节就刚好按两个字的形式排列B。    

要点10、为什么继承一个没有虚析构函数的类是危险的？

　　一个没有虚析构函数的类意味着不能做为一个基类。如std::string, std::complex, 和 std::vector 都是这样的。为什么继承一个没有虚析构函数的类是危险的？当你公有继承创建一个从基类继承的相关类时，指向新类对象中的指针和引用实际上都指向了起源的对象。因为析构函数不是虚函数，所以当你delete一个这样的类时，C++就不会调用析构函数链。举个例子说明：   
class A
{
　public:
　~A() // 不是虚函数
　{
　// ...
　}
};
class B: public A //错; A没有虚析构函数
{
　public:
　~B()
　{
　// ...
　}
};
int main()
{
　A * p = new B; //看上去是对的
　delete p; //错，B的析构函没有被调用
}   

要点11、以友元类声明嵌套的类

　　当你以友元类声明一个嵌套的类时，把友元声明放在嵌套类声明的后面，而不前面。   
class A
{
　private:
　int i;
　public:
　class B //嵌套类声明在前
　{
　　public:
　　B(A & a) { a.i=0;};
　};
　friend class B;//友元类声明
};   
　　如果你把友元类声明放在声明嵌套类的前面，编译器将抛弃友元类后的其它声明。