Understanding C++ Postfix Increment Operator Behavior in Assignment: Unexpected Results with obj1++ = obj2;

Question

I'm currently reading the Deitel C++ book, and it mentioned the behavior of the postfix increment operator, stating that it typically returns a temporary object containing the original value before the increment, and C++ treats such objects as rvalues. The book also mentions that rvalues cannot be used on the left side of an assignment. On the other hand, the prefix increment operator is said to return the actual incremented object with its new value, allowing it to be used as an lvalue.

The text from the book:

[...] the postfix increment operator typically returns a temporary object that contains the original value of the object before the increment occurred. C++ treats such objects as rvalues, which cannot be used on the left side of an assignment. The prefix increment operator returns the actual incremented object with its new value. Such an object can be used as an lvalue in a continuing expression.

To test this, I wrote a simple C++ program using a Counter class with overloaded prefix and postfix increment operators. Here's the code:

#include <iostream>

class Counter {
private:
    int count;

public:
    Counter(int initialCount = 0) : count(initialCount) {}

    Counter& operator++() {
        ++count;
        return *this;
    }

    Counter operator++(int) {
        Counter temp(*this);
        ++count;
        return temp;
    }

    void display() const {
        std::cout << "Count: " << count << std::endl;
    }
};

int main() {
    Counter obj1(5);
    Counter obj2(10);

    ++obj1 = obj2;
    std::cout << "After ++obj1 = obj2; we get: " << std::endl;
    obj1.display();

    std::cout << std::endl;

    obj1++ = obj2;
    std::cout << "After obj1++ = obj2; we get: " << std::endl;
    obj1.display();

    return 0;
}

But the consistent output on different compilers is:

After ++obj1 = obj2; we get: 
Count: 10

After obj1++ = obj2; we get: 
Count: 11

My question is: In the statement obj1++ = obj2;, are we not using obj1++ as an lvalue? According to the book, this should not be possible. Can someone explain this behavior and clarify the concept of rvalues and lvalues in this context?