subscript operator overload returning pointer and assigning value to it

I got a situation where I have a class B having a protected array of A*. I have an another function A* func() which returns pointers to A objects stored in some other container. (for example std::map<int,A*> or A* arr[]).

For example the following implementation:

#include <iostream>
using namespace std;
class A {
public:
    A(int _x): x(_x){};
    int x;
};
class B{
public:
    B() {
        this->arr[0] = new A(1);
        this->arr[1] = new A(2);
    }
    // use idx to index in to the internal array and return A*
    A*& operator[](int idx); // return reference to pointer to avoid not a lvalue error
private:
    // class B has this private array of A*
    A* arr[2];
};

A*& B::operator[](int idx) {
    return this->arr[idx]; // 0<=idx<=1
}



A* arr[2];
A* func(int x) {
    return arr[x]; // 0<=idx<=1
}

int main() {
    arr[0] = new A(12);
    arr[1] = new A(14);

    B b;

    b[1] = func(1); // assign a new value

    cout << b[1]->x << endl; // prints 14
}
// memory leaks of this program can be removed using `std::shared_ptr<A>` in the place of `A*`.

In this example, operator[]() returns a reference to a pointer, because returning pointer becomes rvalue and I will not be able to assign value to it (i.e. b[1] = func(1)).

My question is, is this reference to pointer returning recommended (other ways to achieve this )? or is this perfectly fine with raw pointers as well as with shared_ptr?

Thank You!