Выделение памяти под массив структур

    struct TLog
     {
       string m_Date;
       CCar* m_Car;//либо CDriver* m_Driver
     };

//почти полная копия CCar, можно просто пролистать его
class CDriver
{
public:
    CDriver(const string& name, const string& surname)
    {
        m_Name= name;
        m_Surname= surname;
        m_LogNr= 0;
        m_Log= new TLog[1];
    }
 
 
 
    ~CDriver()
    {
        delete [] m_Log;
    }
 
    void usingCar(CCar* what, const string& when)
     {
         if(m_LogNr==0)
         {
            m_Log[0].m_Car=what;
            m_Log[0].m_Date=when;
 
            m_LogNr++;
            return;
        }
 
        TLog* tempLog=new TLog[m_LogNr+1];
        memmove(tempLog,m_Log,sizeof(TLog)*m_LogNr);
        m_Log=tempLog;
 
        m_Log[m_LogNr].m_Date=when;
        m_Log[m_LogNr].m_Car=what;
        m_LogNr++;
 
 
 
        qsort(m_Log, m_LogNr, sizeof(TLog), CDriver::compareDriversInside);
     }
 
 
     string getName() const
     {
         return (m_Name+" "+m_Surname);
     }
 
    static int compareDriversInside(const void* _first, const void* _second)
    {
        const TLog* first= (TLog*) _first;
        const TLog* second= (TLog*) _second;
        return first->m_Date.compare(second->m_Date);
    }
 
    friend ostream& operator <<(ostream& os,const CDriver& base);
protected:
    struct TLog
     {
       string m_Date;
       CCar* m_Car;
     };
 
    string m_Name;
    string m_Surname;
    TLog* m_Log;
    int m_LogNr;
 };
 
 
 
 
 
 
 
 
 
 
 
 
 
 
class CCar
 {
public:
   CCar(const string& RZ)
   {
       m_RZ=RZ;
       m_LogNr=0;
       m_Log= new TLog[1];///выделяю память под один элемент
   }
 
   ~CCar()
   {
       delete []m_Log;
   }
 
   void usingCar(CDriver* who, const string& when);///здесь и возникает проблема, описана чуть ниже
 
    const string& getRZ() const
    {
        return m_RZ;
    }
 
    static int compareCarsInside(const void* _first, const void* _second)
    {
        const TLog* first= (TLog*) _first;
        const TLog* second= (TLog*) _second;
        return first->m_Date.compare(second->m_Date);
    }
 
    friend ostream& operator <<(ostream& os,const CCar& base);
protected:
    struct TLog
     {
       string m_Date;//когда
       CDriver* m_Driver;//кто
     };
    string m_RZ;//регистрационный номер авто
    TLog* m_Log;//структура с записями кто и когда водил авто
    int m_LogNr;//сколько записей о использовании авто у нас есть
 };
 
 ostream& operator <<(ostream& os,const CDriver& base)
{
    os<<base.m_Name<<" "<<base.m_Surname<<endl;
    for(int i=0;i<base.m_LogNr;i++)
     os<<base.m_Log[i].m_Date<<": "<<base.m_Log[i].m_Car->getRZ()<<endl;
    return os;
}
 
ostream& operator <<(ostream& os,const CCar& base)
{
    os<<base.m_RZ<<endl;
    for(int i=0;i<base.m_LogNr;i++)
     os<<base.m_Log[i].m_Date<<": "<<base.m_Log[i].m_Driver->getName()<<endl;
 
    return os;
}
 
 
 
 
//проблемы появляются здесь так как здесь происходит утечка памяти
void CCar::usingCar(CDriver* who, const string& when)
{
    if(m_LogNr==0) //память уже была выделена конструктором для первого элемента
    {
        m_Log[0].m_Driver=who;
        m_Log[0].m_Date=when;
 
        m_LogNr++;
        return;
    }
    //иначе нужно выделить память под массив на 1 больше чем был
    
    TLog* tempLog=new TLog[m_LogNr+1];
    memmove(tempLog,m_Log,sizeof(TLog)*m_LogNr);
    //m_Log не удаляется
    m_Log=tempLog;
 
    m_Log[m_LogNr].m_Date=when;
    m_Log[m_LogNr].m_Driver=who;
    
    m_LogNr++;
}
 
 
int main()
{
    CCar* car= new CCar("XYZ-123");
    CDriver* driver=new CDriver("Homer", "Simpson");
    CDriver* driver2= new CDriver("Magre", "Simpson");
    car->usingCar(driver,"3");
    car->usingCar(driver,"1");
    car->usingCar(driver2,"2");
    cout<<*car;
    delete car;
}

 memmove(tempLog,m_Log,sizeof(TLog)*m_LogNr);

m_Cars[i]->usingCar(const_cast<CDriver*>(&(FindDriver(fname,sname))),right.m_Cars[i]->m_Log[j].m_Date);

   CCar(const string& RZ)
   {
       m_RZ=RZ;
       m_LogNr=0;
       m_Log= (TLog*) malloc (sizeof(TLog)*10);///выделяю память под ДЕСЯТЬ элементов умышленно с запасом
   }

//проблемы появляются здесь так как здесь происходит утечка памяти
void CCar::usingCar(CDriver* who, const string& when)
{
    if(m_LogNr==0) //память уже была выделена конструктором для первого элемента
    {
        m_Log[0].m_Driver=who;
        m_Log[0].m_Date=when; //вот здесь при первом же вызове функции программа крашиться, видать криво выделил память malloc для строки типа string
 
        m_LogNr++;
        return;
    }
   //ничего не выделяю, у меня места и так под 10 элементов
 
    m_Log[m_LogNr].m_Date=when;
    m_Log[m_LogNr].m_Driver=who;
 
    m_LogNr++;
}

void CCar::usingCar(CDriver* who, const string& when)
{
    if(m_LogNr==0) //память уже была выделена конструктором для первого элемента
    {
        m_Log[0].m_Driver=who;
        m_Log[0].m_Date=when;
 
        m_LogNr++;
        return;
    }
    //иначе нужно выделить память под массив на 1 больше чем был
 
    TLog* tempLog=new TLog[m_LogNr+1];
 
    for(int i=0;i<m_LogNr;i++)
    {
        tempLog[i].m_Date=m_Log[i].m_Date;
        tempLog[i].m_Driver=m_Log[i].m_Driver;
    }
    delete [] m_Log;
    m_Log=tempLog;
 
    m_Log[m_LogNr].m_Date=when;
    m_Log[m_LogNr].m_Driver=who;
 
    m_LogNr++;
}

    struct TLog
     {
       string m_Date;//когда
       CDriver* m_Driver;//кто
     };