无码乱码观看精品久久,粉嫩小泬无遮挡久久久久久,亚洲综合精品香蕉久久网97

<�?gt;dll详细介绍

宝杉 — Tue, 04 Sep 2007 02:46:00 GMT

摘要: · �?.. 阅读全文

宝杉 2007-09-04 10:46 发表评论

8-28模板

宝杉 — Thu, 30 Aug 2007 02:47:00 GMT

模板是重用机制的一�U�工��P��可以实现�c�d��参数化，��x��c�d��定义为参敎ͼ�实现代码可重用性�?/span>

F�Q�宏定义也可以实现重用，��Z��么不使用宏？

Q�Q�宏避开C++�c�d��查机�Ӟ��两个不同�c�d��参数之间的比较将会导致错误�?/span>

模板�Q�模板函敎ͼ�模板�c�d��对象之间的关�p�R�?/span>

模板

�Q�函数模板和�c�L��板）

模板函数

模板�c?/span>

对象

��头代表实例�?/span>

模板

�Q�函数模板和�c�L��板）

模板函数

模板�c?/span>

对象

例如�Q?/span>

C++exams\template_max

模板形参��?/span>T实例化的参数�?/span>

函数模板是一个不完全的函敎ͼ�首先需要将模板形参T实例化�ؓ��定的类型。这个类型可以是预定义的�Q�也可以是用戯��定义�?/span>

模板函数的异�?/span>

1 先调用顺序遵循什么约定？

�Q?/span>1�Q�寻扄��型完全匹配的函数�?/span>

�Q?/span>2�Q�寻扑և�数模板，实例化后�Q��生匹配的模板函数�?/span>

�Q?/span>3�Q�若�Q?/span>1�Q�（2�Q�失败，��试低一�U�的对函数重载的�Ҏ��。例如，通过�c�d��转换�?/span>

�Q?/span>4�Q�（1�Q�（2�Q�（3�Q�都为匹配，则是一个错误�?/span>

2 先了解了�q�样的约定，��很�Ҏ��理解以下�Q?/span>

用非模板函数重蝲函数模板�Q�只声明非模板类函数的原型，不给出函��C��Q�而函��C��借用函数模板的函��C��?/span>

例如�Q?/span>

template

T max( T x, T y)

{

return( x > y )? x : y;

}

int max( int, int);

//int max 重蝲了函数模板的函数体；

int i;

char c;

max�Q?/span>i, c�Q?/span>;

3 定义一个完整的有函��C��的非模板函数�?/span>

比如�Q?/span>max(char, char)�Ӟ��上面的函数模板不能比较比一个字�W�更长的字符串了�?/span>

所以，像一般的重蝲函数一样定义�?/span>

char *max( char *x, char *y )

{

return ( strcmp(x, y) > 0 ) ? x �Q?/span>y�Q?/span>

}

char * max重蝲了函数模板，当调用�ؓ�Q?/span>

max ( “abcd”, “efgh” ); ��执行此函数�?/span>

宝杉 2007-08-30 10:47 发表评论

08-22

宝杉 — Thu, 30 Aug 2007 02:33:00 GMT

如果不想让别��Z��用编译器�~�写构造拷贝和赋值函敎ͼ�可以声明为私有：

class A

{ …

private:

A(const A &a); // �U�有的拷贝构造函�?span lang=EN-US>

A & operate =(const A &a); // �U�有的赋值函�?span lang=EN-US>

};

如果有�h试图�~�写如下�E�序�Q?/span>

A b(a); // 调用了私有的拯��构造函�?span lang=EN-US>

b = a; // 调用了私有的赋值函�?span lang=EN-US>

�~�译器将指出错误�Q�因为外界不可以操作A的私有函数�?/span>

但是怎样才能使用构造拷贝和赋值函数呢�Q?/span>

虚拟函数使用�Q?/span>C++exams\destructor

