C++ - Copy Assignment Operator in Template - c++

Question

I'm trying to overload a copy assignment operator in template struct xpair
template <typename First, typename Second>
struct xpair {
First first{};
Second second{};
xpair(){}
xpair (const First& first, const Second& second):
first(first), second(second) {}
xpair& operator= (const xpair& that) {
cout << "*this = " << *this << " " << "that = " << that << endl;
cout << "use operator = " << endl;
*this = that;
return *this;
}
};
But when I test this code with
using commend = string;
using str_str_pair = xpair<string, string>;
using commend_pair = xpair<commend, str_str_pair>;
commend_pair cmd_pair;
str_str_pair str_pair("a", "1");
commend cmd("comment");
cmd_pair.first = cmd;
cmd_pair.second = str_pair;
It gives me infinite output as
use operator =
*this = {,} that = {a,1}
use operator =
*this = {,} that = {a,1}
use operator =
*this = {,} that = {a,1}
use operator =
*this = {,} that = {a,1}
Why is that?

Answer 1

It gives me infinite output as
Why is that?
Because you've defined the function in terms of itself, see the following code comment.
xpair& operator= (const xpair& that)
{
cout << "*this = " << *this << " " << "that = " << that << endl;
cout << "use operator = " << endl;
// Here you're asking for `this` (i.e., an `xpair` type) to be assigned
// a `that` (i.e., another `xpair` type) using the `operator=` which is
// the function currently being implemented/defined. A function calling
// itself is recursion and there is no stopping condition so it will
// continue infinitely.
*this = that;
return *this;
}
Instead your operation should set the data members of this instance using the data members of that instance.
xpair& operator= (const xpair& that)
{
cout << "*this = " << *this << " " << "that = " << that << endl;
cout << "use operator = " << endl;
first = that.first;
second = that.second;
return *this;
}

Answer 2

Your line
*this = that;
is an assignment as well, taking two arguments. And both are xpair<First,Second>, so it calls the same operator again.
What you would probably like to do is this:
this->first = that.first;
this->second = that.second;
which calls the assignment operators for First and Second.

Answer 3

Your problem is, as others have noted, that your operator= calls your operator=. This results in an infinite recursion.
But, I'll argue for a different implementation:
Add this:
template<class Self,
class=std::enable_if_t<std::is_same<std::decay_t<Self>, xpair>{}>
>
friend auto tieme(Self&& self) {
return std::forward_as_tuple(
std::forward<Self>(self).first,
std::forward<Self>(self).second
);
}
to the body of your pair. The enable_if_t stuff is a bit obscure, but it makes sure this free function will only be invoked on genuine xpairs.
Now your operator= is just:
xpair& operator= (const xpair& that) {
tieme(*this)=tieme(that);
return *this;
}
which is nice, because you don't have to repeat the order of your elements twice over.
But it doesn't stop there.
friend bool operator<(const xpair& lhs, const xpair& rhs) {
return tieme(lhs) < tieme(rhs);
}
the same technique lets you write a bunch of other operators. And anyone who has ever had bugs in < boilerplate will understand that the above is nice.
Move assign?
xpair& operator= (xpair&& that) {
tieme(*this)=tieme(std::move(that));
return *this;
}
swap?
friend void swap(xpair& lhs, xpair& rhs) {
std::swap( tieme(lhs), tieme(rhs) );
}
and it scales -- add more stuff to tieme, and it is auto-handled by all your other methods.