같은 클래스에서 할당으로 역 참조로 = 연산자를 오버로드 할 수 있습니까?

Question

Null 값이나 파생 된 자식을 가리키는 개체 포인터 격자가있는 프로그램에서 작업하고 있습니다. 이 그리드의 값을 파생 된 자식의 주소로 설정하여 아이를 그리드에 "배치"하고 메모리의 위치를 ​​통해 자식에 액세스 할 수 있기를 원합니다.

그리드에 대해 인터페이스가 보이는 부분이 있습니다.

class Grid{ 

public: 
    virtual int get(g_type) const; 

public: 

    parent* operator() (int,int); 

    Grid() : _amtCol(10),_amtRow(10) 
    {construct();} 

    ~Grid() {deconstruct();} 

private: 
    int _amtCol; 
    int _amtRow; 
    parent* **_grid; 

private: 
    parent ***meddle(access); 
    void meddle(access, parent***); 
    virtual void construct(); 
    virtual void deconstruct(); 
}; 

Heres() 오버로드는 다음과 같습니다.

Grid b; 
Child c; 
Child c2; 

b(1,1) = &c; 
b(1,4) = &c2; 

b(1,1)->foo(); //calls the first Childs foo() 
b(1,4)->foo(); //calls the second Childs foo() 

만들어 내 수업의 나머지를 상속 구조의 이동으로까지 작동 :

parent* Grid::operator() (int i,int j){ 

    if(i < get(r_QTY) && j < get(c_QTY)){ 

     return this->meddle(key)[i+1][j+1]; 

    }else{return NULL;} 
} 

은 내가 할 수 있기를 원하는 것은으로 내 프로그램의 나머지 부분에서이 전화입니다.

과부하 등이 작동하는 방식이 있습니까?

아마도 부모님과 자녀 반에서 내 과제 오버로드를 철저히해야한다고 생각했지만 훌륭하게 작동하는 것 같습니다.

///////////////////////////////////////////////////////////////////////////// ///////

제쳐두고,이 구현해야합니까 :

않습니다

void Grid::operator() (int i,int j,parent &cpy){ 
    if(i < get(r_QTY) && j < get(c_QTY)){ 
     this->meddle(key)[i+1][j+1] = &cpy; 
    } 
} 

이 기능을 할 수 있습니다.

내 논문이 있습니다! 감사!

//////////// 빠른 추가 : 따라서 아마도 이것이 도덕적으로나 윤리적으로 올바른지 반드시 알 필요는 없습니다. 작동하는 기능을 구현할 수있는 방법이 있습니다. 라이브러리에 이미있는 것을 사용하는 것이 내 창조물보다 선호된다는 것을 이해하지만, 예를 들어 std :: vector를 사용하면 할 수 있다는 사실은 가능하다는 것을 이해합니다. 어떻게 이것이 가능하게되었는지 궁금하다. 그리고 언어의 구문에 그것이 존재하는 곳이 궁금하다.

Answer 1

은 귀하의 질문에 정확히 확신하지,하지만 당신은 같은 것을 할 수 있습니다 : 당신이 다음

struct parent 
{ 
    virtual ~parent() = default; 
    virtual void foo() = 0; 
}; 

struct Child : parent 
{ 
    Child(int n) : n(n) {} 
    void foo() override { std::cout << n << std::endl;} 
    int n; 
}; 

class Grid{ 
public: 
    Grid() : col(10), row(10), grid(col * row, nullptr) {} 

    parent* operator() (std::size_t x, std::size_t y) const { 
     if (col <= x || row <= y) { throw std::runtime_error("Invalid arguments"); } 
     return grid[y * col + x]; 
    } 

    parent*& operator() (std::size_t x, std::size_t y) { 
     if (col <= x || row <= y) { throw std::runtime_error("Invalid arguments"); } 
     return grid[y * col + x]; 
    } 

private: 
    int col; 
    int row; 
    std::vector<parent*> grid; 
}; 

그리고 :

Grid b; 
Child c(1); 
Child c2(2); 

b(1,1) = &c; 
b(1,4) = &c2; 

b(1,1)->foo(); //calls the first Childs foo() 
b(1,4)->foo(); //calls the second Childs foo() 

Demo