教你从C轻松到C++之三

教你从C轻松到C++之三

                                                                                               
                    4.函数模数（function template）　　 前面讨论的重载机制用来实现求和操作并不受欢迎，这仿佛还不是C++的风格，例如用户需要求两个其它类型（如字符型）对象的和：Add （'a' ‘b’）；它必须再为之准备一个版本，尽管其名字和代码还是那副样子： 　char Add (char a char b)
{
return a + b;
}
　　 这样无聊的工作会让灰心的用户开始怀念起古老的“宏”。然而，更先进的东西一一模板，却可以很方便地解决以上问题： 　template <class TYPE>
TYPE Add (TYPE a TYPE b)
{
return a + b;
};
　　 作为模板参数表示了数据类型。在实际的调用中，编译程序根据实际使用的数据类型产生相应的函数。如： 　int i=Add(1 2); //int Add(int int)
float f=Add(1.0 2.0); //float Add(float float)
　　 将得到编译器正确的解释。但以下的使用： 　int i=Add('A' 0. 0l);
//error: Could not find a match for 'Add(char double)'
　　 所当然地会遭到编译器的拒绝。
　　 以上建立起来的Add）函数模板可以覆盖前面所有的Add（）函数，但再来看看以下语句： 　struct COMPLEX {float r; float i;};
typedef struct COMPLEX complex;
complex c1 c2;
complex c=Add(cl c2);
　　 同理，编译器根据Add （）模板定制成：
　　 c=（c1 +c2 }；
　　 这样的结果是没有定义的，计算机很容易对两个复数的加法不知所措而大发牢骚：
　　 Error： Illegal structure operation
　　 既然计算机不喜欢这个作品，没关系，我们为它再做一个函数就是了： 　complex Add(complex c1 complex c2)
{
complex c;
c. r=c1. r+c2. r;
c. i=c1. i+ c2. i;
return c;
}　这个函数用以正确地作复数求和。奇怪得很，函数名居然还可以取为Add，而不用担心任何冲突。对这种情形也有很好的说法，C++称之为“函数模板重置”。　　 在调用形式上，函数模板很类似于宏，但它同时具有类型检查。更普遍的，模板也可以应用于类中。
　　 至此，对抗#define之战已快接近尾声，然而这似乎永远不得结束。宏就是宏，它总有它的优点，譬如它可节省对象空间，你无法阻止有些C++用户仍喜爱它。
　　 5.操作符重载（operator overload）
　　 我还要声明的是，前面定义的Add（）函数，特别是为complex定做的那个，仍然是值得鄙弃的。它们虽然都能正常工作，但仍不是C++常用的风格。既然是求和，我们会更倾向于表达方式“complex c = c1 +c2；”而不是“complex c =Add（cl c2）；”。
　　 操作符‘+’的使用要比Add （ ）函数的调用让人舒服得多。C++中你完全可以摒弃所谓的“模板重置”，而直接对操作符‘+’进行重载： 　complex operator+(complex c1 complex c2)
{
complex c;
c.r=cl.r+c2. r;
c. i=cl.i+c2. i;
}
　　 这样当出现。c1+ c2的形式时，表达式就会被赋予正当的含义。以下分述一些常见操作符的重载：（1）单目操作符的重载：设@为一个单目运算符，则@x和x@都被解释成operator @（x）。
　　 瞧，这不就是函数调用的形式了吗？其中operator是C++的关键字。例如语句y=——x；将被译作y = operator——（x）；下面是一个求复数相反数的例子： 　//test11. cpp
#include <iostream.h>
#include "complex.h"
complex operator - (complex c)
{
　　　　　　 c.r = -c.r;
　　　　　　 c.i = -c.i;
　　　　　　 return c;
}
void main()
{
　　　　　　 complex c={1.0 2.0};
　　　　　　 c= -c;
　　　　　　 cout<<"c=(" <<c.r<<''<< c.i <<"i)n";
} 假设complex的结构声明包含在complex. h头文件中，testl l将产生如下输出:　　 c=(-1-2i)
　　 '++'和'--'亦可进行重载:
　　 complex operator++(complex& c);
　　 complex operator-一(complex& c);
　　 complex c;
　　 c++;
　　 --c;
　　 ‘++’和’--’是一对怪东西，它们既可以作前缀，又可以作后缀。不过，以下形式的定义只适用于‘++’和’--’的后缀用法:
　　 complex operator++(complex&c int);
　　 complex operator--(complex&c int);
　　 complex c;
　　 c++;//ok
　　 ++c; //error. Illegal structure operation
　　 c++(0); //error: Call of nonfunction
　　 注意:其中操作int参数仅作为标志使用，而无其它含义。
　　 (2)双目操作符的重载

