F：宏定义也可以实现重用，为什么不使用宏？

Q：宏避开C++类型检查机制，两个不同类型参数之间的比较将会导致错误。

模板，模板函数，模板类和对象之间的关系。

模板 （函数模板和类模板）

模板函数

模板类

对象

箭头代表实例化

 

模板 （函数模板和类模板）

模板函数

模板类

对象

例如：

C++exams\template_max

模板形参将T实例化的参数。

函数模板是一个不完全的函数，首先需要将模板形参T实例化为确定的类型。这个类型可以是预定义的，也可以是用户自定义。

模板函数的异常

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

（1）寻找类型完全匹配的函数。

（2）寻找函数模板，实例化后，产生匹配的模板函数。

（3）若（1）（2）失败，尝试低一级的对函数重载的方法。例如，通过类型转换。

（4）（1）（2）（3）都为匹配，则是一个错误。

2 先了解了这样的约定，就很容易理解以下：

用非模板函数重载函数模板，只声明非模板类函数的原型，不给出函数体，而函数体借用函数模板的函数体。

例如：

template <class T>

T max( T x, T y)

{

         return( x > y )? x : y;

}

int max( int, int);

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

int i;

char c;

max（i, c）;

3 定义一个完整的有函数体的非模板函数。

比如：max(char, char)时，上面的函数模板不能比较比一个字符更长的字符串了。

所以，像一般的重载函数一样定义。

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

{

         return ( strcmp(x, y) > 0 ) ? x ：y；

}

char * max重载了函数模板，当调用为：

max ( “abcd”, “efgh” ); 将执行此函数。

     class A

     { …

       private:

         A(const A &a);                   // 私有的拷贝构造函数

         A & operate =(const A &a);  // 私有的赋值函数

     };

如果有人试图编写如下程序：

     A  b(a); // 调用了私有的拷贝构造函数

     b = a;        // 调用了私有的赋值函数

编译器将指出错误，因为外界不可以操作A的私有函数。

但是怎样才能使用构造拷贝和赋值函数呢？

虚拟函数使用：C++exams\destructor

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

C++exams\base_operator

析构函数

构造函数初始化表：构造函数特殊的初始化方式“初始化表达式表”（简称初始化表）。

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

规则

u       如果类存在继承关系，派生类必须在其初始化表里调用基类的构造函数。

u       类的const常量只能在初始化表里被初始化，因为它不能在函数体内用赋值的方式来初始化。

u       类的数据成员的初始化可以采用初始化表或函数体内赋值两种方式，这两种方式的效率不完全相同。

效率

1 内部成员：

初始化表和函数体内赋值都可以，但效率不完全相同，但后者更为清晰直观。

例子：

class F

{

 public:

    F(int x, int y);        // 构造函数

 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; }

示例9-2(c) 数据成员在初始化表中被初始化     示例9-2(d) 数据成员在函数体内被初始化

两种方式效率区别不大。

2 非内部成员：

只能用初始化表，提高效率。

例子：

    class A

{…

    A(void);                // 无参数构造函数

    A(const A &other);      // 拷贝构造函数

    A & operate =( const A &other); // 赋值函数

}；

    class B

    {

     public:

        B(const A &a); // B的构造函数

     private: 

        A m_a;         // 成员对象

};

比较与分析：

B::B(const A &a)  : m_a(a)           {    … }

B::B(const A &a) { m_a = a; … }

1 B类构造函数的初始化里，调用了A类的拷贝构造函数。

2 B类构造初始化里，隐藏了以下几个步骤：

先创建了a对象，调用了A类的无参数构造函数；

把a赋值给m_a，调用了A类的赋值函数；

深入探讨：

构造和析构的次序？

构造从最深处的基类开始的，先一层层调用基类的构造函数，然后调用成员对象的构造函数。

而析构函数严格按照构造函数相反的次序执行，该次序唯一，以便让编译器自动执行析构函数。

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

故C++中，用内联取代所有宏，但在Debug版本中，assert是例外。

assert不产生任何副作用，调用函数会引起内存、代码的变动，所以assert是宏。

内联格式：

     void Foo(int x, int y);    

     inline void Foo(int x, int y)    // inline与函数定义体放在一起

     {

         …

     }

用于实现的关键字，而非用于声明的关键字。

在类中的规范格式：

class A

     {

public:

         void Foo(int x, int y)；

     }

     // 定义文件

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

{

…

}

什么情况不适合使用内联？

1 内联函数代码较长，导致内存消耗较高。

2 内联函数包括循环，执行内联函数代码比调用函数的开销大。

F：为什么构造和解析函数不使用内联？