在编写派生类的赋值函数时�Q�注意不要忘记对基类的数据成员重新赋倹{��例如：

C++exams\base_operator

宝杉 2007-08-30 10:33 发表评论

宝杉 — Thu, 30 Aug 2007 02:31:00 GMT

摘要: 定义�Q? class String { public: String(const char *str = NULL); ... 阅读全文

宝杉 2007-08-30 10:31 发表评论

08-13复习

宝杉 — Thu, 30 Aug 2007 02:28:00 GMT

析构函数

构造函数初始化表：构造函数特�D�的初始化方�?#8220;初始化表辑ּ��?#8221;�Q�简�U�初始化表）�?/p>

初始化表位于函数参数表之后，却在函数�?{} 之前。这说明该表里的初始化工作发生在函数体内的�Q何代码被执行之前�?/p>

规则

u 如果�c�d��在��承关�p�，�z��c�d��d��其初始化表里调用基类的构造函数�?/p>

u �cȝ��const帔R��只能在初始化表里被初始化�Q�因为它不能在函��C��内用赋值的方式来初始化�?/p>

u �cȝ��数据成员的初始化可以采用初始化表或函��C��内赋��g��U�方式，�q�两�U�方式的效率不完全相同�?/p>

效率

1 内部成员�Q?/p>

初始化表和函��C��内赋值都可以�Q�但效率不完全相同，但后者更为清晰直观�?/p>

例子�Q?/p>

class F

{

public:

F(int x, int y); // 构造函�?/p>

private:

int m_x, m_y;

int m_i, m_j;

}

F::F(int x, int y)

: m_x(x), m_y(y)

{

m_i = 0;

m_j = 0;

}

F::F(int x, int y)

{

m_x = x;

m_y = y;

m_i = 0;

m_j = 0;

}

�C�Z��9-2(c) 数据成员在初始化表中被初始化 �C�Z��9-2(d) 数据成员在函��C��内被初始�?/p>

两种方式效率区别不大�?/p>

2 非内部成员：

只能用初始化表，提高效率�?/p>

例子�Q?/p>

class A

{…

A(void); // 无参数构造函�?/p>

A(const A &other); // 拯��构造函�?/p>

A & operate =( const A &other); // 赋值函�?/p>

}�Q?/p>

class B

{

public:

B(const A &a); // B的构造函�?/p>

private:

A m_a; // 成员对象

};

比较与分析：

B::B(const A &a)

: m_a(a)

{

…

}

B::B(const A &a)

{

m_a = a;

…

}

1 B�c�L��造函数的初始化里�Q�调用了A�cȝ��拯��构造函数�?/p>

2 B�c�L��造初始化里，隐藏了以下几个步骤：

先创��Z��a对象�Q�调用了A�cȝ��无参数构造函敎ͼ�

把a赋值给m_a�Q�调用了A�cȝ��赋值函敎ͼ�

深入探讨�Q?/p>

构造和析构的次序？

构造从最深处的基�c�d��始的�Q�先一层层调用基类的构造函敎ͼ�然后调用成员对象的构造函数�?/p>

而析构函��C��格按照构造函数相反的�ơ序执行�Q�该�ơ序唯一�Q�以便让�~�译器自动执行析构函数�?/p>

特别之处是，成员对象初始化次序不受构造函数初始化表次序媄响，由在�c�M��声明的次序决定。而类声明是唯一的，构造函数却可能有多个，所以有多个不同�ơ序函数初始化表。如果按照构造函数的�ơ序构造，那么解析函数不能得到唯一的逆序�?/p>

宝杉 2007-08-30 10:28 发表评论

08-10 内联函数

宝杉 — Mon, 13 Aug 2007 02:24:00 GMT

内联函数�Q�既增加安全性，又可以调用类的数据成员�?/span>

�?/span>C++中，用内联取代所有宏�Q�但�?/span>Debug版本中，assert是例外�?/span>

assert不��生�Q何副作用�Q�调用函��C��引�v内存、代码的变动�Q�所�?/span>assert是宏�?/span>

内联格式�Q?/span>

void Foo(int x, int y);

inline void Foo(int x, int y) // inline与函数定义体攑֜�一�?span lang=EN-US>

{

…

}

用于实现的关键字�Q�而非用于声明的关键字�?/span>

在类中的规范格式�Q?/span>

class A

{

public:

void Foo(int x, int y)�Q?span lang=EN-US>

}

// 定义文�g

inline void A::Foo(int x, int y)

{

…

}

什么情况不适合使用内联�Q?/span>

1 内联函数代码较长�Q�导致内存消耗较高�?/span>

2 内联函数包括循环�Q�执行内联函��C��码比调用函数的开销大�?/span>

F�Q��ؓ什么构造和解析函数不��用内联？

Q�Q�因为析构函数可�?#8220;隐藏”一些行为，例如执行基类或成员对象的析构�q�程�?/span>

有时候编译器会自动取消一些不值得的内联，所以在声明时不�?/span>inline是合理的�?/span>

宝杉 2007-08-13 10:24 发表评论

宝杉 — Mon, 13 Aug 2007 02:21:00 GMT

�~�省�?/span>

提高�E�序易用性，避免每次调用函数参数都相同的情况�?/span>

�~�省值只能出现在函数声明中，不能在函数定义中�?/span>

两个原因�Q?/span>

一是函数的实现�Q�定义）本来��׃��参数是否有缺省值无养I��所以没有必要让�~�省值出现在函数的定义体中�?/span>

二是参数的缺省值可能会改动�Q�显然修改函数的声明比修改函数的定义要方�ѝ�?/span>

规则�Q�参��C��后向前缺�?/span>

正确的示例如下：

void Foo(int x, int y=0, int z=0);

错误的示例如下：

void Foo(int x=0, int y, int z=0);

但要避免二义�?/span>

C++exams\default_para

�q�算�W�重载及其规�?/span>

�q�算�W�即可定义�ؓ成员函数�Q�也可定义�ؓ全局函数�?/span>

规则如下�Q?/span>

�q�算�W?span lang=EN-US>	规则
所有的一元运��符	��重蝲为成员函�?span lang=EN-US>
= () [] ->	只能重蝲为成员函�?span lang=EN-US>
+= -= /= *= &= \|= ~= %= >>= <<=	��重蝲为成员函�?span lang=EN-US>
所有其它运��符	��重蝲为全局函数

不能重蝲的运��符

�Q?span lang=EN-US>1�Q�不能改�?span lang=EN-US>C++内部数据�c�d��Q�如int,float�{�）的运��符�?span lang=EN-US>

�Q?span lang=EN-US>2�Q�不能重�?span lang=EN-US>‘.’�Q�因�?span lang=EN-US>‘.’在类中对��M��成员都有意义�Q�已�l�成为标准用法�?span lang=EN-US>

�Q?span lang=EN-US>3�Q�不能重载目�?span lang=EN-US>C++�q�算�W�集合中没有的符��P��?span lang=EN-US>#,@,$�{�。原因有两点�Q�一是难以理解，二是难以��定优先�U��?span lang=EN-US>

�Q?span lang=EN-US>4�Q�对已经存在的运��符�q�行重蝲�Ӟ��不能改变优先�U�规则，否则��引��h؜乱�?span lang=EN-US>

函数内联

目的�Q�提高执行效率�?/span>

�?/span>

Q��Z��么要用？

A提高执行效率�?/span>

Q如何提高�Q?/span>

A宏代码本�w�不是函敎ͼ�但��用�v来象函数。预处理器用复制宏代码的方式代替函数调用�Q�省��M��参数压栈、生成汇�~�语�a��?/span>CALL调用、返回参数、执�?/span>return�{�过�E�，从而提高了速度�?/span>

Q�~�点�Q?/span>

使用宏代码最大的�~�点是容易出错，预处理器在复制宏代码时常��生意想不到的辚w��效应�?/span>

例如�Q?/span>

#define MAX(a, b) (a) > (b) ? (a) : (b)

语句

result = MAX(i, j) + 2 ;

��被预处理器解释�?span lang=EN-US>

result = (i) > (j) ? (i) : (j) + 2 ;

�׃��q�算�W?span lang=EN-US>‘+’比运��符‘:’的优先��高，所以上�q�语句�ƈ不等价于期望�?span lang=EN-US>

result = ( (i) > (j) ? (i) : (j) ) + 2 ;

如果把宏代码改写�?span lang=EN-US>

#define MAX(a, b) ( (a) > (b) ? (a) : (b) )

则可以解决由优先�U�引��L��错误。但是即使��用修改后的宏代码也不是万无一��q��Q�例如语�?span lang=EN-US style="BORDER-RIGHT: windowtext 1pt solid; PADDING-RIGHT: 0cm; BORDER-TOP: windowtext 1pt solid; PADDING-LEFT: 0cm; PADDING-BOTTOM: 0cm; BORDER-LEFT: windowtext 1pt solid; PADDING-TOP: 0cm; BORDER-BOTTOM: windowtext 1pt solid; mso-border-alt: solid windowtext .5pt">result = MAX(i++, j);

��被预处理器解释�?span lang=EN-US>

result = (i++) > (j) ? (i++) : (j);

对于C++ 而言�Q��用宏代码�q�有另一�U�缺点：无法操作�cȝ��U�有数据成员�?span lang=EN-US>

宝杉 2007-08-13 10:21 发表评论

08-08 隐藏

宝杉 — Mon, 13 Aug 2007 02:16:00 GMT

隐藏规则�Q?/span>

“隐藏”是指�z��cȝ��函数屏蔽了与其同名的基类函数�Q�规则如下：

�Q?span lang=EN-US>1�Q�如果派生类的函��C��基类的函数同名，但是参数不同。此�Ӟ��不论有无virtual关键字，基类的函数将被隐藏（注意别与重蝲��h��Q��?span lang=EN-US>

�Q?span lang=EN-US>2�Q�如果派生类的函��C��基类的函数同名，�q�且参数也相�?/u>�Q�但是基�c�d��数没�?span lang=EN-US>virtual关键字。此�Ӟ��基类的函数被隐藏�Q�注意别与覆盖�؜淆）�?span lang=EN-US>

回顾�Q?/span>

静态多态性：函数重蝲�Q�运��符重蝲�Q?/span>

动态多态性：�l�承�Q�虚函数�Q?/span>

上述例子之所以��用指针目的是�Q�表达一�U�动态性质�Q�即当指针指向不同对象可以调用不同方法。但事实上不能达到这��L��效果。虽然可以强制指针的�c�d��转换�Q�（derived *�Q?/span>p->g();�Q�，或者直接调用指向派生类的指针，但是只要��成员函数声明�ؓvirtual��p��起到�q�样的作用�?/span>

隐藏

不同指针指向同一地址�Q�那么指针的�c�d��军_��调用�Ҏ��Q�还是指针指向的对象�Q?/span>

例子�Q?/span>C++exams\hide

可以看出�Q?/span>virtual函数可以实现不同�c�d��的指针指向不同对象，调用不同的方法�?/span>

��是��_��当父�c�d��象和子类对象同时存在�Q�且调用父子对象的同名方法时�Q�只能用虚拟函数实现�?/span>

另外�Q�提供一�U�思�\�Q?/span>

如果基类与派生类的同名函数参��C��同，比如�Q?/span>

class Base

{

public:

void f(int x);

};

class Derived : public Base

{

public:

void f(char *str);

};

void Test(void)

{

Derived *pd = new Derived;

pd->f(10); // error

}

基类�?/span>int,�z��c�Mؓstring.如果惛_��z��c�M��调用基类的方法，卛_��z��c�M��d��基类�Ҏ��的调用�?/span>

class Derived : public Base

{

public:

void f(char *str);

void f(int x) { Base::f(x); }

};

但此做法�Ҏ��混�ؕ�Q�不宜��用。最好的�Ҏ��q�是�?/span>virtual�?/span>

指针�c�d��

对象�c�d��

面向对象动态的设计�Q�应该是对象�c�d��起到关键作用�Q�而不是指针类型�?/span>

宝杉 2007-08-13 10:16 发表评论

宝杉 — Mon, 13 Aug 2007 02:15:00 GMT

重蝲与覆�?/span>

成员函数被重载的特征�Q?span lang=EN-US>

�Q?span lang=EN-US>1�Q�相同的范围�Q�在同一个类中）�Q?span lang=EN-US>

�Q?span lang=EN-US>2�Q�函数名字相同；

�Q?span lang=EN-US>3�Q�参��C��同；

�Q?span lang=EN-US>4�Q?span lang=EN-US>virtual关键字可有可无�?span lang=EN-US>

覆盖是指�z��c�d��数覆盖基�c�d��敎ͼ�特征是：

�Q?span lang=EN-US>1�Q�不同的范围�Q�分别位于派生类与基�c�）�Q?span lang=EN-US>

�Q?span lang=EN-US>2�Q�函数名字相同；

�Q?span lang=EN-US>3�Q�参数相同；

�Q?span lang=EN-US>4�Q�基�c�d��数必��L��virtual关键字�?span lang=EN-US>

例子�Q?/span>C++exams\cover

指向基类的指针可以指向其共有�z��cȝ��对象�Q�但反之不行�Q�另外私有派生类也不行�?/span>

比如�Q��R 是基�c�，��汽车，马�R �{�是�z��c�R�?/span>

一个�R�cȝ��指针可以指向��M��z��c�，因�ؓ它们都属于�R�?/span>

而反之，不能说指向马车的指针可以指向车，因�ؓ车的概念最大�?/span>

宝杉 2007-08-13 10:15 发表评论

08-07 重蝲�Q�overloaded�Q�、内联（inline�Q�、const和virtual

宝杉 — Mon, 13 Aug 2007 02:14:00 GMT

重蝲�Q?/span>overloaded�Q�、内联（inline�Q��?/span>const�?/span>virtual

	重蝲	内联	const	virtual
全局函数	√	√
�cȝ��成员函数	√	√	√	√

内部标识�W?/span>

�~�译器根据参��Cؓ每个重蝲函数创徏内部标识�W�，以便区分忽略�q�回��g��有返回值的重蝲函数�?/span>

�q�接交换指定�W�号

C�~�译�q�的函数�Q�经�q�编译器标识后与C++的表�C�风��g��同。所�?/span>C++不能直接调用C�~�译出的函数�?/span>C++提供extern “C”

例如�Q?/span>

extern “C”

{

void foo(int x, int y);

… // 其它函数

}

或者写�?/span>

extern “C”

{

#include “myheader.h”

… // 其它C头文�?span lang=EN-US>

}

全局函数与成员函数同�?/span>

全局函数与成员函数同名不��重载，因�ؓ函数作用域不同�?/span>

��Z��区别�Q�调用全局函数�Ӟ��注意格式�Q?/span>

�Q�：函数名（参数�Q�；

隐式�c�d��转换��D��重蝲函数产生二义�?/span>

隐式�c�d��转换�Q�数字本�w�没有类型，把数字当作参敎ͼ�自动�q�行�c�d��转换�?span lang=EN-US>

例如�Q?span lang=EN-US>

void output( int x); // 函数声明

void output( float x); // 函数声明

output(0.5)��生编译错误，因�ؓ�~�译器不知道该将0.5转换�?span lang=EN-US>int�q�是float�c�d��的参数�?/span>

正确写法�Q?/span>

output(int(0.5)); // output int 0

output(float(0.5)); // output float 0.5

宝杉 2007-08-13 10:14 发表评论

08-06 free和delete

宝杉 — Mon, 13 Aug 2007 02:12:00 GMT

free�?/span>delete

只是把指针所指的内存�l�释放掉�Q�但�q�没有把指针本��n�q�掉�?/span>

注意�Q?/span>

�Q?/span>1�Q�指针消亡了�Q��ƈ不表�C�它所指的内存会被自动释放�?/span>

�Q?/span>2�Q�内存被释放了，�q�不表示指针会消亡或者成�?/span>NULL指针�?/span>

比较

malloc�?/span>free�Q�无法满��_��态对象的要求。对象在创徏同时�q�行构造，消亡同时析构�?/span>

malloc free是库函数�Q�不是运��符�Q�不受编译器控制�?/span>

new�?/span>delete�Q�不是库函数�Q�能动态内存分配和清理内存�?/span>

内存耗尽

内存耗尽�?/span>new�?/span>malloc�q�回NULL。但�?/span>WIN32下，使用虚拟内存�Q�不会耗尽的�?/span>

处理内存耗尽大概有两�U��?/span>

A *a = new A;

1 一处内存申�?/span>

if(a == NULL)

{

return;

}

2 如果有多处申请内存，�?span lang=EN-US>

if(a == NULL)

{

cout << “Memory Exhausted” << endl;

exit(1);

}

new�?/span>delete使用要点

1 new内置�?/span>sizeof、类型�{换和�c�d��安全��查功能�?/span>

2 new在创建非内部数据�c�d��的动态对象的同时完成了初始化工作�?/span>

3 对象有多个构造函敎ͼ�那么new的语句也可以有多�U��Ş式�?/span>

例如�Q?/span>diary files\obj.txt

4 如果�?span lang=EN-US>new创徏对象数组�Q�那么只能��用对象的无参数构造函数。例�?span lang=EN-US>

Obj *objects = new Obj[100]; // 创徏100个动态对�?span lang=EN-US>

不能写成

Obj *objects = new Obj[100](1);// 创徏100个动态对象的同时赋初�?span lang=EN-US>1

5在用delete释放对象数组�Ӟ��留意不要丢了�W�号‘[]’。例�?span lang=EN-US>

delete []objects; // 正确的用�?span lang=EN-US>

delete objects; // 错误的用�?span lang=EN-US>

后者相当于delete objects[0]�Q�漏掉了另外99个对象�?span lang=EN-US>

宝杉 2007-08-13 10:12 发表评论

宝杉 — Fri, 03 Aug 2007 05:08:00 GMT

数组要么在静态存储区被创建（如全局数组�Q�，要么在栈上被创徏。数�l�名对应着�Q�而不是指向）一块内存，其地址与容量在生命期内保持不变�Q�只有数�l�的内容可以改变�?/p>

指针可以随时指向��L��c�d��的内存块�Q�它的特征是“可变”�Q�所以我们常用指针来操作动态内存。指针远比数�l�灵�z�，但也更危险�?/p>

1 修改内容

char a[] = "hello";

a[0] = 'X';

cout << a << endl;

char *p = "world"; // 注意p指向帔R��字符�?/p>

p[0] = 'X'; // �~�译器不能发现该错误

cout << p << endl;

2 复制与比�?/p>

strcpy�Q�new type[strlen�Q�a�Q?1]�Q�，而不能用p = a //把a的地址�l�了p�Q�而不是a的内�?/p>

strcmp�Q�if strcmp�Q�a,p�Q?= 0�Q�，而不能用 if( a = p)

// 数组…

char a[] = "hello";

char b[10];

strcpy(b, a); // 不能�?nbsp; b = a;

if(strcmp(b, a) == 0) // 不能�?nbsp; if (b == a)

…

// 指针…

int len = strlen(a);

char *p = (char *)malloc(sizeof(char)*(len+1));

strcpy(p,a); // 不要�?p = a;

if(strcmp(p, a) == 0) // 不要�?if (p == a)

…

sizeof内存定w��计算

1 sizeof(p)相当于sizeof(char*)�Q�C++不支持对指针所指内容容量的计算�?/p>

char a[] = "hello world";

char *p = a;

cout<< sizeof(a) << endl; // 12字节

cout<< sizeof(p) << endl; // 4字节

2 数组作�ؓ函数参数�Q�退化成同类型指针�?/p>

void Func(char a[100])

{

cout<< sizeof(a) << endl; // 4字节而不�?00字节

}

指针参数传递内�?/p>

首先�Q�考虑函数为参数创��Z��时副本的问题。对于��g��递，有�Ş参和实参的区别。但对于引用和指针传递，则可能会产生问题�?/p>

指针作�ؓ函数参数�Q�不能动态申请内存�?/p>

void GetMemory(char *p, int num)

{

p = (char *)malloc(sizeof(char) * num);

}

void Test(void)

{

char *str = NULL;

GetMemory(str, 100); // str 仍然�?NULL

strcpy(str, "hello"); // �q�行错误

}

毛病出在函数GetMemory中。编译器��L��要�ؓ函数的每个参数制作��时副本，指针参数p的副本是 _p�Q�编译器�?_p = p。如果函��C��内的�E�序修改了_p的内容，��导致参数p的内容作相应的修攏V��这��是指针可以用作输出参数的原因。在本例中，_p甌��了新的内存，只是把_p所指的内存地址改变了，但是p丝毫未变。所以函数GetMemory�q�不能输��Z�Q何东�ѝ��事实上�Q�每执行一�ơGetMemory��׃��泄露一块内存，因�ؓ没有用free释放内存�?o:p>

如何�Ҏ��Q?o:p>

1 �?#8220;指向指针的指�?#8221;

void GetMemory2(char **p, int num) //**p

{

*p = (char *)malloc(sizeof(char) * num);

}

void Test2(void)

{

char *str = NULL;

GetMemory2(&str, 100); // 注意参数�?&str�Q�而不是str

strcpy(str, "hello");

cout<< str << endl;

free(str);

}

2 用函数返回值来传递动态内�?o:p>

char *GetMemory3(int num)

{

char *p = (char *)malloc(sizeof(char) * num);

return p;

}

void Test3(void)

{

char *str = NULL;

str = GetMemory3(100);

strcpy(str, "hello");

cout<< str << endl;

free(str);

}

注意

��不要用return语句�q�回指向“栈内�?#8221;的指�?/p>

char *GetString(void)

{

char p[] = "hello world";

return p; // �~�译器将提出警告

}

void Test4(void)

{

char *str = NULL;

str = GetString(); // str 的内�Ҏ��垃圾

cout<< str << endl;

}

宝杉 2007-08-03 13:08 发表评论

内存��理

宝杉 — Fri, 03 Aug 2007 05:06:00 GMT

内存分配方式

1 静态存储区�?nbsp; 全局变量 static

2 �?nbsp; 局部变�?/p>

3 动态存储区域（堆）(malloc free) (new delete)

常见错误和对�{?/p>

1 内存分配未成功�?/p>

对策�Q�程序入口处�Q�检查指针是否�ؓNULL�?/p>

�Q?�Q�参�?p所指向的内存，用assert( p != NULL)

�Q?�Q�malloc或new甌��的内存，用if ( p != NULL)

2 内存未初始化�?/p>

3 内存操作��界�?/p>

4 忘记释放内存�Q�内存泄霌Ӏ?/p>

new与delete配对�?/p>

5 释放内存�Q�却�l�箋使用�?/p>

�Q?�Q�return不能�q�回“栈内存指�?#8221;�?#8220;引用”�Q�因��内存在函数结束时被销毁�?/p>

�Q?�Q�释攑ֆ�存后�Q�设为NULL�Q�防�?#8220;野指�?#8221;�?/p>

规则

1 甌��内存后检查。assert( p != NULL)

2 数组、动态内存初始化�?/p>

3 甌��释放要配寏V�?/p>

4 释放内存讄��NULL�Q�防止��生野指针�?/p>

宝杉 2007-08-03 13:06 发表评论

宝杉 — Fri, 03 Aug 2007 05:05:00 GMT

引用的主要作用：传递函数的参数和返回倹{�?/p>

C++语言中，函数的参数和�q�回值的传递方式有三种�Q��g��递、指针传递和引用传递�?o:p>

��g��?o:p>

函数内的形参是实参（外部变量�Q�的一个拷贝，所以不会媄响实参（外部变量�Q�的倹{�?/p>

void Func1(int x)

{

x = x + 10;

}

…

int n = 0;

Func1(n);

cout << “n = ” << n << endl; // n = 0

指针传�?o:p>

void Func2(int *x)

{

(* x) = (* x) + 10;

}

…

int n = 0;

Func2(&n);

cout << “n = ” << n << endl; // n = 10

引用传�?o:p>

void Func3(int &x)

{

x = x + 10;

}

…

int n = 0;

Func3(n);

cout << “n = ” << n << endl; // n = 10

指针功能强大�Q�但非常危险。恰如其分的使用“引用”�Q�发挥其作用�?/p>

一般先考虑“引用”�Q�如�?#8220;引用”不能做的事，则再�?#8220;指针”来完成�?/p>

宝杉 2007-08-03 13:05 发表评论

宝杉 — Fri, 03 Aug 2007 05:04:00 GMT

pragma��是��Z��让编译器�~�译出的C或C++�E�序与机器硬件和操作�pȝ��保持完全兼容而定义的宏扩展，#pragma是和特定�~�译器相关的�?/p>

一、Pragma说明(Directives)

C和C++�E�序的每�ơ执行都支持其所在的��L��或操作系�l�所��h��的一些独特的特点�?br>一些程�?例如�Q�需要精��控制数据存攄��内存区域或控制某个函数接收的参数�?br>#pragma指示为编译器提供了一�U�在不同机器和操作系�l�上�~�译以保持C和C++完全兼容的方法。Pragmas是由机器和相关的操作�pȝ��定义的，通常�Ҏ��个编译器来说是不同的�?/p>

二、语�?Syntax)

#pragma token-string(特征字符�?特征字符串是一�q�串的字�W�，��是要给一个特定编译器提供说明和编译意见�?/p>

�W�号(#)必须是pragma所在那一行的�W�一个非�I�格字符;
#号和pragma之间可以有�Q意个�I�格�W��?br>�?pragma之后�Q�是可以被编译器解析的预处理特征字符�?br>一般认�?#pragma属于宏扩展�?br>如果�~�译器发��C��认识的pragma,会提��告，但��l�编译下厅R�?/p>

Pragmas可以用在条�g声明上，提供最新的功能性的预处理程序，或者提供给�~�译器定义执行的信息�?/p>

其格式一般�ؓ: #pragma para

其中para为参敎ͼ�下面来看一些常用的参数�?br>

alloc_text
comment //注释
init_seg1
optimize //最优化
auto_inline
component //�l�成部�g
inline_depth
pack //�?br>bss_seg
data_seg
inline_recursion //内嵌递归
pointers_to_members1
check_stack
function
intrinsic //内在�?br>setlocale
code_seg
hdrstop
message
vtordisp1
const_seg
include_alias
once
warning

参数详解

diary files\#pragma 预处理指令详�?doc

宝杉 2007-08-03 13:04 发表评论

宝杉 — Fri, 03 Aug 2007 05:03:00 GMT

* 非递归锁：非递归锁提供互斥的一�U�高效的形式�Q�它定义一个��界区�Q�每一时刻只有单个�U�程可在其中执行。它们之所以是非递归的，是因为当前拥有锁的线�E�在��其释放前不可以再次获取它。否则，��׃��立即发生死锁�?/span>SunOS 5.x通过它的mutex_t�?/span>rwlock_t�Q�和sema_t�c�d��Q?/span>POSIX Pthreads不提供后两种同步机制�Q��ؓ非递归锁提供支持�?/span>ASX构架提供Mutex�?/span>RW_Mutex�Q�和Semaphore包装�Q�以分别��装�q�些语义�?/span>

* 递归锁：另外一斚w��Q�递归锁允�?/span>acquire�Ҏ��嵌套调用�Q�只要当前拥有该锁的�U�程��是试图重新获取它的�U�程。递归锁对于回调驱动的事�g分派构架�Q�比�?/span>1.3.2描述的反应堆�Q�特别有用，在其中构架的事�g循环执行寚w��登记的用户定义的对象的回调。因为随后用户定义的对象可能�l�由它的�Ҏ��入口重入分派构架�Q�必��M��用递归锁以防止在回调过�E�中构架持有的锁发生死锁�?/span>

宝杉 2007-08-03 13:03 发表评论

using namespace std;

宝杉 — Fri, 03 Aug 2007 05:01:00 GMT

错误�Q?/p>

#include
#include

……

string st("test string");

……

error C2065: 'string' : undeclared identifier

解释�Q?/p>

#include

using namespace std;

因�ؓ�? using namespace std; 情况下，

#include 是��? C++ string �c�d��Q?nbsp;

#include 是��? C 的string 操作库函�? ...

�l�节加不�?#8220;.h”

#include

using namespace std;

没有错！�Q?/p>

�?/p>

#include

using namespace std;

�~�译有错�Q�！

解释

“string.h“�q�个头文件是“旧式c头文�?#8221;�Q�而这个文件中没有定义string�c�（�q�点应该不奇怪，c语言中哪有什么类啊）�Q�这个头文�g里面是有�?#8220;旧式char-based字符�?#8221;的操作函敎ͼ�注意都是操作char*字符串的“函数”�Q�所以你引用�q�个头文�Ӟ��~�译器肯定找不到“string”了�?
“string”�q�个头文�Ӟ��没有扩展名）是C++标准化之后的C++头文�Ӟ��里面才有string�cȝ��相关定义�Q�其实，string�q�不是类�Q�是一个typedef�Q�但是��用的时候不用去��他�Q�，而C++标准头文件中的东襉K��攑֜�namespace std中了�Q�所以��用的时候要“using namespace std”�?
附：��g��不要�?iostream.h"�Q�改�?#8220;iostream”吧，因�ؓ标准已经明确规定不在支持"iostream.h"�q�种头文件了�?/p>

标准写法

#include

using namespace std;

F: ��Z��么using namespace std;
要写在include后面�Q?/p>

Q: 因�ؓinclude的文件包含名字域std
如果你把using namespace std写在前面�Q�编译器��q��不到std�q�个名字

宝杉 2007-08-03 13:01 发表评论

C++中的引用

宝杉 — Fri, 03 Aug 2007 05:00:00 GMT

引用卛_��名，数组不能引用�?/p>

引用提高效率�Q�又不在函数中改变。参考：file:///F:/fragments/documents/深入探讨C++中的引用%20-%20KiRa的专�?20-%20CSDNBlog.mht

常引�?/p>

常引用声明方式：const �c�d��标识�W?&引用�?= 目标变量名；

const�c�d�� ?& 是分不开的，引用一般定义成const�?/p>

引用作�ؓ�q�回�?/p>

要以引用�q�回函数��|��则函数定义时要按以下格式�Q?/p>

�c�d��标识�W?&函数名（形参列表及类型说明）
{

函数�?/p>

}

说明�Q?/p>

　　�Q?�Q�以引用�q�回函数��|��定义函数旉��要在函数名前�?amp;

　　�Q?�Q�用引用�q�回一个函数值的最大好处是�Q�在内存中不产生被返回值的副本�?/p>

例子�Q?a href="http://www.shnenglu.com/robinson119/admin/C++exams/rtn_ref">Diary files\C++exams\rtn_ref

引用作�ؓ�q�回��|��必须遵守以下规则�Q?/p>

�Q?�Q�不能返回局部变量的引用。这条可以参照Effective C++[1]的Item 31。主要原因是局部变量会在函数返回后被销毁，因此被返回的引用��成��Z��"无所�?的引用，�E�序会进入未知状态�?

�Q?�Q�不能返回函数内部new分配的内存的引用。这条可以参照Effective C++[1]的Item 31。虽然不存在局部变量的被动销毁问题，可对于这�U�情况（�q�回函数内部new分配内存的引用）�Q�又面��其它��尬局面。例如，被函数返回的引用只是作�ؓ一个��时变量出玎ͼ�而没有被赋予一个实际的变量�Q�那么这个引用所指向的空��_��由new分配�Q�就无法释放�Q�造成memory leak�?/p>

�Q?�Q�可以返回类成员的引用，但最好是const。这条原则可以参照Effective C++[1]的Item 30。主要原因是当对象的属性是与某�U�业务规则（business rule�Q�相兌��的时候，其赋值常�怸�某些其它属性或者对象的状态有养I��因此有必要将赋值操作封装在一个业务规则当中。如果其它对象可以获得该属性的非常量引用（或指针）�Q�那么对该属性的单纯赋值就会破坏业务规则的完整性�?/p>

�Q?�Q�引用与一些操作符的重载：

　　��操作符<<�?gt;>�Q�这两个操作�W�常常希望被�q�箋使用�Q�例如：cout << "hello" << endl;　因此�q�两个操作符的返回值应该是一个仍然支持这两个操作�W�的��引用。可选的其它�Ҏ��包括�Q�返回一个流对象和返回一个流对象指针。但是对于返回一个流对象�Q�程序必��重斎ͼ�拯��Q�构造一个新的流对象�Q�也��是��_��q�箋的两�?lt;<操作�W�实际上是针对不同对象的�Q�这无法让�h接受。对于返回一个流指针则不能连�l��?lt;<操作�W�。因此，�q�回一个流对象引用是惟一选择。这个唯一选择很关键，它说明了引用的重要性以及无可替代性，也许�q�就是C++语言中引入引用这个概�늚�原因吧�?赋值操作符=。这个操作符象流操作�W�一��P��是可以连�l��用的�Q�例如：x = j = 10;或�?x=10)=100;赋值操作符的返回值必��L��一个左��|��以便可以被��l�赋倹{��因此引用成了这个操作符的惟一�q�回值选择�?/p>

宝杉 2007-08-03 13:00 发表评论

ANSI C/C++的编译器规范

宝杉 — Fri, 03 Aug 2007 04:59:00 GMT

在Visual C++中，可以在函数类型前加_cdecl�Q�_stdcall或者_pascal来表�C�其调用规范�Q�默认�ؓ_cdecl�Q?/p>

// 被调用函数是以int为参敎ͼ�以int��回�?br>__stdcall int callee(int);

// 调用函数以函数指针�ؓ参数
void caller( __cdecl int(*ptr)(int));

// 在p中企囑֭�储被调用函数地址的非法操�?br>__cdecl int(*p)(int) = callee; // 出错

指针p和callee()的类型不兼容�Q�因为它们有不同的调用规范。因此不能将被调用者的地址赋值给指针p�Q�尽��两者有相同的返回值和参数列�?nbsp;

宝杉 2007-08-03 12:59 发表评论

函数指针

宝杉 — Fri, 03 Aug 2007 04:58:00 GMT

声明�Q?/p>

先定义函敎ͼ�void print(string str)�Q?/p>

声明一个函数指针，void ( *p )( string ) = NULL;

指向copy函数�Q�p = & print; �?p = print�Q?/p>

调用指针函数�Q�p( “hello” );

可以把多个函数放在一个指针数�l�里�Q�然后通过数组对应指针方便调用函数�?/p>

例子�Q?a href="http://www.shnenglu.com/robinson119/admin/C++exams/pointer_func">Diary files\C++exams\pointer_func

动态绑定一个函�?/p>

void caller(void(*ptr)())

{

ptr(); /* 调用ptr指向的函�?*/

}

void func();

int main()

{

p = func;

caller(p); /* 传递函数地址到调用�?*/

}

如果赋了不同的值给p�Q�不同函数地址�Q�，那么调用者将调用不同地址的函数。赋值可以发生在�q�行�Ӟ��q�样使你能实现动态绑定�?/p>

宝杉 2007-08-03 12:58 发表评论

重蝲

宝杉 — Fri, 03 Aug 2007 04:57:00 GMT

静态联�~�：�q�行之前���完成的联编�Q�系�l�在�~�译时就军_��如何完成某个动作�?/span>

动态联�~�：�E�序�q�行之后才完成的联编�Q�系�l�在�q�行时动态实现某一动作�?/span>

静态多态性：函数重蝲�Q�运���符重蝲�Q?/span>

动态多态性：�l�承�Q�虚函数�Q?br>

函数重蝲

1 参数有差别�?/span>

2 参数相同�Q�属不同�c�R�?/span>

一个重载的例子�Q?/span>Diary files\C++exams\func_reload

名字压�g�Q?/span>是编译器�Ҏ��函数重蝲的不同类型，在编译时改变函数名字�Q�而达到区分的目的�?/span>

宝杉 2007-08-03 12:57 发表评论

宝杉 — Fri, 03 Aug 2007 04:55:00 GMT

友元函数一般在�c�M��声明�Q�如果一个友元需要访问多个类的对象，那么每个�c�都要声明一�ơ友元函数�?/p>

�q�要注意�Q�友元函数的入口包括多个�c�，那这些类都要在友元函��C��前声明�?/p>

如例子：Diary files\C++exams\frnd_vst2_func

如果是类person的两个��承他的子�c�boy和girl�Q�那么友元函数如何声明和定义�?/p>

Diary files\C++exams\frnd_member

�q�需要注意的地方有：

基类的数据成员共有；构造函敎ͼ�构造函数初始化表；�cȝ��声明先于友元函数�Q�提高了重用性；

基类的数据成员必��d��有，因�ؓ构造函��C��讉K��到它们，子类的构造函��C��会引用基�cȝ��构造函敎ͼ�如果是私有的会是的子�c�L��造函��C��能直接访问基�cȝ��U�有成员�Q�要通过基类的成员函数来讉K��?/p>

子类�Q�public基类

�q�有写细节问题：

头文�Ӟ��char *a的声明和使用�Q�分配char*数据�Q?/p>

例如�Q?/p>

char *name;

name = new char[ strlen( s ) + 1 ];

友元函数的声明时的入口参数可以只写类型，不写参数名�?/p>

例如�Q?/p>

class boy

{

……

void disp( gril & );

}

注意声明时的入口参数可省略，但要�?amp;�?/p>

定义�Ӟ��写成

void disp( gril &x ){ …… }

宝杉 2007-08-03 12:55 发表评论

this指针

宝杉 — Fri, 03 Aug 2007 04:53:00 GMT

声明�Q?nbsp; �c?nbsp; 对象�Q?nbsp; �c?nbsp; *指针�Q?/p>

int i; *this�Q?/p>

this指针是一个隐含指针，是成员函数所属对象的指针�?/p>

每个成员函数都有一个this指针�Q�this指针指向该函数所属类的对象�?/p>

使用格式�Q�this -> 成员变量

不同的对象调用同一个成员函敎ͼ�C++会根据成员函数的this指针指向哪一个对象，来调用该对象的成员变量�?/p>

this指针如何得到对象名？

例如�Q�一个类class me的初始化函数�Q?/p>

void init(char ma, int mb)

{ a = ma; b = mb; }

�~�译�Ӟ��被编译器转化为：

void init(me *this, char ma, int mb) //多了一个this指针的参敎ͼ�指向me�cȝ��obj

{ this -> a = ma, this -> b = mb; }

宝杉 2007-08-03 12:53 发表评论

宝杉 — Fri, 03 Aug 2007 04:52:00 GMT

对于只做输入用的指针参数�Q�最好用const�Q�这样避免指针参数被修改�?

比如�Q�对于上面的StringCopy的例子，写成

void StringCopy (char *strDestination, const char *strSource); //比较安全�?/p>

但是如果输入参数以��g��递的形式传递对象，则改��Z��用const &最好，因�ؓ省去了��时对象的构造和解析的过�E�，提高效率和安全性�?/p>

int printf�Q?#8230;…�Q�；�q�个函数的参��C��定�Q�没有严格的�c�d��查，所以最好不用�?/span>

宝杉 2007-08-03 12:52 发表评论

无码乱码观看精品久久,粉嫩小泬无遮挡久久久久久,亚洲综合精品香蕉久久网97

<�?gt;dll详细介绍

8-28模板

08-22

08-13复习

08-10 内联函数

08-08 隐藏

08-07 重蝲�Q�overloaded�Q�、内联（inline�Q�、const和virtual

08-06 free和delete

内存���理

using namespace std;

C++中的引用

ANSI C/C++的编译器规范

函数指针

重蝲

this指针

内存��理