　　 设@为一个双目操作符，x@ y被解释成:
　　 operator@(x y)
　　 例如语句z=x+y;被译为z=operator+(x y);
　　 毋需多言，前面的complex operator + (complex c1 complex c2)就是个很好的例子。
　　 (3)new delete的重载
　　 new delete也可以被重载(别看它们那样神秘)，它们通常采取的声明形式如下:
　　 void*operator new (size_t size);
　　 void operator delete (void*p);
　　 其中size t是一个与实现有关的unsigned int类型。以下是它们的使用:
　　 int*ip=new int;
　　 delete ip;
　　 当使用new分配一个TYPE类型的对象空间时，sizeof (TYPE)将作为第一参数引起new (size_t)函数的调用，如上new语句将被译作:
　　 ip=operator new (sizeof(int));
　　以下是重载的例子:
　//test12.cpp
#include <alloc.h>
#include <iostream.h>
#include "complex.h"
static void * operator new (size_t size)
{
　　　　　　 cout << size << " byte(s) allocated! n";
　　　　　　 return malloc(size);
}

static void operator delete (void *p)
{
　　　　　　 free(p);
　　　　　　 cout<<"memory block returned! n";
}

void main()
{
　　　　　　 int *ip = new int(10);
　　　　　　 complex *cp = new complex;
　　　　　　 float * fp = new float[10];
　　　　　 delete [] fp;
　　　　　　 delete cp;
　　　　　　 delete ip;
}

4 byte(s) allocated!
8 byte(s) allocated!
40 byte(s) allocated!
memory block returned!
memory block returned!
memory block returned!
　　 在这例子中，malloc（）与free（）被重新拾起，替代了new delete的功能。同时，new （） delete（）函数声明为static类型，以防止它们的重载对其它文件产生副作用。在未重载new、delete之前，系统会使用缺省的那一份new delete版本。
　　 操作符重载是一张最令你自豪的Ace，但必须记住它仍具有以下限制：①操作符重载要求操作对象至少有一个是类对象（类只是结构的一个广义概念）。我曾经做过以下的尝试： 　//error: 'operator+(char*char*)’ must he a member function or have a parameter of class type
char*operator+(char*s1 char* s2)
{
return strcat(sl s2);
}

　　 但后来编译器证明了这种对基本数据类型的多情是愚蠢的。
　　 ②不可以构造新操作符，也不能改变操作符操作参数的数目，不能改变操作符的优先级。
　　 ③操作符的含义应尽量忠实于操作符的原义，这不是一条严格的规则，但是一条很好的忠告。譬如，当你将complex的‘！’操作定义成机器重新启动的代码，虽然C++没有理由阻拦你，但这样不好。


　　 c=(-1-2i)
　　 '++'和'--'亦可进行重载:
　　 complex operator++(complex& c);
　　 complex operator-一(complex& c);
　　 complex c;
　　 c++;
　　 --c;
　　 ‘++’和’--’是一对怪东西，它们既可以作前缀，又可以作后缀。不过，以下形式的定义只适用于‘++’和’--’的后缀用法:
　　 complex operator++(complex&c int);
　　 complex operator--(complex&c int);
　　 complex c;
　　 c++;//ok
　　 ++c; //error. Illegal structure operation
　　 c++(0); //error: Call of nonfunction
　　 注意:其中操作int参数仅作为标志使用，而无其它含义。
　　 (2)双目操作符的重载

