C++로 동시에 =과 [] 연산자를 오버로드 할 수 있습니다

Question

여기서 [] 및 = 연산자를 오버로드하여 삽입 기능을 없애고 싶습니다. [] 연산자를 오버로드하여 값을 삽입 할 위치의 주소를 성공적으로 반환했습니다. 하지 않습니다, 원래의 코드가 변경하더라도, 배열 요소에 대한 포인터를 반환에서

int& operator[](int at) 

:

#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

대입 연산자 '='를 용도에 맞게 사용할 필요가 없습니다. 액세스 연산자 '[]'만 오버로드하십시오. 의 모양은 그 : 당신에게 returntype의 인스턴스에 대한 참조를 줄 것 때문에 당신이 늘 귀하의 경우 귀하의 returntype의의 할당 연산자를 오버로드 할 필요가있다

returntype& operator [](int indexvariable); 

.

은 그럼 당신은 쓸 수 있습니다 :

는

arr[5] = 23; 

Answer 2

당신은 당신의 operator[]의 반환 형식을 변경하여 원하는 동작을 얻을 수 있습니다 배열에 저장된 값을 가진 모든 것. 원래 코드를 사용하면 요소의 값을 변경하기 위해 다음과 같이 작성할 수 있습니다.

잘 보이지 않는 것처럼 보입니다.

포인터 대신 참조를 반환하면 참조하는 값을 직접 변경할 수 있습니다.

Answer 3

당신은 약간의 속임수와 거의 모든 것이 동작을 얻을 수 있습니다.
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 4

덧글 OP를 akexeykuzmin0's response으로 남겨두고 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"; 
} 

출력

g++ -std=c++17 -O2 -Wall -Werror main.cpp && ./a.out 
0x7ffd682844f0 
42 
42 

0x7ffd682844f0 
137 
137 

0x7ffd682844f0 
0 
0 

Live demo on coliru

이 핸들러는 암시 int*로 변환 할 수 있으며 수는에 operator= 과부하.