Q：因为析构函数可能“隐藏”一些行为，例如执行基类或成员对象的析构过程。

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

提高程序易用性，避免每次调用函数参数都相同的情况。

缺省值只能出现在函数声明中，不能在函数定义中。

两个原因：

一是函数的实现（定义）本来就与参数是否有缺省值无关，所以没有必要让缺省值出现在函数的定义体中。

二是参数的缺省值可能会改动，显然修改函数的声明比修改函数的定义要方便。

规则：参数从后向前缺省

正确的示例如下：

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

错误的示例如下：

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

但要避免二义性

C++exams\default_para

运算符重载及其规则

运算符即可定义为成员函数，也可定义为全局函数。

规则如下：

不能重载的运算符

（1）不能改变C++内部数据类型（如int,float等）的运算符。

（2）不能重载‘.’，因为‘.’在类中对任何成员都有意义，已经成为标准用法。

（3）不能重载目前C++运算符集合中没有的符号，如#,@,$等。原因有两点，一是难以理解，二是难以确定优先级。

（4）对已经存在的运算符进行重载时，不能改变优先级规则，否则将引起混乱。

函数内联

目的：提高执行效率。

宏

Q为什么要用？

A提高执行效率。

Q如何提高？

A宏代码本身不是函数，但使用起来象函数。预处理器用复制宏代码的方式代替函数调用，省去了参数压栈、生成汇编语言的CALL调用、返回参数、执行return等过程，从而提高了速度。

Q缺点？

使用宏代码最大的缺点是容易出错，预处理器在复制宏代码时常常产生意想不到的边际效应。

例如：

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

语句

result = MAX(i, j) + 2 ;

将被预处理器解释为

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

由于运算符‘+’比运算符‘:’的优先级高，所以上述语句并不等价于期望的

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

如果把宏代码改写为

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

则可以解决由优先级引起的错误。但是即使使用修改后的宏代码也不是万无一失的，例如语句result = MAX(i++, j);

将被预处理器解释为

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

对于C++ 而言，使用宏代码还有另一种缺点：无法操作类的私有数据成员。

“隐藏”是指派生类的函数屏蔽了与其同名的基类函数，规则如下：

（1）如果派生类的函数与基类的函数同名，但是参数不同。此时，不论有无virtual关键字，基类的函数将被隐藏（注意别与重载混淆）。

（2）如果派生类的函数与基类的函数同名，并且参数也相同，但是基类函数没有virtual关键字。此时，基类的函数被隐藏（注意别与覆盖混淆）。

回顾：

静态多态性：函数重载；运算符重载；

动态多态性：继承；虚函数；

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

隐藏

不同指针指向同一地址，那么指针的类型决定调用方法，还是指针指向的对象？

例子：C++exams\hide

可以看出，virtual函数可以实现不同类型的指针指向不同对象，调用不同的方法。

就是说，当父类对象和子类对象同时存在，且调用父子对象的同名方法时，只能用虚拟函数实现。

另外，提供一种思路：

如果基类与派生类的同名函数参数不同，比如：

基类为int,派生类为string.如果想在派生类中调用基类的方法，即在派生类中添加基类方法的调用。

class Derived : public Base

{

public:

void f(char *str);

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

};

但此做法容易混乱，不宜使用。最好的方法还是用virtual。

指针类型

对象类型

面向对象动态的设计，应该是对象类型起到关键作用，而不是指针类型。

成员函数被重载的特征：

（1）相同的范围（在同一个类中）；

（2）函数名字相同；

（3）参数不同；

（4）virtual关键字可有可无。

覆盖是指派生类函数覆盖基类函数，特征是：

（1）不同的范围（分别位于派生类与基类）；

（2）函数名字相同；

（3）参数相同；

（4）基类函数必须有virtual关键字。

例子：C++exams\cover

指向基类的指针可以指向其共有派生类的对象，但反之不行，另外私有派生类也不行。

比如：车 是基类，小汽车，马车 等是派生类。

一个车类的指针可以指向任何派生类，因为它们都属于车。

而反之，不能说指向马车的指针可以指向车，因为车的概念最大。

	重载	内联	const	virtual
全局函数	√	√
类的成员函数	√	√	√	√

内部标识符

编译器根据参数为每个重载函数创建内部标识符，以便区分忽略返回值与有返回值的重载函数。

连接交换指定符号

C编译过的函数，经过编译器标识后与C++的表示风格不同。所以C++不能直接调用C编译出的函数。C++提供extern “C”

例如：

extern “C”

{

   void foo(int x, int y);

   … // 其它函数

}

或者写成