　　 设@为一个双目操作符，x@ y被解释成:
　　 operator@(x y)
　　 例如语句z=x+y;被译为z=operator+(x y);
　　 毋需多言，前面的complex operator + (complex c1 complex c2)就是个很好的例子。
　　 (3)new delete的重载
　　 new delete也可以被重载(别看它们那样神秘)，它们通常采取的声明形式如下:
　　 void*operator new (size_t size);
　　 void operator delete (void*p);
　　 其中size t是一个与实现有关的unsigned int类型。以下是它们的使用:
　　 int*ip=new int;
　　 delete ip;
　　 当使用new分配一个TYPE类型的对象空间时，sizeof (TYPE)将作为第一参数引起new (size_t)函数的调用，如上new语句将被译作:
　　 ip=operator new (sizeof(int));
　　以下是重载的例子:
　//test12.cpp
#include <alloc.h>
#include <iostream.h>
#include "complex.h"
static void * operator new (size_t size)
{
　　　　　　 cout << size << " byte(s) allocated! n";
　　　　　　 return malloc(size);
}

static void operator delete (void *p)
{
　　　　　　 free(p);
　　　　　　 cout<<"memory block returned! n";
}

void main()
{
　　　　　　 int *ip = new int(10);
　　　　　　 complex *cp = new complex;
　　　　　　 float * fp = new float[10];
　　　　　 delete [] fp;
　　　　　　 delete cp;
　　　　　　 delete ip;
}

4 byte(s) allocated!
8 byte(s) allocated!
40 byte(s) allocated!
memory block returned!
memory block returned!
memory block returned!
　　 在这例子中，malloc（）与free（）被重新拾起，替代了new delete的功能。同时，new （） delete（）函数声明为static类型，以防止它们的重载对其它文件产生副作用。在未重载new、delete之前，系统会使用缺省的那一份new delete版本。
　　 操作符重载是一张最令你自豪的Ace，但必须记住它仍具有以下限制：①操作符重载要求操作对象至少有一个是类对象（类只是结构的一个广义概念）。我曾经做过以下的尝试： 　//error: 'operator+(char*char*)’ must he a member function or have a parameter of class type
char*operator+(char*s1 char* s2)
{
return strcat(sl s2);
}
　　 但后来编译器证明了这种对基本数据类型的多情是愚蠢的。
　　 ②不可以构造新操作符，也不能改变操作符操作参数的数目，不能改变操作符的优先级。
　　 ③操作符的含义应尽量忠实于操作符的原义，这不是一条严格的规则，但是一条很好的忠告。譬如，当你将complex的‘！’操作定义成机器重新启动的代码，虽然C++没有理由阻拦你，但这样不好。

