L-value interpretation of overloading operator() - c++

Question

While studying graph theory, I wanted to try some code, so I came up with this:
class edge
{
public:
edge(char v1, char v2, int wt = INT_MAX) : vertex1(v1), vertex2(v2), weight(wt) {}
edge(const edge& e)
{
this->vertex1 = e.vertex1;
this->vertex2 = e.vertex2;
this->weight = e.weight;
}
edge& operator=(const edge& e)
{
this->weight = e.weight;
return *this;
}
edge& operator=(const int& w)
{
this->weight = w;
return *this;
}
bool operator==(const edge& e) const
{
const auto res = this->weight == e.weight;
return res;
}
bool is_connected() const { return !(weight == INT_MAX); }
char vertex1;
char vertex2;
int weight;
};
And corresponding graph class:
class graph
{
public:
edge operator ()(const char &i, const char &j) const; // #1
edge& operator ()(const char &i, const char &j); // #2
// More implementations...
private:
std::vector<char> vertices;
std::vector<edge> edges;
};
This allows me to write code like this:
graph g;
g('a', 'b') = 1;
g('a', 'f') = 2;
g('a', 'b') = g('a', 'f'); // #2 is called
g('a', 'b'); // #2 is called
How can I cause #1 to get called? Okay, also it occurs to me that something might be wrong with this construct. Could someone kindly review this code for me? Thanks!
Also, I read this one here, but I need more information.

Answer 1

Overload resolution between these two methods is roughly equivalent to the overload resolution of the following two functions.
edge func(const graph *thiz, const char &i, const char &j); // #1
edge& func(graph *thiz, const char &i, const char &j); // #2
then the following call is fully matched with the #2 because the first argument is not const.
graph g;
func(&g, 'a', 'b');
However if the first argument was const, only #1 can be called.

Answer 2

If you want to do this sort of thing, you need to have your operator() return an edge_ref helper object that can be assigned to (to insert an edge into the graph), or implicitly converted into an edge:
class graph {
std::set<char> vertices;
std::map<std::pair<char, char>, int> edges;
class edge_ref {
graph &self;
char i, j;
public:
edge_ref(graph &g, char i, char j): self(g), i(i), j(j) {}
int operator=(int weight) {
self.vertices.insert(i);
self.vertices.insert(j);
return self.edges[std::make_pair(i, j)] = weight; }
operator int() {
return self.edges.at(std::make_pair(i, j)); }
};
public:
edge_ref operator()(char i, char j) { return edge_ref(*this, i, j); }