C＋＋库研究笔记——操作符重载实现类型转换＆这样做的意义

目标：

已知这个接口：

std::vector<double> add_vec(double *d1, double *d2)
{
.....
return result;
}

我们自定义了这个类：

class array
{
int size_;
double *data_;
....
};

要求实现：

array v1(10), v2(10);
add_vec(v1, v2);

留意到，当array 类型传入add_vec时，会遇到(double*) 类型的“试探性”强制转换， 所以，我们只要做一个从array到，(double*)的类型转换即可。

这样做的好处：

• 1.有了类型转换，我们不需要再写这样一个多态函数实现array 与array的相加

std::vector<double> add_vec(array d1, array d2)
{
.....
return result;
}

• 2.以下的接口：

std::vector<double> add_vec(double* d1, double* d2)

可能重写起来非常麻烦，甚至add_vec(double*, double*) 是别人封装好的，我们看不到源代码，此时更谈不上重写

实现方法及测试代码：（直接在这个代码上增加，所以代码有些乱）

C++类型转换操作符（type conversion operator）

#include <iostream>

 class D {
 public:
    D(double d) : d_(d) {
        data_=new double[10];
        for(int i=0; i<10; i++)
            data_[i]=d;
    }

    ~D()    {   delete []data_;   }

    /* “(int)D”类型转换 */
    operator int() const {
        std::cout << "(int)d called!" << std::endl;
        return static_cast<int>(d_);
    }

    // for: double me=    *d1;      //ok
    double& operator*(void) {
        return *data_;
    }

    // for: double *me2= (double*)d1;
    operator double*(void){
        return data_;
    }


 private:
    double d_;
    double *data_;
};

 int add(int a, int b) {
    return a + b;
}

#include <vector>
std::vector<double> add_vec(double* d1, double* d2)
{
    std::vector<double> r(10);
    for(int i=0; i<10; i++){
        r[i]=d1[i]+d2[i];
    }
        
    return r;
}


 int main() {
    D d1 = 1.1;
    D d2 = 2.2;
    std::cout << add(d1, d2) << std::endl;

    double me=    *d1;      //ok
    std::cout<<"me:"<<me<<std::endl;
    double *me2= (double*)d1;   // ok

    std::vector<double> r;
    r=add_vec(d1, d2);
    for(int i=0; i<r.size(); i++){
        std::cout<<r[i]<<" "<<std::endl;
    }


    //std::cout << add_vec(d1, d2) << std::endl;

    return 0;
}

输出：

(int)d called!
(int)d called!
3
me:1.1
3.3 
3.3 
3.3 
3.3 
3.3 
3.3 
3.3 
3.3 
3.3 
3.3 

补充：

注意到：

    double me=    *d1;     
    double *me= (double*)d1;   

第二个的意义为把 D类型当成一个指针, 然后把把指针（即地址）赋值给me

第一个意义为：把D类型先假设指针，然后把指针指向的值转给me

二者等价，所以，可删除其中一个冗余定义，经过测试，代码仍能正常运行

    // for: double *me2= (double*)d1;
    operator double*(void){
        return data_;
    }

但是如果：

    // for: double me=    *d1;      //ok
    double& operator*(void) {
        return *data_;
    }

则会报错：

Press ENTER or type command to continue
main.cpp: In function ‘int main()’:
main.cpp:62:27: error: invalid cast from type ‘D’ to type ‘double*’
main.cpp:63:18: error: invalid conversion from ‘int’ to ‘double*’ [-fpermissive]
main.cpp:69:21: error: invalid conversion from ‘int’ to ‘double*’ [-fpermissive]
main.cpp:44:21: error:   initializing argument 1 of ‘std::vector<double> add_vec(double*, double*)’ [-fpermissive]
main.cpp:69:21: error: invalid conversion from ‘int’ to ‘double*’ [-fpermissive]
main.cpp:44:21: error:   initializing argument 2 of ‘std::vector<double> add_vec(double*, double*)’ [-fpermissive]

仔细理解，编译器这样做是有道理的，因为第一个重载只是第一个的特殊情况，不能包括第一个，而第二个重载却能包含第一个

更多参见：

Can a cast operator be explicit?

How do conversion operators work in C++?