关于c ++：是否可以将（）运算符作为取消引用和=运算符作为同一类中的赋值重载？


Is it possible to overload both the () operator as a dereference and the = operator as assignment in same class?

我正在开发一个程序，它有一个指向空值或派生子级的对象指针网格。我希望能够将此网格上的值设置为其派生子节点的地址，这样我就可以将子节点"放置"在网格上，并通过它们在内存中的位置访问子节点。

下面是网格的界面。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
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();
};

这是()重载的样子。

1
2
3
4
5
6
7
8
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;}
}

我想做的是在我的程序的其余部分内将其称为：

1
2
3
4
5
6
7
8
9
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()

其余的类都是创建的，并且工作到继承和结构为止。

有没有一种方法可以链接重载或这样的工作？

我想也许我需要在父母和孩子班上解决我的作业负担过重的问题，但他们似乎工作得很好。

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

除此之外，我已经实现了：

1
2
3
4
5
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，它是可以做到的，这意味着它是可能的。我想知道这是如何实现的，以及它在语言语法中的位置。

相关讨论

不确定你的问题是什么，但是你可以做如下的事情：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
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;
};

然后你有：

1
2
3
4
5
6
7
8
9
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()

演示