Question

这里我想通过重载[]和=运算符来摆脱插入函数。通过重载[]运算符，我已经成功返回了我想要插入值的所需位置的地址。

#include<iostream>
using namespace std;

#define const maxSize = 30;

class ARRAY
{
private:
    int *ar;
    int end;
public:
    ARRAY()
    {
        ar = new int[40];
        end = -1;
    }

    void insert(int value)
    {
        end += 1;
        ar[end] = value;
    }

    void insert(int value, int index)
    {
        if (index<30 && index >-1)
        {
            int tempEnd = end;
            for (int i = end; i >= index; --i)
            {
                ar[tempEnd + 1] = ar[tempEnd];
                tempEnd -= 1;
            }
            end += 1;
            ar[index] = value;

        }
        else
            cout << "\nOVERFLOW";
    }

    void remove(int index)
    {
        if (index >= 0 && index <= end)
        {
            for (int i = index; i < end; ++i){

                ar[i] = ar[i + 1];
            }
            end -= 1;
            //do something
        }
        else
            cout << "\nNothing gonna happens";
    }

    void display()
    {
        for (int i = 0; i <=end; ++i)
            cout << "\n" << ar[i];
    }

    int* operator[](int at)
    {
        if (at < 40){
            end++;
            return (&ar[at]);

        }
    }

    //Here I want to do = operator overloading, How can I do this?
};

int main()
{
    ARRAY arr;
    arr.insert(1);
    arr.insert(2);
    arr.insert(3);
    arr.insert(4);
    arr.insert(5);
    arr[5] = 10;
    arr.display();
    return 0;
}

Answer 1

您可以通过更改operator[]的返回类型来实现理想的行为：

int& operator[](int at)

在原始代码中，它返回指向数组元素的指针，即使更改了数组元素，也不会对存储在数组中的值执行任何操作。使用原始代码，您可以编写类似这样的内容来更改元素的值：

*(arr[5]) = 10;

看起来并不明显。

如果返回引用而不是指针，则可以直接更改它引用的值。

Answer 2

你可以通过一些诡计来实现任何理想的行为在你的情况下，如果你想要operator=的一些特定动作（例如检查边界和插入一个新元素），你可以引入一个辅助类，它将保存对数组和索引的引用，然后重载该课程的operator=：

class ArrayIndex
{
  ARRAY& array;
  int index;
public:
  ArrayIndex(ARRAY& a, int i) : array(a), index(i) {}
  void operator=(int value)
   { array.insert(value,index); }
};

当然，您调整了ARRAY operator[]以返回ArrayIndex对象。

如果您不想要插入或执行任何异常操作，并且只想访问这些元素，则operator[]返回引用（int&）就足够了。

Answer 3

您不需要为您的目的重叠赋值运算符'='。仅重载访问运算符'[]'。这应该是这样的：

returntype& operator [](int indexvariable);

这将为您提供一个返回类型的实例的引用，因此您不需要在您的情况下重载您的返回类型的赋值运算符。

然后你可以写：

arr[5] = 23;

Answer 4

在akexeykuzmin0's response上留下评论OP后，我建议您更改open(_:options:completionHandler:)以向您的元素返回处理程序。

operator[]

<强>输出

#include <iostream>
struct ARRAY
{
    struct Handler
    {
        int* _ptr;
        Handler(int* ptr) : _ptr(ptr) {}
        int& operator*() { return *_ptr; }
        operator int*() { return _ptr; }
        int& operator=(int const& value) { *_ptr = value; return **this; }
    };

    int _value;
    ARRAY(int n) : _value(n) {}
    Handler operator[](size_t) { return Handler(&_value); }
};

int main() {
    ARRAY arr(42);
    std::cout
        << std::hex << &arr._value << "\n"
        << std::dec << arr._value << "\n"
        << *arr[0] << "\n\n";

    arr[0] = 137;
    std::cout
        << std::hex << &arr._value << "\n"
        << std::dec << arr._value << "\n"
        << *arr[0] << "\n\n";

    int* pvalue = arr[0];
    *pvalue = 0;
    std::cout
        << std::hex << &arr._value << "\n"
        << std::dec << arr._value << "\n"
        << *arr[0] << "\n\n";
}

Live demo on coliru

此处理程序可以隐式转换为g++ -std=c++17 -O2 -Wall -Werror main.cpp && ./a.out 0x7ffd682844f0 42 42 0x7ffd682844f0 137 137 0x7ffd682844f0 0 0，并且可以重载int*上的operator=。

如何在c ++中同时重载=和[]运算符

4 个答案: