我无法将 object 分配给 object 数组

Question

I just wrote my first copy constructor and copy operator, and I'm trying to assign an object instance to an array like so:

Agent agent = Agent(navmesh, rb, m_maxPathSize);
Agent tmp = agent; // DEBUG
m_agents[idx] = agent;

The copy constructor seems to be working fine, since tmp is a perfect copy of agent (with a newly assigned m_path pointer). But when I assign agent to m_agents[idx] , the latter consists of what I'd expect from the default constructor ( m_path == 0 , m_alive == false ).

My constructors look like this:

Agent() { m_path = 0; m_alive = false; };
Agent::Agent(NavMeshNavigator* navmesh, RigidBody* rb, int maxPathSize)
    : m_rb(rb), m_navmesh(navmesh), m_maxPathCount(maxPathSize)
{
    m_path = new float3[maxPathSize];
};
Agent::Agent(const Agent &a)
{
    memcpy(this, &a, sizeof(Agent));
    if (m_path)
    {
        float3* oldptr = m_path;
        m_path = new float3[m_maxPathCount];
        memcpy(m_path, oldptr, m_maxPathCount * sizeof(float3));
    }
}
Agent& Agent::operator=(const Agent &a) { return Agent(a); }
Agent::~Agent() { if (m_path) delete[] m_path; };

...

protected:
   float3* m_path;
   bool m_alive = true;

The constructor allocates memory for m_path using new[] , the destructor frees it with delete[] , the copy operator calls the copy constructor, and the copy constructor first memcopies the original before allocating a new m_path array.

In my test case, idx == 0 , so that can't be it. I originally used malloc instead of new[] but got the same results. I'd say the problem is in my copy constructor/operator since I have no experience with that, but then why does it work perfectly on tmp ?

EDIT: The m_agents array is declared and destroyed like this:

NavMeshAgents(int maxAgents, int maxAgentPathSize)
        : m_maxAgents(maxAgents), m_maxPathSize(maxAgentPathSize)
    {
        m_agents = new Agent[maxAgents];
    };
    ~NavMeshAgents() { if (m_agents) delete[] m_agents; m_agents = 0; };

Answer 1

As @Evg @HolyBlackCat and @Adrian-Reinstate-Monica explained in the comments, new[] calls the default constructor for all its members. Agent tmp = agent calls the copy constructor, whereas tmp = agent would've called the assignment operator ( tmp.operator=(agent) ). My assignment operator was wrong, it should initialize this (and then return *this rather than return an instance.