指针操作符重载时为什么不用返回类型啊？

#include
#include
using namespace std;

template
class Array {
private:
T * list ; //数组指针
int size ; //数组长度
public:
Array(int size) ;//构造函数
Array (const Array< T> &a ) ;//赋值构造函数
Array(){}//构造函数
~Array(){}//析构函数
int getSize()const; //获得数组大小
void reSize(int i) ; //修改数组大小
T & operator [] (int i) const; // []的重载
Array & operator = (const Array &a ) ;// '='号的重载
operator T *();
operator const T *()const ;
};
//构造函数
template
Array::Array(int size) {
assert (size >= 0);
this->size =size ;
list =new T [size] ;
}
//（深）复制构造函数
template
Array::Array (const Array &a ){
size =a.size ;
list = new T(size) ;
for(int i=0;i list[i] =a.list[i] ;
}
//获得数组大小
template
int Array::getSize()const{

return this->size ;
}
//修改数组大小
template
void Array::reSize(int i ){
assert (i>=0) ;
if(i ==size)
return ;
T * newList =new T[size];
int n =(i
for(int i=0;i newList[i] =list[i] ;
delete[] list ;
list =newList ;
size =i ;
}

//对操作符[]的重载
template
T & Array::operator [] (int i)const{
assert(0<=i &&i<=size);
return list[i];
}
//对操作符 =的重载
template
Array & Array::operator =(const Array &a ){
if(&a != this){
if(size delete[] list;
size =a.size ;
list =new T[size];
for(int i=0;i list[i] =a.list[i] ;
}

else {
for(int i=0;i list[i] =a.list[i] ;
}

}

}
//重载指针转换运算符 让Array类的对象名转换成T指针类型的指针
template //就是这里有问题 为什么函数没有返回类型呢
Array::operator T*(){//就是这里有问题 为什么函数没有返回类型呢
return list ;//就是这里有问题 为什么函数没有返回类型呢
}
template
Array::operator const T*()const{
return list ;
}


void main (){
Arraya(10);
cout< a[0] =0;
a[1]=1;
cout<<*a< cout<<*(a+1)<}
写了一个类似于vector数组的模版

你没有重载指针操作符，指针操作符是箭头，也就是这个：->
重载指针运算符的写法是：
return_type operator->(parameter_type param) { ... }
可见，是需要返回值的。

而你在这里写的operator T *(); 不是操作符的重载，而是一个隐式转换的函数，从Array类转到T*
这个转换允许你写出这样的代码：
int *i = a;

同样，也不要认为你重载了星号运算符，星号运算符的写法是：
return_type operator* (param_type);
你之所以可以写*a是因为Array类存在到int*的隐式转换，而int*是可以用星号运算符的

其实指针和引用在编译实现没有区别 主要引用是c++特性，c++更喜欢用引用 而且不用写那么麻烦（不用写例如*这些符号，用起来更方便

如以上回答内容为低俗、色情、不良、暴力、侵权、涉及违法等信息，可以点下面链接进行举报！

点此我要举报以上问答信息