WEB开发网
开发学院软件开发C++ 轻轻松松从C一路走到C++系列文章之三 阅读

轻轻松松从C一路走到C++系列文章之三

 2008-03-08 12:45:41 来源:WEB开发网   
核心提示:4.函数模数(function template) 前面讨论的重载机制用来实现求和操作并不受欢迎,这仿佛还不是C++的风格,轻轻松松从C一路走到C++系列文章之三,例如用户需要求两个其它类型(如字符型)对象的和:Add ('a' ’b’); 它必须再为之预备一个版本,尽管其名字和代码还是那副样子: ch
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版本。

操作符重载是一张

Tags:轻轻松松 一路 列文

编辑录入:爽爽 [复制链接] [打 印]
赞助商链接