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++?