rvalue reference -what is new with 'move constructor' that could not have been implemented in C++98?

I am new at C++ 11/17 and trying to understand how the rvalue reference move works.
In the code below what is the difference between the "modified copy constructor" and "move constructor"?
I have made them to do the same thing but only a different prototype. If I make "move constructor" in a comment, well, the "modified copy constructor" will do just the same.

My point is why we need the "move constructor" how is it different now in C++17 from our old version of C++98? I just could do the same thing before only by implementing differently the "copy constructor" and avoid all the deep copy it used to do.
What am I missing? What I do not understand?

#include <iostream>

class A {
public:
    int* arr, size;
    bool flag;

    // parameterized constructor
    A(int len) {
        size = len;
        arr = new int[size];
        flag = false;
    }

    // modified copy constructor
    A(A& temp) {
        arr = temp.arr;
        size = temp.size;
        flag = temp.flag;
        temp.arr = NULL;
    }

    // move constructor
    A(A&& temp) {
        arr = temp.arr;
        size = temp.size;
        flag = temp.flag;
        temp.arr = NULL;

        std::cout << " A(A&& temp)" << std::endl;
    }

    // destructor
    ~A() {
        delete[] arr;
    }
};

A func()
{
    A obj(100000);
    return obj;
}

int main()
{
    A obj1 = func();
    std::cout << obj1.size << std::endl;
    return 0;
}

I expected the move constructor add a new solution for a problem could not handle in c++98

An lvalue reference to a non-const object (ie A&), such as used in your "modified" copy constructor, cannot bind to an rvalue (ie a temporary object), but an lvalue reference to a const object (ie const A& or A const &) can.

This is why copy constructors and copy assignment operators typically take const references. But, doing so prevents them from being able to steal an object's data (which a copy shouldn't do anyway).

func() returns a temporary object, hence it returns an rvalue. As such, A obj1 = func(); (aka A obj(func());) does not compile pre-C++11 unless the copy constructor takes a const reference (as it should) in order to bind to the temporary object.

An rvalue reference (ie A&&), on the other hand, can bind to an rvalue (hence its name). This is the single most important feature added in C++11 that allows move semantics to be practical.

Thus, move constructors and move assignment operators can steal data from any non-const object, particularly a temporary object, such as from a function's return value. Whereas before, they could only steal data from a pre-existing object.