C / C++ / MFC

COleDateTime* pDate1 = new COleDateTime();
COleDateTime* pDate2 = new COleDateTime();

pDate1->GetStatus();

delete pDate1;
delete pDate2;

typedef struct{
  COleDateTime firstDateTime;
  COleDateTime secondDateTime;
}PairCOleDateTime;

void myFunc(COleDateTime & d1, COleDateTime & d2)
{
// write something into d1 and d2
}

COleDateTime x, y;
myFunc(x, y);
// myFunc stored the results inside x and y 

COleDateTime* CMyClass::AllocTwoDates()
{
   COleDateTime* pDate = new COleDateTime[2];
   return pDate;
}

void CMyClass::SomeFunction()
{
   COleDateTime* pDates = AllocTwoDates()
   // use the pDates allocated
   // now, delete them
   delete[] pDates;
}

void CMyClass::SomeFunction()
{
   COleDateTime* pDates = AllocTwoDates();
   // set first date object to current date
   pDates[0] = COleDateTime::GetCurrentTime();
   // set second date object to same day and time next year
   pDates[1].SetDate(pDates[0].GetYear()+1 ,pDates[0].GetMonth() ,pDates[0].GetDay());
   // now we delete the date objects
   delete[] pDates;
   // now every information in the date objects are gone.
   CString cs = pDates[1].Format(%d %b %Y); // illegal as pDates[1] is deleted!!!!

// in CMyClass.h

class CMyClass
{
public:
   CMyClass();
   ~CMyClass();

   void SomeFunction();
   void UseTheDates();
protected:
   void AllocTwoDates();
   void DeleteDates();
   const COleDateTime* GetDates();
private:
   COleDateTime* m_pDates;
};
   
// in CMyClass.cpp
CMyClass::CMyClass()
{
   m_pDates = NULL;
}

CMyClass::~CMyClass()
{
   DeleteDates();
}

void CMyClass::SomeFunction()
{
   AllocTwoDates();
   // don't delete dates
}

void CMyClass::UseTheDates()
{
   // use the date objects in m_pDates, they are still valid if m_pDates != NULL
   if (GetDates() != NULL) {
      // do something
   }
}

void CMyClass::AllocTwoDates()
{
   DeleteDates(); // can be called even if dates are already deleted
   m_pDates = new COleDateTime[2];
} 

void CMyClass::DeleteDates()
{
   if (m_pDates != NULL) { // this is where the protection for double-deletion is
      delete[] m_pDates;
      m_pDates = NULL; // important!
   }
}

GetDates()[1].Format("%d %b %Y");
delete GetDates();

GetDates()[0] = COleDateTime::GetCurrentDate(); // illegal

class CMyClass
{
public:
   COleDateTime Dates[2];
   ...
};

class CYourClass
{
public:
   COleDateTime ChangedDates[2];
....
};

void CYourClass::AssignValues()
{
   ChangedDates[0] = date1;
   ChangedDates[1] = date2;
}

// use from CYourClass member:
int CYourClass::CalcDifference(period dt)
{
   int iDifference = 0;
   // calculate the number of dt intervals
   // this code won't work as written, it's just as an example 
   COleDateTime date = ChangedDates[0];
   for (int i=0; ChangedDates[1]>date; i++) {
      iDifference++;
      date += dt;
   }
   // now return the number of dt periods
   return iDifference;
}
// use ChangedDates from outside CYourClass:
int CSomeOtherClass::CalcDifference(CYourClass yourclass, period dt)
{
   int iDifference = 0;
   // calculate the number of dt intervals
   // this code won't work as written, it's just as an example
   COleDateTime date = yourclass.ChangedDates[0];
   for (int i=0; yourclass.ChangedDates[1]>date; i++) {
      iDifference++;
      date += dt;
   }
   // now return the number of dt periods
   return iDifference;
}

COleDateTime[] CMyClass::ModifyDates(COleDateTime date1, COleDateTime date2)
{
   ChangedDates[0] = date1;
   ChangedDates[1] = date2;
   return ChangedDates;
}

int CMyClass::CalcNumberOfPeriod(COleDateTime StartDate,COleDateTime EndDate)
{
   int iNumberOfPeriod;
   ModifyDates(StartDate,EndDate); // you actually don't need ModifyDates to return the array
   //calculate the difference using ChangedDates[0] and ChangedDates[1] - they will now contain your StartDate and EndDate.
.
.
.
return iNumberOfPeriod;
}

void CMyClass::ModifyDates(COleDateTime* pDates)
{
   // pDates points to an array of two dates, pDates[0] and pDates[1]
   // do whatever modification is needed.
}

int CMyClass::CalcNumberOfPeriod(COleDateTime StartDate COleDateTime EndDate, periodtype dt)
{
   COleDateTime Dates[2];
   Dates[0] = StartDate;
   Dates[1] = EndDate;
   ModifyDates(Dates); // Dates i type COleDateTime*. Dates[0] and Dates[1] is type COleDateTime
   int iPeriods;
   // calculate the number of periods between the dates
   iPeriods = .....
   return iPeriods;
}

COleDateTime* CMyClass::AllocAndModifyDates(COleDateTime date1, COleDateTime date2)
{
   COleDateTime* pDates = new COleDateTime[2];
   pDates[0] = date1;
   pDatse[1] = date2;
   // do the modification
   return pDates;
}

int CMyClass::CalcNumberOfPeriod(COleDateTime StartDate, COleDateTime EndDate, periodtype dt)
{
   COleDateTime* pDates = AllocAndModifyDates(StartDate, EndDate);
   int iPeriods;
   // do the calculation of number of periods
   // now we're done using the dates, let's delete them
   delete[] pDates;
   return iPeriods;
}