extern “C”

{

   #include “myheader.h”

   … // 其它C头文件

}

全局函数与成员函数同名

全局函数与成员函数同名不算重载，因为函数作用域不同。

为了区别，调用全局函数时，注意格式：

：：函数名（参数）；

隐式类型转换导致重载函数产生二义性

隐式类型转换：数字本身没有类型，把数字当作参数，自动进行类型转换。

例如：

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

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

output(0.5)将产生编译错误，因为编译器不知道该将0.5转换成int还是float类型的参数。

正确写法：

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

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

只是把指针所指的内存给释放掉，但并没有把指针本身干掉。

注意：

（1）指针消亡了，并不表示它所指的内存会被自动释放。

（2）内存被释放了，并不表示指针会消亡或者成了NULL指针。

比较

malloc和free：无法满足动态对象的要求。对象在创建同时进行构造，消亡同时析构。

malloc free是库函数，不是运算符，不受编译器控制。

new和delete：不是库函数，能动态内存分配和清理内存。

内存耗尽

内存耗尽时new和malloc返回NULL。但在WIN32下，使用虚拟内存，不会耗尽的。

处理内存耗尽大概有两种。

A  *a = new A;

1       一处内存申请

if(a == NULL)

{

     return;

     }

2    如果有多处申请内存，则

if(a == NULL)

{

     cout << “Memory Exhausted” << endl;

     exit(1);

}

new与delete使用要点

1 new内置了sizeof、类型转换和类型安全检查功能。

2 new在创建非内部数据类型的动态对象的同时完成了初始化工作。

3 对象有多个构造函数，那么new的语句也可以有多种形式。

例如：diary files\obj.txt

4 如果用new创建对象数组，那么只能使用对象的无参数构造函数。例如

     Obj  *objects = new Obj[100];    // 创建100个动态对象

不能写成

     Obj  *objects = new Obj[100](1);// 创建100个动态对象的同时赋初值1

5在用delete释放对象数组时，留意不要丢了符号‘[]’。例如

     delete []objects;  // 正确的用法

delete objects;    // 错误的用法

后者相当于delete objects[0]，漏掉了另外99个对象。

指针可以随时指向任意类型的内存块，它的特征是“可变”，所以我们常用指针来操作动态内存。指针远比数组灵活，但也更危险。

1 修改内容

       char a[] = "hello";

       a[0] = 'X';

       cout << a << endl;

       char *p = "world";     // 注意p指向常量字符串

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

       cout << p << endl;

2 复制与比较

strcpy（new type[strlen（a）+1]），而不能用p = a    //把a的地址给了p，而不是a的内容

strcmp（if strcmp（a,p）== 0），而不能用      if( a = p)  

       // 数组…

       char a[] = "hello";

       char b[10];

       strcpy(b, a);                 // 不能用       b = a;

       if(strcmp(b, a) == 0)     // 不能用  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内存容量计算

1           sizeof(p)相当于sizeof(char*)，C++不支持对指针所指内容容量的计算。

char a[] = "hello world";

    char *p  = a;

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

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

2           数组作为函数参数，退化成同类型指针。

void Func(char a[100])

    {

        cout<< sizeof(a) << endl;   // 4字节而不是100字节

}

指针参数传递内存

首先，考虑函数为参数创建临时副本的问题。对于值传递，有形参和实参的区别。但对于引用和指针传递，则可能会产生问题。

指针作为函数参数，不能动态申请内存。

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");               // 运行错误

}

毛病出在函数GetMemory中。编译器总是要为函数的每个参数制作临时副本，指针参数p的副本是 _p，编译器使 _p = p。如果函数体内的程序修改了_p的内容，就导致参数p的内容作相应的修改。这就是指针可以用作输出参数的原因。在本例中，_p申请了新的内存，只是把_p所指的内存地址改变了，但是p丝毫未变。所以函数GetMemory并不能输出任何东西。事实上，每执行一次GetMemory就会泄露一块内存，因为没有用free释放内存。

如何改正：

1 用“指向指针的指针”

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

{

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

}

void Test2(void)

{

       char *str = NULL;

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

       strcpy(str, "hello");

       cout<< str << endl;

       free(str);

}

2 用函数返回值来传递动态内存

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语句返回指向“栈内存”的指针

char *GetString(void)

{

       char p[] = "hello world";

       return p;  // 编译器将提出警告

}

void Test4(void)

{

char *str = NULL;

str = GetString();   // str 的内容是垃圾

cout<< str << endl;

}

1 静态存储区域           全局变量 static

2 栈                            局部变量

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

常见错误和对策

1 内存分配未成功。

