перегрузка оператора присваивания с оператором индекса

Question

Я перегружен как индекс оператора и операторами присваивания, и я пытаюсь получить правильное значение для оператора присваивания например Array x; x[0]=5; путем перегрузки оператора подстрочного я могу получить значение 0, но когда я перегрузить оператор присваивания это делает назначение, но он не использует мою перегруженную функцию, потому что vaiable 2 должен иметь значение 5.

class Array 
{ 

public: 
    int *ptr; 
    int one,two; 
    Array(int arr[]) 
    { 
     ptr=arr; 
    } 

    int &operator[](int index) 
    { 
     one=index; 
     return ptr[index]; 
    } 
    int & operator=(int x){ 
     two=x; 
     return x; 
    } 
}; 

int main(void) 
{ 
    int y[]={1,2,3,4}; 
    Array x(y); 
    x[1]=5; 
    cout<<x[0]<<endl; 
} 

Answer 1

он не использует свой operator=, потому что вы не назначая к экземпляру Array, вы присваиваете к int , Это будет вызывать ваш оператор:

Array x; 
x = 7; 

Если вы хотите перехватывать задания на то, что operator[] возвращается, его необходимо вернуть объект прокси и определит оператор присваивания для этого прокси. Пример:

class Array 
{ 
    class Proxy 
    { 
    Array &a; 
    int idx; 
    public: 
    Proxy(Array &a, int idx) : a(a), idx(idx) {} 
    int& operator= (int x) { a.two = x; a.ptr[idx] = x; return a.ptr[idx]; } 
    }; 

    Proxy operator[] (int index) { return Proxy(*this, index); } 
}; 

Answer 2

Вы перегружен operator= для Array класса, а не для int (которые вы не можете сделать, кстати). x[1]=5; использует Array::operator[] для доступа к элементу, который возвращает int&, а затем использует обычный оператор назначения int для части =5. Array::operator= используется только тогда, когда вы назначаете весь объект (т. Е. Как вы его определили, вы можете сделать x = 5;), не его элементам/членам.

Answer 3

Что вы хотите сделать operator=? Я хотел бы предложить лучше подпись

Array& operator=(int x) 

и он должен (я) возвращает ссылку на себя *this, и (б) должны сделать лучшую работу по повторной инициализации других значений, то есть он может иметь больше смысла очистите массив или сделайте что-нибудь подобное.

#include <iostream> 

using namespace std; 

class Array 
{ 

public: 

    int *ptr; 
    int one,two; 
    Array(int arr[]) 
    : 
     one(0), two(0) 
    { 
     ptr=arr; 
    } 


    int &operator[](int index) 
    { 
     one=index; 
     return ptr[index]; 
    } 
    Array & operator=(int x){ 
     two=x; 
     return *this; 
    } 
}; 

std::ostream& operator<<(std::ostream& stream, const Array& array) 
{ 
    stream << "(" << array.one << ", " << array.two << ": "; 
    if (array.ptr) 
     stream << *(array.ptr); 
    stream << ")"; 
    return stream; 
} 

int main(void) 
{ 
    int y[]={1,2,3,4}; 
    Array x(y); 
    cout << "Before assigning one element: " << x << endl; 
    x[1]=5; 
    cout << "After assigning one element: " << x << endl; 
    x = 7; 
    cout << "After operator=:    " << x << endl; 
} 

Runnable исходный код по адресу: http://ideone.com/ejefcr

Вот выход. Формат для печати: (one, two, ptr[0]). Я думаю, вы хотите, чтобы переменная-член one была индексом элемента с последним доступом?

Before assigning one element: (0, 0: 1) 
After assigning one element: (1, 0: 1) 
After operator=:    (1, 7: 1) 

Answer 4

Оператор присваивания, который вы написали, применит к массиву, а не к элементу массива. Например,

x = 5; 

будет использовать ваш оператор присваивания. По внешнему виду вы хотите иметь переопределенный оператор присваивания, применяемый при использовании оператора индекса. Единственный способ получить что-то подобное для работы - это использовать прокси-класс:

struct Proxy { 
    Proxy(Array* array, int* element); 
    void operator= (int rhs) { 
     array->two = rhs; 
     *element = rhs; 
    } 
    operator int() const { return *element; } 
}; 
Proxy operator[](int index) 
{ 
    one=index; 
    return Proxy(this, ptr + index); 
}