　　 在调用形式上，函数模板很类似于宏，但它同时具有类型检查。更普遍的，模板也可以应用于类中。
　　 至此，对抗#define之战已快接近尾声，然而这似乎永远不得结束。宏就是宏，它总有它的优点，譬如它可节省对象空间，你无法阻止有些C++用户仍喜爱它。
　　 5.操作符重载（operator overload）
　　 我还要声明的是，前面定义的Add（）函数，特别是为complex定做的那个，仍然是值得鄙弃的。它们虽然都能正常工作，但仍不是C++常用的风格。既然是求和，我们会更倾向于表达方式“complex c = c1 +c2；”而不是“complex c =Add（cl c2）；”。
　　 操作符‘+’的使用要比Add （ ）函数的调用让人舒服得多。C++中你完全可以摒弃所谓的“模板重置”，而直接对操作符‘+’进行重载： 　complex operator+(complex c1 complex c2)
{
complex c;
c.r=cl.r+c2. r;
c. i=cl.i+c2. i;
}
　　 这样当出现。c1+ c2的形式时，表达式就会被赋予正当的含义。以下分述一些常见操作符的重载：（1）单目操作符的重载：设@为一个单目运算符，则@x和x@都被解释成operator @（x）。
　　 瞧，这不就是函数调用的形式了吗？其中operator是C++的关键字。例如语句y=——x；将被译作y = operator——（x）；下面是一个求复数相反数的例子： 　//test11. cpp
#include <iostream.h>
#include "complex.h"
complex operator - (complex c)
{
　　　　　　 c.r = -c.r;
　　　　　　 c.i = -c.i;
　　　　　　 return c;
}
void main()
{
　　　　　　 complex c={1.0 2.0};
　　　　　　 c= -c;
　　　　　　 cout<<"c=(" <<c.r<<''<< c.i <<"i)n";
} 假设complex的结构声明包含在complex. h头文件中，testl l将产生如下输出:　　 c=(-1-2i)
　　 '++'和'--'亦可进行重载:
　　 complex operator++(complex& c);
　　 complex operator-一(complex& c);
　　 complex c;
　　 c++;
　　 --c;
　　 ‘++’和’--’是一对怪东西，它们既可以作前缀，又可以作后缀。不过，以下形式的定义只适用于‘++’和’--’的后缀用法:
　　 complex operator++(complex&c int);
　　 complex operator--(complex&c int);
　　 complex c;
　　 c++;//ok
　　 ++c; //error. Illegal structure operation
　　 c++(0); //error: Call of nonfunction
　　 注意:其中操作int参数仅作为标志使用，而无其它含义。
　　 (2)双目操作符的重载

　　 设@为一个双目操作符，x@ y被解释成:
　　 operator@(x y)
　　 例如语句z=x+y;被译为z=operator+(x y);
　　 毋需多言，前面的complex operator + (complex c1 complex c2)就是个很好的例子。
　　 (3)new delete的重载
　　 new delete也可以被重载(别看它们那样神秘)，它们通常采取的声明形式如下:
　　 void*operator new (size_t size);
　　 void operator delete (void*p);
　　 其中size t是一个与实现有关的unsigned int类型。以下是它们的使用:
　　 int*ip=new int;
　　 delete ip;
　　 当使用new分配一个TYPE类型的对象空间时，sizeof (TYPE)将作为第一参数引起new (size_t)函数的调用，如上new语句将被译作:
　　 ip=operator new (sizeof(int));
　　以下是重载的例子:
　//test12.cpp
#include <alloc.h>
#include <iostream.h>
#include "complex.h"
static void * operator new (size_t size)
{
　　　　　　 cout << size << " byte(s) allocated! n";
　　　　　　 return malloc(size);
}

static void operator delete (void *p)
{
　　　　　　 free(p);
　　　　　　 cout<<"memory block returned! n";
}

void main()
{
　　　　　　 int *ip = new int(10);
　　　　　　 complex *cp = new complex;
　　　　　　 float * fp = new float[10];
　　　　　 delete [] fp;
　　　　　　 delete cp;
　　　　　　 delete ip;
}

4 byte(s) allocated!
8 byte(s) allocated!
40 byte(s) allocated!
memory block returned!
memory block returned!
memory block returned!
　　 在这例子中，malloc（）与free（）被重新拾起，替代了new delete的功能。同时，new （） delete（）函数声明为static类型，以防止它们的重载对其它文件产生副作用。在未重载new、delete之前，系统会使用缺省的那一份new delete版本。
　　 操作符重载是一张最令你自豪的Ace，但必须记住它仍具有以下限制：①操作符重载要求操作对象至少有一个是类对象（类只是结构的一个广义概念）。我曾经做过以下的尝试： 　//error: 'operator+(char*char*)’ must he a member function or have a parameter of class type
char*operator+(char*s1 char* s2)
{
return strcat(sl s2);
}

