网站建设| 数据库类| 图形图象| 程序设计| 现代办公| 操作系统| 考试认证| 网络技术| 软件工程| 电脑相关| 文学作品
网站开发| 网页制作| 操作系统| 图象图形| 考试认证| 数据库类| 程序设计| 硬件技术| 现代办公| 网络技术| 笑话频道
 
您的位置: 电脑书库首页-> 电脑文摘-> 程序设计-> C/C++/VC-> 轻轻松松C to C++ (三)

轻轻松松C to C++ (三)
作者:佚名 来源:InterNet 加入时间:2005-1-28
相关文章
  • 轻轻松松C to C++ (二)
  • 轻轻松松C to 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++没有理由阻拦你,但这样不好。

    [文章录入员:nancy]

    相关文章
  • 轻轻松松C to C++ (二)
  • 轻轻松松C to C++(一)
  • 相关书籍:
    本站推荐内容

    近期主机类热搜关键词:
    美国服务器 美国服务器租用 海外服务器租用 国外服务器租用

    C/C++/VC
    C/C++/VC
    C++Builder
    Basic/VB类
    Delphi/Pascal
    Java编程
    FORTRAN
    其它
    电脑教程阅读排行
    ·新手入门:c++经典
    ·VC开发实例
    ·ping的源程序
    ·Visual C++编程技巧之一
    ·Visual C++程序设计中的...
    ·Windows 中不规则窗体的编...
    ·扔掉Socket实现网络编程
    ·例解用 VC++ 6.0 实现 ...
    ·VC实现PC并行端口数字信息输入...
    ·轻轻松松C to C++(一)