0

我对 C++ 中的运算符重载有疑问。

我定义了以下类：

template <class T>
class Array
{
public:
//! Default constructor
Array(int ArraySize = 10);

////! Defualt destructor
Array<T>::~Array();

//! Redefinition of the subscript operator
T& Array<T>::operator[] (int index);

//! Redefinition of the assignment operator
const Array<T>& Array<T>::operator=(const Array<T>&);

//! Redefinition of the unary operator -
Array<T>& operator-(Array<T>& a);

//! Array length
int size;

private:
//! Array pointer
T *ptr;
};

一元运算符 - 定义如下：

//! Redefinition of the unary operator -
template<class T> 
 Array<T>& operator-(Array<T>& a){
    static Array<T> myNewArray(a.size);

    for( int i = 0; i < a.size; i++){
    myNewArray[i]=-a[i];    
    }
    return myNewArray;
}

如何避免“myNewArray”记忆中的持久性？当函数结束并且像 VectorA=-VectorB 这样的赋值失败时，Whitout“静态”声明 myNewArray 会消失。

第二个问题是关于强制转换运算符的重载；我以这种方式重载了铸造运算符：

//!CASTING
template <class B>
operator Array<B>(){
    static Array<B> myNewArray(size);

.... a function makes the conversion and returns myNewArray populated...

return myNewArray;
}

但它不起作用！在使用静态声明执行函数后，对象 myNewArray 似乎也消失了。任何像 VectorA=(Array<'anytype'>)VectorB 这样的赋值都会失败。

错误在哪里？请大家提出解决方案好吗？先感谢您！

4

3 回答 3

1

对于您的运营商，不要返回参考。返回 myNewArray 的副本。大多数编译器可以省略复制并使用返回值优化来使性能可以接受。

您还应该将这些方法标记为 const，因为它们不会更改状态。

template<class T> 
 Array<T> operator-(const Array<T>& a) {
    Array<T> myNewArray(a.size);

    for( int i = 0; i < a.size; i++){
    myNewArray[i]=-a[i];    
    }
    return myNewArray;
}
于 2012-09-02T22:17:34.690 回答
0

如果没有“静态”声明，myNewArray 会在函数结束时消失，并且任何赋值失败，例如 VectorA=-VectorB。

不，它没有。编译器确保它挂起足够长的时间以被复制。

此外，如果将 myNewArray 初始化为原始的副本，则代码会更简洁：

Array<T> myNewArray(a);
for (int i = 0; i < myNewArray.size(); ++i)
    myNewArray[i] *= -1;
于 2012-09-02T22:17:00.710 回答
-1

嗯，既然这两个问题都涉及到正确分配新值的神秘失败，那么赋值运算符有什么问题吗？

于 2012-09-02T22:21:07.977 回答