您需要注意的c++ 的11个要点[转贴] 基础知识
[code]下面的这些要点是对所有的C++程序员都适用的。我之所以说它们是最重要
的，是因为这些要点中提到的是你通常在C++书中或网站上无法找到的。如：指向
成员的指针，这是许多资料中都不愿提到的地方，也是经常出错的地方，甚至是对 S%e/z1Y/Z%n8c]:n
一些高级的C++程序员也是如此。
这里的要点不仅仅是解释怎样写出更好的代码，更多的是展现出语言规则里面 {1o5Vn@ }
的东西。很显然，它们对C++程序员来说是永久的好资料。我相信这一篇文章会使 h6ns6Iz E
你收获不小。
首先，我把一些由不同层次的C++程序员经常问的问题归到一起。我惊奇的发
现有很多是有经验的程序员都还没意识到 .h 符号是否还应该出现在标准头文件
中。 ;c-J5aA {
N DI0X6A
]c(g#B/v2yd4[4X2]2Bh
要点1: <iostream.h> 还是 <iostream>? 1Wp t,T w9z
f&q Y` _ af7b
很多C++程序员还在使用<iostream.h>而不是用更新的标准的<iostream>库。
这两者都有什么不同呢？首先，5年前我们就开始反对把.h符号继续用在标准的头 ]K X.th'L{H
文件中。继续使用过时的规则可不是个好的方法。从功能性的角度来讲，
<iostream>包含了一系列模板化的I/O类，相反地<iostream.h>只仅仅是支持字符
流。另外，输入输出流的C++标准规范接口在一些微妙的细节上都已改进，因此， qug*B ~ O
<iostream>和<iostream.h>在接口和执行上都是不同的。最后，<iostream>的各组 4_2i x(TA&MP
成都是以STL的形式声明的，然而<iostream.h>的各组成都是声明成全局型的。 (p4{:lC+E kv
因为这些实质上的不同，你不能在一个程序中混淆使用这两个库。做为一种习 6a.H9d ve'^y
惯，在新的代码中一般使用<iostream>，但如果你处理的是过去编写的代码，为了 U0F Y j%l&^
继承可以用继续用<iostream.h>旧保持代码的一致性。
D+^#LZ^ y:G
^w Fg&Q H7z0?
要点2：用引用传递参数时应注意的地方 !Uu"w)c;S{|,b V~
6bH^4x;P e"H
在用引用传递参数时，最好把引用声明为const类型。这样做的好处是：告诉 P.E5m V#C MGl_
程序不能修改这个参数。在下面的这个例子中函数f()就是传递的引用：
void f(const int & i); 7DU2Zeb].S
int main() g/p7N!wR'd9D7`
{ 4W r9RmxD
f(2); /* OK */
} N.I+{pX NL#^1F
这个程序传递一个参数2给f()。在运行时，C++创建一个值为2的int类型的临 T7h V vy1p+@Cbh
时变量，并传递它的引用给f().这个临时变量和它的引用从f()被调用开始被创建 -Z3v_sLMd"B'A
并存在直到函数返回。返回时，就被马上删除。注意，如果我们不在引用前加上 9\#zl&G!A#im? j'\
const限定词，则函数f()可能会更改它参数的值，更可能会使程序产生意想不到的 -QX `dzCDg
行为。所以，别忘了const。
7|}"xhm/T
这个要点也适用于用户定义的对象。你可以给临时对象也加上引用如果是
const类型：
!W K$cx+Z2EkJ~
struct A{};
void f(const A& a);
int main() Qh R T4r8Rc
{
f(A()); // OK,传递的是一个临时A的const引用 Wh-C bT\`.\b
} S l6ox$O4QOE
ehI q,k r$Z#t
要点3：“逗号分离”表达形式 ?-n w&M:[
3O s3n!]T*B.xc)q
“逗号分离”表达形式是从C继承来的，使用在for-和while-循环中。当然，这
条语法规则被认为是不直观的。首先，我们来看看什么是“逗号分离”表达形式。
一个表达式由一个或多个其它表达式构成，由逗号分开，如： c'_ bww [
if(++x, --y, cin.good()) //三个表达式
这个if条件包含了三个由逗号分离的表达式。C++会计算每个表达式，但完整 cMlnB
的“逗号分离”表达式的结果是最右边表达式的值。因此，仅当cin.good()返回 pyCB t^
true时，if条件的值才是true。下面是另一个例子：
int j=10;
int i=0;
while( ++i, --j) zF kF%qz v.x,j3@
{
//直到j＝0时，循环结束，在循环时，i不断自加 .},GE2\;Z bt
} k o|+hx\ K(_f
要点4，使用全局对象的构造函数在程序启动前调用函数
有一些应用程序需要在主程序启动前调用其它函数。如：转态过程函数、登记 yy }x2c W
功能函数都是必须在实际程序运行前被调用的。最简单的办法是通过一个全局对象
的构造函数来调用这些函数。因为全局对象都是在主程序开始前被构造，这些函数
都将会在main()之前返回结果。如：
class Logger 7El lVV$^
{ Lie+}S!w Z
public: | V6q8{8y-X u6d}
Logger() "F oxXwr
{
activate_log();//译者注：在构造函数中调用你需要先运行的函数
}
}; 7rV+nT3j/e&St
Logger log; //一个全局实例 -s*k U*^!F G[.@Tc4ZE
int main() C,m ]!Q*{)C I
{ \ Dn%r7e^
record * prec=read_log();//译者注：读取log文件数据
//.. 程序代码
} :t l7r2~/O FW{
全局对象log在main()运行之前被构造，log调用了函数activate_log()。从 4E8U6c c o!`ZF
而，当main()开始执行时，它就可以从log文件中读取数据。 2WU;E |k f.^
e1x h a}:sr5S M
毫无疑问地，在C++编程中内存管理是最复杂和最容易出现bug的地方。直接访 '?,u|} } o
问原始内存、动态分配存储和最大限度的发挥C++指令效率，都使你必须尽力避免
有关内存的bug。
*xT{`V!g
要点5：避免使用复杂构造的指向函数的指针 U%wl*OP w s ^t
指向函数的指针是C++中可读性最差的语法之一。你能告诉我下面语句的意思 G(}#J:K%j7\
吗？
void (*p[10]) (void (*)()); },g!P9wK'x
P是一个“由10个指针构成的指向一个返回void类型且指向另一个无返回和无
运算的函数的数组”。这个麻烦的语法真是让人难以辨认，不是吗？你其实可以简
单的通过typedef来声明相当于上面语句的函数。首先，使用typedef声明“指向一
个无返回和无运算的函数的指针”： K E+d#L4L7l k
typedef void (*pfv)(); 6D` ]#w6c4eu,ry
接着，声明“另一个指向无返回且使用pfv的函数指针”： (z ?wK^!z{0?3E
typedef void (*pf_taking_pfv) (pfv);
现在，声明一个由10个上面这样的指针构成的数组：
pf_taking_pfv p[10];
与void (*p[10]) (void (*)())达到同样效果。但这样是不是更具有可读性 Du&v&@Q Q
了！ 3i#~7O&u[ ? sY
+Kr&\6CA'f-t E
要点6：指向成员的指针 SA HA)A&? J+p
z)? j$klYQ
一个类有两种基本的成员：函数成员和数据成员。同样的，指向成员的指针也 :~?/vf+@O%L(R3y(ze
有两种：指向函数成员的指针和指向数据成员的指针。后则其实并不常用，因为类 2S B$HHw^
一般是不含有公共数据成员的，仅当用在继承用C写的代码时协调结构（struct)和
类(class)时才会用到。
指向成员的指针是C++语法中最难以理解的构造之一，但是这也是一个C++最强 |VJ? fv8QW"DbB
大的特性。它可以让你调用一个类的函数成员而不必知道这个函数的名字。这一个
非常敏捷的调用工具。同样的，你也可以通过使用指向数据成员的指针来检查并改
变这个数据而不必知道它的成员名字。
指向数据成员的指针
尽管刚开始时，指向成员的指针的语法会使你有一点点的迷惑，但你不久会发
现它其实同普通的指针差不多，只不过是*号的前面多了::符号和类的名字，例： ,d` pA+]
定义一个指向int型的指针：
:sH {E-f,P+Zr(~E
int * pi;
定义一个指向为int型的类的数据成员：
int A::*pmi; //pmi是指向类A的一个int型的成员 i-@0X5B B6Y:kZ/T6d
你可以这样初始化它：
class A c4IY+q{'Z L
{
public:
int num; l dJs$`/M y Z?#j
int x; 9J%[ n4U&V~@ {
};
int A::*pmi = & A::num;
上面的代码是声明一个指向类A的一个int型的num成员并将它初始化为这个num
成员的地址.通过在pmi前面加上*你就可以使用和更改类A的num成员的值：
A a1, a2;
int n=a1.*pmi; //把a1.num赋值给n &e2p Fx-GQ X+s%~@4s-]
a1.*pmi=5; // 把5赋值给a1.num p+\2Ll,Z'T
a2.*pmi=6; // 把6赋值给6a2.num %p`6] X Hz
如果你定义了一个指向类A的指针，那么上面的操作你必须用 ->*操作符代 \&O#_ A&N9J
替：
A * pa=new A;
int n=pa->*pmi;
pa->*pmi=5;
x$[XA)i8x+YE
指向函数成员的指针 &G `8]&V Q;@;B
它由函数成员所返回的数据类型构成，类名后跟上::符号、指针名和函数的参 A4Y,sxTZ T"E4o
数列表。举个例子：一个指向类A的函数成员（该函数返回int类型）的指针： }@e [Qf"W6e
jq l4P Z9c,Lm I T
class A -]4C$^} l I/M
{
public: /Q?[;Kz
int func (); 'O!{C:oJG?I
}; R;u3R4\;d{
int (A::*pmf) (); XHR4F)}?
T? a0x[ vzN.l#{ Z
上面的定义也就是说pmf是一个指向类A的函数成员func()的指针.实际上，这 H&B,iZLU.jz9Sk
个指针和一个普通的指向函数的指针没什么不同，只是它包含了类的名字和::符 P:J%v_^b_pt
号。你可以在在任何使用*pmf的地方调用这个函数 C `pKD
func()：
pmf=&A::func; &N E3z2d x dy6L
A a;
(a.*pmf)(); //调用a.func()
如果你先定义了一个指向对象的指针，那么上面的操作要用->*代替： jWK:Tp2dBZ@
A *pa=&a; #o"^*Uf:\O(l
(pa->*pmf)(); //调用pa->func()
指向函数成员的指针要考虑多态性。所以，当你通过指针调用一个虚函数成员 {9S#L] aA
时，这个调用将会被动态回收。另一个需要注意的地方，你不能取一个类的构造函
数和析构函数的地址。
c@H Qzy\?8e*ZU!n
要点7、避免产生内存碎片 nwc[6] {,h
H3F H&Q By+cl V
(pac"a MP*n
经常会有这样的情况：你的应用程序每运行一次时就因为程序自身缺陷而产生
内存漏洞而泄漏内存，而你又在周期性地重复着你的程序，结果可想而知,它也会
使系统崩溃。但怎样做才能预防呢？首先，尽量少使用动态内存。在大多数情况
下，你可能使用静态或自动存储或者是STL容器。第二，尽量分配大块的内存而不 ;js"^5[1~m
是一次只分配少量内存。举个例子：一次分配一个数组实例所需的内存，而不是一
次只分配一个数组元素的内存。 0C o"}-P,O
J6Y n6\0_ur2D
要点8、是delete还是delete[] -B [k _:ve g!x4O8R
在程序员中有个荒诞的说法：使用delete来代替delete[]删除数组类型时是可 !h7f K!x2G R
以的！ ,R'B}8e9q ["dn
举个例子吧：
int *p=new int[10]; P? ?~D7ul
delete p; //错误，应该是：delete[] p u q lc R4A6Q
上面的程序是完全错误的。事实上，在一个平台上使用delete代替delete[]的 `(vvl U#I0O9I
应用程序也许不会造成系统崩溃，但那纯粹是运气。你不能保证你的应用程序是不 Y1b{ G _)k)\0W
是会在另一个编译器上编译，在另一个平台上运行，所以还是请使用delete[]。 !O5Pa+u5gL_
要点9、优化成员的排列 'h)v QZ8Q\$^
r[+PD7y!fae
一个类的大小可以被下面的方式改变： -[ q(U5Nt K`
8Z _^$U Jv
struct A .~C4r z eF
{ a O9CG3ccT.o
bool a;
int b;
bool c; [0t(Qu:yM9YFY
}; //sizeof (A) == 12 *^ J` ^x*\
j1P [ J:\9MQZ
在我的电脑上sizeof (A) 等于12。这个结果可能会让你吃惊，因为A的成员总 d;\2k,`2\Z%d6j f#K
数是6个字节：1+4+1个字节。那另6字节是哪儿来的？编译器在每个bool成员后面
都插入了3个填充字节以保证每个成员都是按4字节排列，以便分界。你可以减少A
的大小，通过以下方式： (MIm'q xL.[)p_
)Sr-w J.I y
struct B
{ &^/[r;O}
bool a; I [3a(D#S
bool c;
int b;
}; // sizeof (B) == 8 $dz D2uAT(c#V~
这一次，编译器只在成员c后插入了2个字节。因为b占了4个字节，所以就很自 6Sxi GnZ
然地把它当作一个字的形式排列，而a和c的大小1+1=2，再加上2个字节就刚好按两
个字的形式排列B。 d6s2vl;s$_
D\)S9~,U&g
要点10、为什么继承一个没有虚析构函数的类是危险的？
h*kX$q)B:?n-E~%j
一个没有虚析构函数的类意味着不能做为一个基类。如std::string,
std::complex, 和 std::vector 都是这样的。为什么继承一个没有虚析构函数的
类是危险的？当你公有继承创建一个从基类继承的相关类时，指向新类对象中的指 -z ~ x(Z%?4j%FV-K
针和引用实际上都指向了起源的对象。因为析构函数不是虚函数，所以当你delete K7j/n }BZ
一个这样的类时，C++就不会调用析构函数链。举个例子说明：
class A
{
public:
~A() // 不是虚函数
{
// ...
} v0yl!P/L5k
}; -L4I ~(p){Rt
class B: public A //错; A没有虚析构函数
{
public: 8n#L*ec.E Q2h
~B()
{ @/qR*Z mZH1vs
// ... /F,~'M*JW\~
}
}; :o'H nV#o8h2O/V
ReU br5d f
int main() o8P|(d+}/W'Y,CU,g0t@
{
A * p = new B; //看上去是对的
delete p; //错，B的析构函没有被调用 "P-v1ri&}~ ]-[
}
qf5B6^&b!O m E u |
K\C%G` N u
要点11、以友元类声明嵌套的类
当你以友元类声明一个嵌套的类时，把友元声明放在嵌套类声明的后面，而不
前面。
$y5nHK VM \)uZ9n
class A y$\d2CE eh&~ `a
{ Rg7K3C,B O5t)O.M8e l
private:
int i; sVg}(vUq)C8|`l
public:
class B //嵌套类声明在前
{
public: .]N `:r-~#Q&u~5cS T
B(A & a) { a.i=0;};
}; N LaW4@&U6v
friend class B;//友元类声明
}; 7y r!`EO9w(eZw0W%T[8vO
%q&C` _+M~2T/Nx L
如果你把友元类声明放在声明嵌套类的前面，编译器将抛弃友元类后的其它声 W!u#B*r+p/eH*ct
明。
[/code] 言简意亥。g(\C-C#PW
好文！ 不会吧,斑竹竟然是个小妹妹,!!!看来要好好学了,呵呵,谢谢这文章了 :)
写的好,pf#ObB Pn8a*G p1P`@%NE
以前自认为自己C++很强,现在看来还有很多东西要学习! S!_ @6R U)B1b:e
:cool: 请问 "要点6：指向成员的指针"中
S?k*kU'GH
指向函数成员的指针要考虑多态性。所以，当你通过指针调用一个虚函数成员时，这个调用将会被动态回收。另一个需要注意的地方，你不能取一个类的构造函数和析构函数的地址。
这个"这个调用将会被动态回收"是什么意思? 该函数指针有动态功能吗?
谢谢?
多谢斑竹
好文，C++的东西博大精深，非一朝一夕能吃透的。我们一起努力吧，为LINUX阵营添砖加瓦。谢谢
好文章，H5vW5x(jY%o|._|9^ n最近正在学习C++，l6} T#sc#H
有了这遍文章，
相信还是能少走些弯路。。。。。 哎，不认菜都不行……，以后我跟定你啦，斑竹！ 好啊，虽然我还不会c++,可我会努力，不一定要向斑竹看齐 好啊！ 好东西！
谢谢了！
还不错
第6条和第11条还有些新意，其它的都是老生常谈了。不过C++的陷阱太多，不得不时时提防。喜欢C++的，加我呀，大家多多交流。
QQ:365095569 为何只能看到要点2 太经典了，这些经验是书本上不可能学到的！非常感谢！ [I]5年前我们就开始反对把.h符号继续用在标准的头 1zN!|8a!`$a!H B
文件中。继续使用过时的规则可不是个好的方法。[/I]
我不是很明白呀？？我看现在的那些c++程序，还是用.h的库文件呀 :eek: good good study. day day up “5年前”指的是98年第一个ISO/C++标准出世，从此C和C++划清界限。 文章不错啊 请多多的写一些最新的c++变化 ，我代表c++爱好者感激你
页:
[1]