C++学习要点1. 传指针时，我们可以通过指针来修改它在外部所指向的内容。但如果要修改外部指针所指向的对象是不可能的。例如传递外部指针到函数内来分配空间，必须传递指针的指针或指针的引用。
7j0t u/z4p c
?'a|U
d1P({$n8t VS p O8Hl
2. char carry[10] = {0}; 编译器会将其后所有的东西都置0；
a3^6FhE
7{o3z)e-VD
3. 函数返回值为const时，返回的东西付给一个类型相同的标示后其不能为左值；
b1Q5y W9Q:ny7~Y
zy
l}4OY,j(y+a
4. const int *i; int const *i; int * const i; 前两个功能相同，说明I所指向的内容不变；最后一个说明指针指向的地址不变，但内容可变。
V+Cy;L9}q
)J[ J8qE3Jq
ZgKD:^
5. 类中的const成员函数。定义为在原型后加const。常量函数不能修改类中的任何属性。但有两种方法可以修改。
Yc Lbg2z
+jt5Ot.J n[g#v
a) {（myclass *）this->member1 = values;}
V } {+`-K
0CM^X,eh A c
b) 将一个成员定义成mutable即可被常量函数修改。
/Hd
c*bL ]*?F;o6d M/AY,w
]N#xim@
6. 类中的常量const 类型的，不能在类中被用来定义数组。而enum {ONE=100; TWO=2};定义的ONE、TWO却可以。通常的enum定义的置分配问题：enum A{ L=9, Z};此时Z的值为10。
4v5|
qd,J)i0G
FH Bk7l(^
7. 用const定义的int可用来开辟数组，但const定义的常量数组中的元素，不能用来定义数组。
"h`.i)|8uBb
d+L/`X:Pb){f
8. 用sizeof计算变量的空间，如果是数组，按实际空间返回；常量字符串（实际上是在静态内存区开辟的变量）sizeof返回比实际长度加一。如果是指针则不考虑它指向的空间大小，仅仅返回指针类型的大小。如果用sizeof计算函数的行参，即使是属组也仅仅返回一个相关类型指针的大小。
6VmD)\,RT
$f%iap6Z9r s%T/k
9. 形如int iarray[] = {12, 124, 433};编译器会自动给iarray分配3个元素的长度。元素长度的个数计算公式为sizeof(iarray) / sizeof(*iarray)。
| t6i @;G:td+N7~S
9l4A VED1V
10. 拷贝构造函数：当行参和实参结合时，如果是复杂对象的传值类型，则调用拷贝构造函数生成一个临时对象作为实参，退出函数时，临时对象被调用析构函数释放。当返回值是复杂对象是，也是调用拷贝构造函数来赋值。这就出现构造函数和析构函数被调用次数不相等的情况。拷贝构造函数的原型为A(A&)，我们可在类中重载。（缺省的拷贝构造函数是使用位（bit）拷贝方法：浅层拷贝，不拷贝指针指向的内容）。
X0g\:ad
.KzK/a4h9l
11. volatile类型的变量告诉编译器，本变量不需要进行代码优化。在多线程的应用中，我们如果读入一个变量到寄存器，此时时间片到期，去处理其他线程了，在重新获得处理机时，volatile类型告诉处理机，重新从变量读取数据到寄存器，而不是用寄存器数据直接处理，这样可以防止脏数据。
l4MA6q9[!y jYlm
$~E\MJ+c\^$mh
12. class 和struct在一定程度上有相同的功能，只不过前者缺省的成员是私有的，后者在缺省时成员为共有的。故而class不是c++必需的保留字
`*^l8\{;](^5Hs
n{)[ |
dq(\+h
{$[
13. c和c++编译器，对相同的函数名编译后生成的相同的标示不同，故而在引用c的库文件时必须使用extern “C”告诉编译器，它是c的函数，按c的规则编译。通常我们使用的标准头文件已被处理过。
r*^#? g-Q F Bo
4y%M;f\e8EY
14. #include “filename”； #include <filename>，前者先在当前目录下寻找文件，如果找不到再到系统规定的路径下找，后者直接到系统规定的路径下找。
-Wj Lh%z$E:oV
!i | V
\_
15. 任何地方分配的静态变量（static）,其生命周期和主进程相同。第二次定义一个已存在的static变量，对变量的内用无影响，但它的可见范围只在定义的范围内。（考研曾作错！）(从静态变量的特性不难理解，类中的static类型是所有对象共享的)
GZ.rp ou V
0~ \0V'y xs!o
16. 内联函数（inline）在实现上实际和宏类似，在内联函数出现的地方将函数展开来避免函数调用时的出栈、如栈，提高效率。但内联函数的代价是：代码增大。inline函数适合成员函数和自由函数。在类中实现的函数自动为内联函数。inline必须定义到函数的实现上，例如：inline int PlusOne(int) 是无效的。友元函数在类的体内被实现自动变为内联函数。
D&o$AI"S`G
i%c(o)MR6S
17. #include <iostream.h>
U@-Nl0w tr&Q0w;}
/J u t+bV7{6i
#define DEBUG(X) cout<<#X"="<<X<<endl
!g E;g { _!iG-Y u
o4R-e
T hzI|5I
其中的#X表示X被当作字符串输出。
;C/z,Y
g1F'A'| VUc
@9y+g3f-a
18. assert(0 != 0); 如果assert中的条件为假，则运行期间回退出程序，且报告出错代码的行号。（#include <assert.h>）
*MS1IM-D6QO
@F.PdAx!} R!L&` Y
19. 静态对象在main结束或exit()被调用时才调用自身的析构函数。这意味着，在对象的析构函数中调用exit()是很危险的，有可能进入一个死循环中。调用abort()来退出函数，静态对象的析构函数并不会被调用。我们可以用atexit()来指定跳出main或调用exit时要执行的操作，用atexit注册的函数，可以在所有对象的析构函数之前调用。
,HT b
M/`9Or#s
$G c%fd cO5i
void exit_fn2(void)
v&DX O%~
@
i^7P.k3O2t;I@'`
{
pz/A6GjJ
k9x
g;{'r9K2B(SP
printf("Exit function #2 called\n");
q;o
B%u ]$d3W
/aO yL n
g
} //处理函数
+yjYy1e$@B p
9ng
Qc+g7z.x
atexit(exit_fn2);
3f,V(oG!?'D
6y J
^$p9t5z;wm*L
20. 全局变量实际上用的是静态存储。静态变量的构造是在进入main之前调用的，在main结束时调用它的析构函数。变量的名字由小范围（c++而言）：
:B(Kkq6W0N/L:]]
"g2mw L m2Tl@y3~
//*.cpp
\3y3N:H K's
t])wivY+k9D
int a; //静态变量,但为 extern int a; 即它是全局的，外部可见的
m4n+Gmz
1yt8SG6o
u+@m#bK F
static int b; //静态变量,static 和extern相反，只在*.cpp中有效，对其他单元（文件）是不可见的。函数的定义和上面相同。
1E(L(Q]
kR P
s,e^HG \$xlR
main()
m5k
A xG d
t9ou
1`{ w(M&Qd:}XJ2l;N
{ }
2oDi'L6b+M'\;],jR
xu/` H8C.|;O;{
类的静态成员变量可以如下赋值：int X::s=23;（在*.cpp中，无论公私都可以）
,OJ&T9d@y}!h M
g1X7~p |%X
21. 名字空间(namespace): 定义一个名字空间，然后使用unsing就可以将当前的类型上下文转换名字空间所定地的.
dc4L gPb w
i-HKIai&HI1gV
namespace math
-u
s K&r,k_
V^.~iPf
{
?.d;ze#cf"F[ZB,\c
8zy
vcS K+t
enum sign{positive, negative};
$u*F N#j o
{ r0Ah klQ j"l
uXm!n
class integer{
5r N#|;C1Y8_
F-y-h W$~
8K&b7Y5A(z;Jj?8A9r^
int i；
3[sc jdpdU
q _,{%@&QB
sign s;
MP Dh2u
*iT Ux*L#B
public:
3l b8P4S b)Z7R4E
1]+W] ]"B
interger(int I=0): i(i) {………}
-H` ZA*m-A~
"viE8r"G#o d)b+t-MkL
sign Sign() {………}
,xVJ5k:R F'R.D y"fe
4{'}$v\z1SG
h
…………………..
{N?c K
b
z/gL7^3[
};//end class
V6J%t I S6li2cs|1j
"r]8w;[{%`4L U
interger A, B, C;
b
c[3FR"nU$v1a
iK%p uUa {
interger divide(interger, interger);
Z ] K6b
Z!e o$u H b
"@.]"Go9P?5H0Ek9h']
}//no ;
wdgkDH+E7N
@ l)J+pw_$x,R
M1` BB-P)xa
0WLX%nCg1g'r
void q()
PV%A4Q H4?7j U ]
H zXaZ-O
{
Y!f&Ak;_
s3QE-i
)N&Ank;Z$L"D+R ^
using namespace math;
_D?haE
WX/hB'K0k ul
interger A; //hides math::A
$e N
P"v-C*d
H'[O5fN2E*T
A.Sign(negative);
(HyJD
A/D
W R~Nu0]
Math::A.Sign(positive);
gR6s MH$g9E9t
R~/vj
j
z
}
Kd3\ [B}FF1{)c;oV
,MH#SIh-A
i+E/F
22. 一般对于函数flaot f(int a, int b); 某些c++编译器编译后生成_f_int_int的名字，有些c编译器则生成_f的名字。故在c++中链接c的库函数时要用extern “C”告诉编译器，按c的规则来编译函数。类似的还有extern “C”{#include “myhead.h”},c++还支持extern “C++”{}.
0am/};^ni
KY*m9F xP
G
23. 在函数调用时，传引用也是将指针压栈。
VT3m2\,G}5k
]z'_/}'_]5K0v+x
24. 构造函数、析构函数、赋值构造函数、重载的=，四者的调用顺序：(三种函数都已实现)
s }h8_
P b(z
)}2k
F
d z
a) X x; X a=x;
i/sb6m:A5Q
_
A#h
p[
result:
K"nw A]hk CD;r
"Z{Y1\(mP?#EO
X:construct
0@l(q4}/LX6C*g.r%}
/L2IN
VG OGJ
X:copy_struct
:` qhmb-n
y)U
,`5]8r @ oC$y5r1@P
b) X x; X a; a=x;
N&u J Vt%[ Q;bD2l
+]!j M n0X d;N9e~&G
Result:
|9N7b G e,N4l U'V w
;m r]r:}W5[y'D}
X:construct
-ux k0BD#[zQ%x
-I&S/Ht8pn
X:construct
X8bm'G&V-m,o/f p
~){G/v/v d
X:copy_stru
u)t9W
x/s6K] l1v5F3h
)g Jq+j$j,i w:B
operator =
6RM~D C7fE?b
SqA"m6QfJ m
X:destruct
@ITX H-Yw ZzjT
YP%x(G@T#T t2|
{
如果没有赋值构造函数则结果：
5F?Y U/_}$Wh
"K#i.k#e @/o
q+H[G
X:construct
?`KD,[ \ q1bk
.c m:^3N!O_
X:construct
)U }
X B7}M _V
s*O#X6N#f1NxB
operator =
,o1BpC s:MNL Y
w&o)O z%\$hJ
X:destruct
2r{+Jk9`0pC
H/MkY H
（如果直接X a=x;这不掉用一般的构造函数，调用复制构造函数）
Y4N}
KB E ?
,T9qNyR)X0wP]}]
指向类的成员函数的指针：设 int X:: a(void){}
%S$T^a0C g9?j0V
9d P @*^+b'X`Ep _
X x;
TDe"G9Ech
?4}'byr/X1~u
int (X:: *pf)(void)= &X::a;
D T y e~S%]
AM Uu*s].W G m#w I
(x.*pf)();
"\Jt+v P%C6L
5R M E3d!NN\
指向成员变量的指针： 设int i; 是X的成员变量
g)J1@:mH.b
D;F7s%U l*NdE.ch
int X::*pm = &X::i;
i
B\`:O"}e|%K Z|.L
$qST``
_9B0s d.}
X x;
K7AC#qkj!x d1Tv
4~C!TB*H5K6~
x.*pm=12;
']}-[ m#n |!U
hz MVw8e$t^&|
X *p=&x;
A7S6Pu(Lg9V'H
4Qc/[@&R"t&d&Z
p->*pm=11;
p+X y X&k }!x
y2`f!v K/\+U![]k
25. ++的操作符重载
7k0g:WP+eb
*zH,[Cp F2p
const X& operator++() //++b; const X operator++(int ) //b++
)fbe.zN PS xy9`
-i3d@ TW y
其中的第二个参数为哑元，永远也不使用到。
5^%oG#L`2pQ4a/K
W
K&Y2Pl;J x%B
26．自动类型转换
\7loBJry{5u
9d)y0N&J3@c*d
a.) class one{ b} class two{
&T(@ P7R$oNj*k}
C"|
tE|$o:CihGW g
public: one(){} public: two(const one &){}
+\IR2O&jA4w'of
b
O3X_RQ g2oU S8bC {
}; };
nW/p
] }
*aPVb!`t
void f(two) {}
#W|dCC!x
L!T V5t2X/i;t)f X
main(){ one ONE; f(ONE); }
`2P \bNz Z FnU
)uh
?5f3_"wX
此时会调用two中的一个构造函数进行类型的自动转换。但效率不高。可以阻止隐含的类型转换。方法如下：将类two给为
z W'?(h:B\;k9yL%K
lu HY.`s0@u+}
class two{ public: explicit two(const one &){} };
N+I&ua,_9t
"R6KRC/\B2~b"j A~
explicit只对构造函数起作用。此时必须这样调用函数：f(two(ONE));
UG*W2`%f Weo b
^T4E m)c
q l"{
27． 一个理想的string类，它知道如何从string转换到char *:
Jr%Z Z n
?n.uCU0B9q
class string
ujCy,]:Yc
n"U gd*BH
{
!k%@!z VL
,}I;t#^+W a \.s
private: char *s;
+S x6D g_r9e;aR"r
Q#Z W gZF:W
public:
iQMql
~5{bD f X,Ir
string(const char *S="")
-w'fM f`4`
qx2R:|;j8^2q
{
8b!t |8vx8w
!?$Q | \'}4G2CM3[
s=new char[strlen(S)+1];
2L `JFd
B I
q(IW lq6i
strcpy(s, S);
7W mX n_x2W{&|#d
S:md{$G
v Oj&qX
}
v:T2L&{XT.mT
0r;OT z S3e
~string(){delete s;}
,\5e&hBtWu&N S+m
c3ef2\K i
operator const char *() const {return s;}
.^8F hK [3U2Mk
%{ B5I7hP
};
V;d0iY Xf
*k|0rH!^ an
v x[
int main(void)
0yn*n*X#Uk\
3P{,k]!^"u {+? A
{
Q`1W2W:F v#Y
yf:T!R*V:G v6Y
string str1("lizhihui2");
V5g]4DCU
V%n,Nz k%fl
string str2("lizhihui2");
i3Q$BqUB`G!{M
.m"So;H)}.B(M5Y)a~-I;\Q C
strcmp(str1, str2);
A+ailnQ_@ u
a&N8a
PU%O
}
i pd q2u%h ~*`/T
OtnqL(H-Z4{
28． 如果从一种类型到另一钟类型有多种转换方法，则会出错：
_3E(A7U y a
R.dGL+f3[!Cl
classs Y;
[hr"t)y9l`yb
A5D*wUl'dl
class X
1X~G }]
'k` p"P4F
{
Xs$z"`$A7c G
8z+B3T }*Q @`4r1N
public: operator Y() const； //convert X to Y
{ls%DO NrB
M_S
^_Z
};
%L*d8}@7u^0q
d(p@W j8y
class Y{
{*J(M,D] [8v
WAm?Z W*Pf%T8I
public: Y(X) ;//convert X to Y
,]ph5@{
"y@1ju%F2B&T G-T
};
cWd.a#BjH
9^ ]%L,y
~&O!m C?qV]
void f(Y);
_Z9O'S9O m BNO$c
A%A4M#A1n5C
main()
\ H$f
P2OI!L4xE
g*Yk
a'QK-[ j3P
{
GJ l4R1?#d{
2] ? O+N
j k9Kx5z
X x;
'oa\ ])cS1AO
1\6UV x+c
~U%_
f(x); //error: ambiguous conversion
9F.a:t6H"ahwc5E S
|a)v)k!Ja'M(b*?
}
2Z!V Q.e/l@9kz6P7p
hx
[DD c
29．删除数组对象：
F@c$S|&[5UP
rA
W;^0@'ql,^pp
foo *fp = new foo[100]; delete []fp; 或 delete [100]fp;
o"X;M^.o*{
R~
h?&B U
使指针更像数组：int *const q=new int[10];这样q不能移动则更像数组。
\cg#a-C
'pU,J-{a7\m3?/\7^Y
30．new堆内存用完时的异常处理器函数
P!dB;^G3J
B ^Q1I"} ^N
:g1C K.c-Z&p
void out_of_memory() {printf(“out of memory!\n”); exit(1);}
` ^ Gy%Y k g+^
*jA@l E&w&t R*_.F }
main() { set_new_handler(out_of_memory); …………….}
Hh(T%v'X{fy
+p5N(c4` `K&m+e%R
31．new和delete的一种全局重载方法
l2t:D+FZ-y
$C}jjeKp$T:i
void * operator new(size_t sz)
`p"| Gc
6^ ` Z o k D!b
}
{
dS#g#p!]H9\'fq O6_x:G
7b eE-TD
printf("operator new :%d bytes\n",sz);
+u_K4b'Q(l-S
/F ]*m |OF
void *m=malloc(sz);
;P n?k]q w K a&G
m.LVr#ZD1h9]g
if(!m) puts("out of memory\n");
#T'|;R%W%tC%b6@ \
"]#j}V ODQ
return m;
5M8NT0|!A.Q'qR _
&x
xl*~}-MxC
hY
}
SgqV;y!|
%z3[dg0x5b8nI z
void operator delete(void *m)
GA#BT8VQj
uw)qb.f`#VwU-Z
{
7{*e9S/l$NBU'Mz
'B,B vlo
puts("operator delete.\n");
C X n#bF1@~
3X"d6j4tX1R d
free(m);
k!o"Xo*C:r[$?6NY
of?7rCnJ5M
}
M1]2h
zOw)v
6\3}'{ |)^T9r
class s
NO
Emq:})`+s
I$D h x1CU.N
{
"t^ ry4nJ
lk
(x4rnZA;N
int i[100];
b#Fp.C/{^Kb O
(|"? P&M;hW
public:
v+d%u t7|!R k(E
l:U;do#oek
@ A4d
s(){puts("s::S()");}
J:Y-n,Fw"Yq|Q
#X*oVMPgE q qT)E
~s(){puts("s::~S()");}
)l_ u6A)j/y,NC
;H3~,X qU8O+X%[Q6~ ~Kf
};
i djl U"H
` jmf0i*y4y
int main(int argc, char* argv[])
{(yCn3m'F0T
^o8{9l-x EP.}
{
5F3l
~h7z(Q l
u t ] ]|]
int *p=new int(23); //operator new :4 bytes
j5L F,v F1c-A T#_
elZla l|@
delete p; //operator delete.
$P
v$Ef7n^0i(P+~
o A'W}G
*Y tF'P V)cY
r7o s+r}x? |g
s *pp=new s; //operator new :400 bytes
0D-`U wS
@V3p
2dk%t ~9O/a L+bJ&x
delete pp; //operator delete.
;{;Wt o.gIy
S Xh-Z
@9g
+|5QN&r5IOm!u h l,L
g3? u9P I~ _6b+h
s*pa=new s[3]; //operator new :1208 bytes, more 8 bytes for array info
)@ nNz*r |}[ Q
J V b9ux5Td
delete []pa; // operator delete. (C++Bilder unsupport)
&k5P7yH.^[!~
9Y"[^B2TBT$`a
return 0;
m nuC3K
Ck1lT
H-E*R
F#_n
}
$r z gz!xaT
'M | od GVtP(Y
缺省的系统new和delete是调用malloc和free来工作的，系统要维护一张内存分配表。分配出去的内存要记住它的大小和起始地址，释放时根据起使地址释放。