C++ C++；操作员过载错误

我正在尝试创建一个名为safearray的数组的我自己的版本，以测试我对操作符重载和创建适当类等方面的知识

我遇到了两个错误

SafeArray.h:11:15:错误：“const int SafeArray:：operator”不能重载

SafeArray.h:10:10:错误：带有“int&SafeArray:：operator”

我的代码分为三个文件

Main.cpp

#include <cstdlib>
#include <iostream>

#include "SafeArray.h"

using namespace std;

int main(int argc, char** argv) {

    SafeArray a(10); // 10 integer elements

    for (int i = 0; i < a.length(); i++) {
        cout << i << " " << a[i] << "s" << endl; // values initialise to 0
    }

    cout << endl << a[1]; // Program exits here.

    a[3] = 42;
    cout << a[3];
    a[10] = 10;
    cout << a[10];
    a[-1] = -1; // out-of-bounds is "safe"?

    SafeArray b(20); // another array

    b = a; // array assignment

    for (int i = 0; i < b.length(); i++) {
        cout << b[i] << endl; // values copied from a
    }

    return 0;
}

SafeArray.cpp

#include "SafeArray.h"
#include <iostream>

SafeArray::SafeArray(int x) {
    length_ = x;
    array = new int[length];
    for (int i = 0; i < length_; i++) {
        array[i] = 0;
    }
}

int SafeArray::length() {
    return this->length_;
}

int SafeArray::boundsCheck(int y) {

}

int& SafeArray::operator[] (int y) {
    return array[y];
}

SafeArray::~SafeArray() { 
    delete [] array;
}

SafeArray::SafeArray(SafeArray const &other) { 
    int *temp = new int[rhs.size_];
    for (int i=0; i<rhs.size_; i++)
        temp[i] = rhs.array[i];
    std::swap(temp, array);
    delete [] temp;
    return *this;
}

#包括“SafeArray.h”
#包括
SafeArray:：SafeArray（int x）{
长度=x；
数组=新整数[长度]；
对于（int i=0；i长度；
}
int SafeArray:：boundsCheck（int y）{
}
int&SafeArray:：运算符[]（int y）{
返回数组[y]；
}
SafeArray:：~SafeArray（）{
删除[]数组；
}
SafeArray:：SafeArray（SafeArray常量和其他）{
int*temp=新int[rhs.size_u2;]；
对于（int i＝0；i您的类定义无效。<代码> int数组[]/Cuth>是不完整的类型，它不应该作为非静态类成员出现。一些编译器将其作为<代码> int数组[0 ] < /C>的同义词，但是零大小数组在C++中也不适用（仅在C99）。< /P>
简言之，您无法以这种方式编写代码。您需要了解动态分配和管理自己的内存。请查看
std:：vector
是如何实现的

在C++11中，我可能建议使用
std:：unique_ptr array
作为一种快速修复方法，将其初始化为
array（新的int[x]）
实际上int array[]是有效的，并且可能会显示为类成员。以下编译符合C++11的严格要求：

class foo 
{
public:
    foo() {}
    int length;
    int A[];
};

void ralph()
{
    foo *bar = (foo *)new int[ 21 ];
    bar->length = 20;
    bar->A[0] = 1;
}

这是合法的，并且有它的优点（偶尔）。尽管它不是常用的

然而，我怀疑OP想要的是更多的东西

class SafeArray {
public:
    SafeArray(int);              // int variable will be the array size
    int length();
    int boundsCheck(int y);       // constructor will call this function

    int& operator[] (int y);
    const int operator [] (const int y) // you need this one too.
private:
    int length_;
    int *array;
};

连同

SafeArray::SafeArray(int x) {
    length_ = x;
    array = new int[length];
    for (int i = 0; i < length_; i++) {
        array[i] = 0;
    }
}

SafeArray:：SafeArray（int x）{
长度=x；
数组=新整数[长度]；
对于（int i=0；i
正如@Kerrek已经指出的，您的类定义显然是错误的（不应该编译）

要解决此问题，您需要将定义更改为以下内容：

int *array;

然后，在默认的ctor中，您可以使用如下内容：

SafeArray::SafeArray(unsigned size = 0) 
    : array(new int[size])
{ 
    for (unsigned i=0; i<size; i++)
        array[i] = 0;
}

除此之外，还需要一个复制构造函数来复制数据：

SafeArray::SafeArray(SafeArray const &other) { 
    int *temp = new int[rhs.size_];
    for (int i=0; i<rhs.size_; i++)
        temp[i] = rhs.array[i];
    std::swap(temp, array);
    delete [] temp;
    return *this;
}

然后意识到，所有这些都是一团乱麻，永远不会真正起作用。特别是，基本方法仅限于大小基本固定的数组。只要只存储
int
s，就很容易忽略问题，并创建一个（某种程度上）动态数组有效。但是，当/如果要存储其他类型时，您只需要将分配内存与初始化内存中的对象分开，这意味着基本上扔掉上面的所有代码，并将其替换为以下内容：

分别跟踪阵列大小和分配大小
使用
：：operator new
、分配器对象或其他类似对象分配内存
在需要时使用“放置新对象”来初始化内存中的对象
使用显式析构函数调用销毁对象
使用
：：operator delete
释放内存
等等。总而言之，
std:：vector
不是一件小事。
错误消息指的是以下两行：

int& operator[] (int y);
const int operator [] (const int y); // you need this one too.

您的错误消息指出，（int y）和（const int y）太类似于[]运算符的两个不同重载。您不能在（int y）和（const int y）上重载，因为调用都是不明确的

如果您的SafeArray是const，您可能打算返回一个const int，但如果您的SafeArray不是const，则返回一个int。在这种情况下，您可以通过将单词const放在参数列表之后来声明要应用于const SafeArray的第二个函数。这是您应该在SafeArray中写入的内容。h:

int& operator[] (int y);
const int operator [] (int y) const; // you need this one too.

然后，您必须在SafeArray.cpp中写入这两个函数：

int& SafeArray::operator[] (int y) {
    return array[y];
}

const int SafeArray::operator[] (int y) const { // you need this one too.
    return array[y];
}

我看不到您动态分配内存的任何地方……因此，几秒钟后我就看到了这一点：
int-array[]；
。您声明了一个大小不完整的数组。也许您的编译器将其理解为
array[0]
，但是零大小的数组不是标准的。然后你继续给这个数组中的
x
元素赋值……它从来没有初始化过。我甚至不知道这是如何编译的。哦，是的，它会编译好的。事实上，这是一个习惯用法，当你想要一个数组但在编译时不知道它的大小时，你就分配它动态地将struct编译为正确的大小，然后您可以使用最大大小的数组。它给您的是数组的数据在struct中，而不是其他位置的单独内存块。还有一定程度的模糊性：-（它不会使用一致的实现编译。gcc包括（至少类似于）C99灵活数组成员作为C++的扩展。我不确定它是否会以迂腐模式来诊断问题，但它至少值得一试。
int& operator[] (int y);
const int operator [] (const int y); // you need this one too.

int& operator[] (int y);
const int operator [] (int y) const; // you need this one too.

int& SafeArray::operator[] (int y) {
    return array[y];
}

const int SafeArray::operator[] (int y) const { // you need this one too.
    return array[y];
}