对策：程序入口处，检查指针是否为NULL。

（1）参数*p所指向的内存，用assert( p != NULL)

（2）malloc或new申请的内存，用if ( p != NULL)

2 内存未初始化。

3 内存操作越界。

4 忘记释放内存，内存泄露。

new与delete配对。

5 释放内存，却继续使用。

       （1）return不能返回“栈内存指针”和“引用”，因为该内存在函数结束时被销毁。

       （2）释放内存后，设为NULL，防止“野指针”。

规则

1 申请内存后检查。assert( p != NULL)

2 数组、动态内存初始化。

3 申请释放要配对。

4 释放内存设置NULL，防止产生野指针。

C++语言中，函数的参数和返回值的传递方式有三种：值传递、指针传递和引用传递。

值传递

函数内的形参是实参（外部变量）的一个拷贝，所以不会影响实参（外部变量）的值。

    void Func1(int x)

{

    x = x + 10;

}

…

int n = 0;

    Func1(n);

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

指针传递

    void Func2(int *x)

{

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

}

…

int n = 0;

    Func2(&n);

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

引用传递

    void Func3(int &x)

{

    x = x + 10;

}

…

int n = 0;

    Func3(n);

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

指针功能强大，但非常危险。恰如其分的使用“引用”，发挥其作用。

一般先考虑“引用”，如果“引用”不能做的事，则再用“指针”来完成。

pragma就是为了让编译器编译出的C或C++程序与机器硬件和操作系统保持完全兼容而定义的宏扩展，#pragma是和特定编译器相关的。

一、Pragma说明(Directives)

C和C++程序的每次执行都支持其所在的主机或操作系统所具有的一些独特的特点。
一些程序,例如，需要精确控制数据存放的内存区域或控制某个函数接收的参数。
#pragma指示为编译器提供了一种在不同机器和操作系统上编译以保持C和C++完全兼容的方法。Pragmas是由机器和相关的操作系统定义的，通常对每个编译器来说是不同的。

二、语法(Syntax)

#pragma token-string(特征字符串)特征字符串是一连串的字符，就是要给一个特定编译器提供说明和编译意见。