　　 但后来编译器证明了这种对基本数据类型的多情是愚蠢的。
　　 ②不可以构造新操作符，也不能改变操作符操作参数的数目，不能改变操作符的优先级。
　　 ③操作符的含义应尽量忠实于操作符的原义，这不是一条严格的规则，但是一条很好的忠告。譬如，当你将complex的‘！’操作定义成机器重新启动的代码，虽然C++没有理由阻拦你，但这样不好。

　　 c=(-1-2i)
　　 '++'和'--'亦可进行重载:
　　 complex operator++(complex& c);
　　 complex operator-一(complex& c);
　　 complex c;
　　 c++;
　　 --c;
　　 ‘++’和’--’是一对怪东西，它们既可以作前缀，又可以作后缀。不过，以下形式的定义只适用于‘++’和’--’的后缀用法:
　　 complex operator++(complex&c int);
　　 complex operator--(complex&c int);
　　 complex c;
　　 c++;//ok
　　 ++c; //error. Illegal structure operation
　　 c++(0); //error: Call of nonfunction
　　 注意:其中操作int参数仅作为标志使用，而无其它含义。
　　 (2)双目操作符的重载

　　 设@为一个双目操作符，x@ y被解释成:
　　 operator@(x y)
　　 例如语句z=x+y;被译为z=operator+(x y);
　　 毋需多言，前面的complex operator + (complex c1 complex c2)就是个很好的例子。
　　 (3)new delete的重载
　　 new delete也可以被重载(别看它们那样神秘)，它们通常采取的声明形式如下:
　　 void*operator new (size_t size);
　　 void operator delete (void*p);
　　 其中size t是一个与实现有关的unsigned int类型。以下是它们的使用:
　　 int*ip=new int;
　　 delete ip;
　　 当使用new分配一个TYPE类型的对象空间时，sizeof (TYPE)将作为第一参数引起new (size_t)函数的调用，如上new语句将被译作:
　　 ip=operator new (sizeof(int));
　　以下是重载的例子:
　//test12.cpp
#include <alloc.h>
#include <iostream.h>
#include "complex.h"
static void * operator new (size_t size)
{
　　　　　　 cout << size << " byte(s) allocated! n";
　　　　　　 return malloc(size);
}

static void operator delete (void *p)
{
　　　　　　 free(p);
　　　　　　 cout<<"memory block returned! n";
}

void main()
{
　　　　　　 int *ip = new int(10);
　　　　　　 complex *cp = new complex;
　　　　　　 float * fp = new float[10];
　　　　　 delete [] fp;
　　　　　　 delete cp;
　　　　　　 delete ip;
}

4 byte(s) allocated!
8 byte(s) allocated!
40 byte(s) allocated!
memory block returned!
memory block returned!
memory block returned!
　　 在这例子中，malloc（）与free（）被重新拾起，替代了new delete的功能。同时，new （） delete（）函数声明为static类型，以防止它们的重载对其它文件产生副作用。在未重载new、delete之前，系统会使用缺省的那一份new delete版本。
　　 操作符重载是一张最令你自豪的Ace，但必须记住它仍具有以下限制：①操作符重载要求操作对象至少有一个是类对象（类只是结构的一个广义概念）。我曾经做过以下的尝试： 　//error: 'operator+(char*char*)’ must he a member function or have a parameter of class type
char*operator+(char*s1 char* s2)
{
return strcat(sl s2);
}
　　 但后来编译器证明了这种对基本数据类型的多情是愚蠢的。
　　 ②不可以构造新操作符，也不能改变操作符操作参数的数目，不能改变操作符的优先级。
　　 ③操作符的含义应尽量忠实于操作符的原义，这不是一条严格的规则，但是一条很好的忠告。譬如，当你将complex的‘！’操作定义成机器重新启动的代码，虽然C++没有理由阻拦你，但这样不好。