C++运算符重载 - “重新创建 Vector”

Question

我目前正在学习拼贴二级编程课程...我们正在研究运算符重载...为此，我们将重建向量类... 我正在构建该类，发现它的大部分都是基于 [] 运算符。当我尝试实现 + 运算符时，我遇到了一个奇怪的错误，这是我的教授以前从未见过的（显然是因为课程将 IDE 从 MinGW 切换到 VS Express...）（我正在使用 Visual Studio Express 2008 C++ 版...)

Vector.h

#include <string>
#include <iostream>
using namespace std;

#ifndef _VECTOR_H
#define _VECTOR_H

const int DEFAULT_VECTOR_SIZE = 5;

class Vector
{
private:
    int *   data;
    int     size;
    int     comp;
public:
    inline  Vector      (int Comp = 5,int Size = 0) 
        : comp(Comp), size(Size)    { if (comp > 0) { data = new int [comp]; } 
                                      else { data = new int [DEFAULT_VECTOR_SIZE];
                                      comp = DEFAULT_VECTOR_SIZE; }
                                    }
    int      size_      ()          const       { return size; }
    int      comp_      ()          const       { return comp; }
    bool     push_back  (int);
    bool     push_front (int);
    void     expand     ();
    void     expand     (int);
    void     clear      ();
    const    string at  (int);
    int&         operator[ ](int);
    int&         operator[ ](int) const;
    Vector&  operator+  (Vector&);
    Vector&  operator-  (const Vector&);
    bool     operator== (const Vector&);
    bool     operator!= (const Vector&);

    ~Vector() { delete [] data; }
};

ostream& operator<< (ostream&, const Vector&);

#endif

Vector.cpp

#include <iostream>
#include <string>
#include "Vector.h"
using namespace std;

const string Vector::at(int i) {
    this[i];
}

void Vector::expand() {
    expand(size);
}

void Vector::expand(int n ) {
    int * newdata = new int [comp * 2];
    if (*data != NULL) {
        for (int i = 0; i <= (comp); i++) {
            newdata[i] = data[i];
        }
        newdata -= comp;
        comp += n;
        data = newdata;
    delete newdata;
    }
    else if ( *data == NULL || comp == 0) {
        data = new int [DEFAULT_VECTOR_SIZE];
        comp = DEFAULT_VECTOR_SIZE;
        size = 0;
    }
}

bool Vector::push_back(int n) {
    if (comp = 0) { expand(); }
    for (int k = 0; k != 2; k++) {
        if ( size != comp ){
            data[size] = n;
            size++;
            return true;
        }
        else {
            expand();
        }
    }
    return false;
}

void Vector::clear() {
    delete [] data;
    comp = 0;
    size = 0;
}
int& Vector::operator[] (int place) { return (data[place]); }
int& Vector::operator[] (int place) const { return (data[place]); }

Vector& Vector::operator+ (Vector& n) {
    int temp_int = 0;

    if (size > n.size_() || size == n.size_()) { temp_int = size; }
    else if (size < n.size_()) { temp_int = n.size_();  }

    Vector newone(temp_int);
    int temp_2_int = 0;

    for ( int j = 0; j <= temp_int && 
                     j <= n.size_() && 
                     j <= size; 
                                        j++) {
        temp_2_int = n[j] + data[j];
        newone[j] = temp_2_int;
    }
////////////////////////////////////////////////////////////
    return newone;
////////////////////////////////////////////////////////////
}

ostream& operator<< (ostream& out, const Vector& n) {
    for (int i = 0; i <= n.size_(); i++) {
////////////////////////////////////////////////////////////
        out << n[i] << " ";
////////////////////////////////////////////////////////////
    }
    return out;
}

错误：

out << n[i] << " "; error C2678:

二进制“[”：找不到哪个运算符 接受类型的左操作数 'const Vector'（或者没有 可接受的转换）

return newone;

错误 C2106: '=' : left 操作数必须是左值

---

如上所述，我是一名学生，正在选择计算机科学作为我选择的专业，我希望得到提示、指示和更好的方法：D

Answer 1

this:

int operator[ ](int);

是一个非常量成员函数。这意味着不能在 const Vector 上调用它。

通常，下标运算符的实现方式是返回一个引用（如果您返回一个值，就像您所做的那样，则不能将其用作左值，例如您不能执行 newone[j] = temp_2_int ; 就像您在代码中一样）：

int& operator[](int);

为了能够在 const 对象上调用它，您还应该提供成员函数的 const 版本：

const int& operator[](int) const;

既然您要求“提示、指针和更好的方法做一些事情：”

• 你不能命名你的包含守卫_VECTOR_H。以下划线开头，后跟大写字母的名称保留用于实现。 很多关于下划线的规则。
• 您不应该在标头中使用using namespace std。
• 您的 operator+ 应该采用 const Vector& 因为它不会修改其参数。
• 您的 at 应该返回一个 int 并且应该匹配 C++ 标准库容器的语义（即，如果 i 超出，它应该抛出异常您需要使用 (*this)[i] 来调用重载的 operator[]
• 您需要了解 * 的内容 。在一些地方，您混淆了指针和它们指向的对象，
• 请注意混淆 = 和 == （例如，在 if (comp. 编译器将对此发出警告。
• = 0))。如果您保证 data 永远不会出现，那么 无效的。