符号(#)必须是pragma所在那一行的第一个非空格字符;
#号和pragma之间可以有任意个空格符。
在#pragma之后，是可以被编译器解析的预处理特征字符。
一般认为,#pragma属于宏扩展。
如果编译器发现不认识的pragma,会提出警告，但继续编译下去。

Pragmas可以用在条件声明上，提供最新的功能性的预处理程序，或者提供给编译器定义执行的信息。

其格式一般为: #pragma  para 

其中para为参数，下面来看一些常用的参数。

参数详解

diary files\#pragma  预处理指令详解.doc

   * 递归锁：另外一方面，递归锁允许acquire方法嵌套调用，只要当前拥有该锁的线程就是试图重新获取它的线程。递归锁对于回调驱动的事件分派构架（比如1.3.2描述的反应堆）特别有用，在其中构架的事件循环执行对预登记的用户定义的对象的回调。因为随后用户定义的对象可能经由它的方法入口重入分派构架，必须使用递归锁以防止在回调过程中构架持有的锁发生死锁。

#include   <iostream.h>
#include   <string.h>

……

string   st("test   string");  

……

error   C2065:   'string'   :   undeclared   identifier  

解释：

#include   <string>  

using   namespace   std;  

因为在   using   namespace   std;   情况下， 

#include   <string>     是使用   C++     string   类库； 

#include   <cstring>     是使用   C   的string   操作库函数   ...  

细节 加不加“.h”

#include <iostream.h>

#include <string>

using       namespace      std;

没有错！！

而

#include <iostream.h>

#include <string.h>

using       namespace      std;

编译有错！！

解释

  “string.h“这个头文件是“旧式c头文件”，而这个文件中没有定义string类（这点应该不奇怪，c语言中哪有什么类啊），这个头文件里面是有关“旧式char-based字符串”的操作函数，注意都是操作char*字符串的“函数”，所以你引用这个头文件，编译器肯定找不到“string”了。  
  “string”这个头文件（没有扩展名）是C++标准化之后的C++头文件，里面才有string类的相关定义（其实，string并不是类，是一个typedef，但是使用的时候不用去管他），而C++标准头文件中的东西都放在namespace   std中了，所以使用的时候要“using   namespace   std”。  
  附：建议楼主不要用"iostream.h"，改成“iostream”吧，因为标准已经明确规定不在支持"iostream.h"这种头文件了。

标准写法

#include <iostream>

#include <string>

using       namespace      std;

F: 为什么using   namespace   std;  
       要写在include后面？

Q: 因为include的文件包含名字域std  
如果你把using   namespace   std写在前面，编译器就看不到std这个名字

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

常引用

常引用声明方式：const 类型标识符 &引用名 = 目标变量名；

const类型 和 & 是分不开的，引用一般定义成const。

引用作为返回值

要以引用返回函数值，则函数定义时要按以下格式：

类型标识符 &函数名（形参列表及类型说明）
{

函数体

}

说明：

　　（1）以引用返回函数值，定义函数时需要在函数名前加&

　　（2）用引用返回一个函数值的最大好处是，在内存中不产生被返回值的副本。

例子：Diary files\C++exams\rtn_ref

引用作为返回值，必须遵守以下规则：

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

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

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

（4）引用与一些操作符的重载：

　　流操作符<<和>>，这两个操作符常常希望被连续使用，例如：cout << "hello" << endl;　因此这两个操作符的返回值应该是一个仍然支持这两个操作符的流引用。可选的其它方案包括：返回一个流对象和返回一个流对象指针。但是对于返回一个流对象，程序必须重新（拷贝）构造一个新的流对象，也就是说，连续的两个<<操作符实际上是针对不同对象的！这无法让人接受。对于返回一个流指针则不能连续使用<<操作符。因此，返回一个流对象引用是惟一选择。这个唯一选择很关键，它说明了引用的重要性以及无可替代性，也许这就是C++语言中引入引用这个概念的原因吧。 赋值操作符=。这个操作符象流操作符一样，是可以连续使用的，例如：x = j = 10;或者(x=10)=100;赋值操作符的返回值必须是一个左值，以便可以被继续赋值。因此引用成了这个操作符的惟一返回值选择。

// 被调用函数是以int为参数，以int为返回值
__stdcall int callee(int);

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

// 在p中企图存储被调用函数地址的非法操作
__cdecl int(*p)(int) = callee; // 出错

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

先定义函数，void print(string str)；

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

指向copy函数，p = & print; 或 p = print；

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

可以把多个函数放在一个指针数组里，然后通过数组对应指针方便调用函数。

例子：Diary files\C++exams\pointer_func

动态绑定一个函数

void caller(void(*ptr)())

{

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

}

void func();

int main()

{

p = func;

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

}

如果赋了不同的值给p（不同函数地址），那么调用者将调用不同地址的函数。赋值可以发生在运行时，这样使你能实现动态绑定。

动态联编：程序运行之后才完成的联编，系统在运行时动态实现某一动作。

静态多态性：函数重载；运算符重载；

动态多态性：继承；虚函数；

函数重载

1 参数有差别。

2 参数相同，属不同类。

一个重载的例子：Diary files\C++exams\func_reload

名字压延：是编译器根据函数重载的不同类型，在编译时改变函数名字，而达到区分的目的。

还要注意：友元函数的入口包括多个类，那这些类都要在友元函数之前声明。

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

如果是类person的两个继承他的子类boy和girl，那么友元函数如何声明和定义。

Diary files\C++exams\frnd_member

这需要注意的地方有：

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

基类的数据成员必须共有，因为构造函数会访问到它们，子类的构造函数也会引用基类的构造函数，如果是私有的会是的子类构造函数不能直接访问基类的私有成员，要通过基类的成员函数来访问。

子类：public基类

还有写细节问题：

头文件；char *a的声明和使用；分配char*数据；

例如：

char *name;

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

友元函数的声明时的入口参数可以只写类型，不写参数名。

例如：

class boy

{

       ……

       void disp( gril & );

}

注意声明时的入口参数可省略，但要写&。

定义时，写成

void disp( gril &x ){      ……       }

                   int  i;           <class>      *this；

this指针是一个隐含指针，是成员函数所属对象的指针。

每个成员函数都有一个this指针，this指针指向该函数所属类的对象。

使用格式：this -> 成员变量

不同的对象调用同一个成员函数，C++会根据成员函数的this指针指向哪一个对象，来调用该对象的成员变量。

this指针如何得到对象名？

例如：一个类class me的初始化函数：

void init(char ma, int mb)

{ a = ma; b = mb; }

编译时，被编译器转化为：

       void init(me *this, char ma, int mb)     //多了一个this指针的参数，指向me类的obj

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

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

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

   void StringCopy (char *strDestination, const char *strSource);         //比较安全。

   但是如果输入参数以值传递的形式传递对象，则改为使用const &最好，因为省去了临时对象的构造和解析的过程，提高效率和安全性。

   int printf（……）；这个函数的参数不确定，没有严格的类型检查，所以最好不用。