Using std::vector's emplace with const reference member

I was using emplace_back on a vector of my class A that has a const reference member variable of class Handle with some success. However I needed to change it to use emplace instead to be able to insert at certain index. But that doesn't seem to compile. Looking at cppreference, I can't tell what the difference between the two methods is, except that one takes an explicit iterator

#include <vector>

class Handle
{
	int do_something();
};

class A
{
public:
	A(int a, float d, const Handle& h) : a_(a), d_(d), h_(h) {}
private:
	int a_;
	float d_;
	const Handle& h_;
};

int main()
{
	Handle h;
	std::vector<A> foo;
    foo.reserve(10);
	foo.emplace_back(3, 4.5, h); // OK
    // foo.emplace(foo.begin() + 3, 3, 4.5, h); // NOT OK
}

I get an error on using emplace :

In file included from main.cpp:7:
/Library/Developer/CommandLineTools/SDKs/MacOSX.sdk/usr/include/c++/v1/vector:1759:18: error: object of type 'A' cannot be assigned because its copy assignment operator is implicitly deleted
            *__p = _VSTD::move(__tmp.get());
                 ^
main.cpp:41:6: note: in instantiation of function template specialization 'std::vector<A>::emplace<int, double, Handle &>' requested here
        foo.emplace(foo.begin() + 3, 3, 4.5, h);
            ^
main.cpp:22:16: note: copy assignment operator of 'A' is implicitly deleted because field 'h_' is of reference type 'const Handle &'
        const Handle& h_;

Do I need to change my class design to accommodate using emplace?

I found this question but it doesn't seem to provide an alternative

Your code is attempting to insert an element into a non-end position in an empty std::vector, which is not allowed. The std::vector::emplace method inserts an element at the specified position, but that position must be within the range of the container (i.e., between begin() and end()).

In your code, the position foo.begin() + 3 is out of range for the current foo.
You can modify your code in the following ways:
Use the emplace_back method instead of the emplace method, which will append the new element to the end of the std::vector.

foo.emplace_back(3, 4.5, h);

Or, increase the size of the std::vector using the resize method before using the emplace method.

foo.resize(10);
foo.emplace(foo.begin() + 3, 3, 4.5, h);

However, beware that the above code will create A objects with default construction at the first three positions of foo. If the A class does not have a default constructor, or if you do not want to create these default objects, you might need to seek other solutions.

Moreover, the A class contains a constant reference to the Handle class, which causes the copy constructor and copy assignment operator of the A class to be deleted. This is because a reference member cannot change the object it refers to once it has been initialized. If std::vector needs to move or copy elements internally (for example, when the container needs to adjust its internal storage size), it will need to use these deleted copy constructors or copy assignment operators, leading to a compile error. You may need to modify the design of the A class to make it copyable or movable.