Answer 2

无法将其纳入对尼尔答案的评论中，所以我必须在这里详细说明。

关于您的 expand() 函数。看起来这个函数的工作是通过 n 个元素扩展具有 comp 元素的内部存储，同时保持 Vector 的 size 。那么让我们来看看您拥有的内容。

void Vector::expand(int n) {
    int * newdata = new int [comp * 2];

好的，您刚刚创建了一个新数组，其大小是旧数组的两倍。错误：为什么新的尺寸与n没有任何关系？

    if (*data != NULL) {

错误：*data 是数组中的第一个 int 元素。它不是一个指针。为什么将其与NULL进行比较？

概念错误：即使您说 if (data != NULL)，这可能是一个测试，看看是否存在数组，但 data 在什么时间点 曾经设置为NULL吗？如果内存不足，new [] 不会返回 NULL；它抛出异常。

        for (int i = 0; i <= (comp); i++) {
            newdata[i] = data[i];
        }

警告：您正在复制整个数组，但只有前 size 元素有效。循环可以运行到 size 就可以了。

        newdata -= comp;

错误：指针数学错误。 newdata 设置为一个指针，指向谁知道 (comp int 从 newdata 的开头返回的位置？！ ），而且几乎可以肯定的是，如果给delete []一个指针，它会破坏内存。

        comp += n;

这很好，就其本身而言。

        data = newdata;
        delete newdata;
    }

错误：您存储了一个指针，然后立即删除了它的内存，使其成为无效指针。

    else if ( *data == NULL || comp == 0) {
        data = new int [DEFAULT_VECTOR_SIZE];
        comp = DEFAULT_VECTOR_SIZE;
        size = 0;
    }
}

错误：这应该在您的构造函数中，而不是在这里。同样，没有任何东西将 data 设置为 NULL，并且 *data 是一个 int，而不是指针。

这个函数应该做什么：

• 创建一个由 comp + n 元素组成的新数组
• ，将 size 元素从旧数组复制到新数组，
• 删除旧数组array
• 设置data 指向新数组

祝你好运。

Answer 3

除了其他人已经写过的关于您的 operator[]() 的内容之外：

您的 operator+() 采用每个非 const 引用的右侧——就好像它会试图改变它一样。然而，对于 A+B，每个人都希望 B 保持不变。

此外，我将实现所有二元运算符，将其操作数同等对待（即，不更改其中任何一个）作为非成员函数。作为成员函数，左侧 (this) 可以进行不同的处理。 （例如，它可能会受到派生类中的覆盖版本的影响。）

然后，IME 将 operator+() 基于 operator+=() 总是好的。 operator+=() 不会平等地对待其操作数（它会更改其左边的操作数），因此最好将其作为成员函数来完成。完成此操作后，在其之上实现 operator+() 就是小菜一碟了。

最后，operator+() 永远不应该返回对对象的引用。当您说 A+B 时，您希望返回一个新对象，而不是更改某些现有对象并返回对该对象的引用。

Answer 4

您的代码中有太多错误，以至于很难知道从哪里开始。其一：

 delete [] data;
 *data = *newdata;

删除一个指针，然后立即取消引用它。

并且：（

const string Vector::at(int i) {
    this[i];
}

我认为）这是一个整数向量。为什么这会返回一个字符串？对此应用 [] 运算符不会调用您的运算符 [] 重载 - 它将其视为数组，但事实并非如此。

Answer 5

您需要提供两个版本的运算符[]。对于访问：

T operator[](std::size_t idx)const;

对于写入元素：

T& operator[](std::size_t idx);

在上述两个例子中，将 T 替换为元素的类型。出现此问题的原因是，只有标记为“const”的函数才能在声明为“const”的对象上调用。将所有非变异函数标记为“const”绝对是您应该做的事情，称为“const 正确性”。由于返回对元素的引用（写入所必需的）允许底层对象发生变化，因此该版本的函数不能设为“const”。因此，需要一个只读的“const”重载。

您可能还有兴趣阅读：

• C++ FAQ Lite 中的常量正确性< /a>
• C++ 中的常量正确性

Answer 6

int Vector::operator[] (int place) { return (data[place]); }

这样

int Vector::operator[] (int place) const { return (data[place]); }

您就可以对 const 向量执行 [] 操作。函数声明后的 const 表示类实例 (this) 被视为 const Vector，这意味着您将无法修改正常属性。或者换句话说：仅具有对属性的读取访问权限的方法。