C / C++ / MFC

int days_left_in_month; // *** this needs to be initialised to some value
while(days_left_in_month > 0)
{
days_left_in_month = days_in_month[*mm] - *dd;
// days_left_in_month = days_in_month[*mm] - *dd;
if (days_in_month[2] && is_leap_year(*yy) == true) // ***days_in_month[2] is always non-zero, you should be checking if month is greater than 2.
{
days_left_in_month++;
}
} // end while

Set days_in_year to the actual number of days up to the date given, which in the case above should be 365.
Add days_to_add to days_in_year.
While days_in_year > 365
{
    add 1 to year
    subtract 365 from days_in_year
}
Use the remaining value of days_in_year to calculate the month and day.

int days_in_month[] = { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };

void add_days_to_date (int* mm, int* dd, int* yy, int days_left_to_add)
{
  int days_left_in_month;
  while (days_left_in_month > 0)

while (days_left_in_month > 0)
{
  days_left_in_month = days_in_month[*mm] - *dd;
  if (days_in_month[2] && is_leap_year (*yy) == true)

if (month == 2 && is_leap_year(*yy) == true)

void add_days_to_date (int* mm, int* dd, int* yy, int days_left_to_add)
{
  int days_left_in_month;
  days_left_in_month = days_in_month[*mm] - *dd;
  if (*mm == 2 && is_leap_year (*yy))
    days_left_in_month++;

bool operator<(const usingrange& x) const

// FUNCTION TEMPLATE _Debug_lt_pred
template <class _Pr, class _Ty1, class _Ty2,
    enable_if_t<is_same_v<_Remove_cvref_t<_Ty1>, _Remove_cvref_t<_Ty2>>, int> = 0>
constexpr bool _Debug_lt_pred(_Pr&& _Pred, _Ty1&& _Left, _Ty2&& _Right) noexcept(
    noexcept(_Pred(_Left, _Right)) && noexcept(_Pred(_Right, _Left))) {
    // test if _Pred(_Left, _Right) and _Pred is strict weak ordering, when the arguments are the cv-same-type
    const auto _Result = static_cast<bool>(_Pred(_Left, _Right));
    if (_Result) {
        _STL_VERIFY(!_Pred(_Right, _Left), "invalid comparator");

struct usingrange
{
	ESDID esdid;
	int start;
	int end;
	
	usingrange() { start = 0; end = 0; return; }
  bool operator<(const usingrange& x) const {
	  if (esdid < x.esdid)
		  return esdid < x.esdid;
	  if (start < x.start) 
		  return start < x.start;
	  if (end < x.end) return end < x.end;
	  else
		  return x.end < end;

bool operator<(const usingrange& x) const {

    return start < x.start;
 }

;
struct usingrange
{
	ESDID esdid;
	int start;
	int end;
	
	usingrange() { start = 0; end = 0; return; }
  bool operator<(const usingrange& x) const {
	  union
	  {
		  long double a;
		  char str1[16];
	  }c;
	  union
	  {
		  long double b;
		  char str2[16];
	  }d;
	
	  ::memset(&c.str1, 0x00, 16);
	  ::memset(&d.str2, 0x00, 16);
	  ::memcpy(&c.str1[4], &esdid, 4);
	  ::memcpy(&c.str1[8],&start,4);
	  ::memcpy(&c.str1[12], &end, 4);
	  ::memcpy(&d.str2[4], &x.esdid, 4);
	  ::memcpy(&d.str2[8], &x.start, 4);
	  ::memcpy(&d.str2[12], &x.end, 4);

	  return c.a < d.b;

	//	  return usingrange  < x;
	//	  if (start < x.start) 
     //   return start < x.start;
//		  return x.end < end;

 }
 
};

[k5054@localhost tmp]$ cat example.c 
#include <stdio.h>

int main()
{
    double d = 0.0 / 0.0;  // produces NaN 
    printf("1.0 < d = %d\n", 1.0 < d);
    printf("d < 1.0 = %d\n", d < 1.0);
    printf("d == d  = %d\n", d == d);
}
[k5054@localhost tmp]$ gcc example.c -o example
[k5054@localhost tmp]$ ./example 
1.0 < d = 0
d < 1.0 = 0
d == d  = 0
[k5054@localhost tmp]$

*#35;include <cstring>
struct usingrange {
    ESDID esdid;
    int start;
    int end;
    // ... other stuff ...
    bool operator<(const usingrange& x)const {
        return ::memcmp(this, &x, sizeof(*this)
    }
};

struct ESDID
{
  char c[4];

  bool operator<(const ESDID& other) const
  {
    return c[0] < other.c[0] && c[1] < other.c[1] &&
      c[2] < other.c[2] && c[3] < other.c[3];
  }
}

struct usingrange
{
  ESDID esdid;
  int start;
  int end;

  bool operator<(const usingrange& other) const
  {
    return esdid < other.esdid && start < other.start &&
      end < other.end;
  }
}

usingrange using_range{ usingpoint->usingesdid };

using_range.start = (BYTE &)usingpoint->statement;
using_range.end = (BYTE &)usingpoint->laststatement;

usingrange using_range2;
using_range2 = using_range;

using_range.start = *usingpoint->statement;
	    using_range.end = *usingpoint->laststatement;

using_range.start = usingpoint->statement;

struct A {
  char ch;
  long l;
//...
};

struct B {
  int i;
  char c;
//...
};

A a;
B b;

a = b;

a.l = b.i;
a.ch = b.c;

struct A {
  char ch;
  long l;
//...
  int operator =(B& rhs) {l = rhs.i; ch = rhs.c; return 1;}
};

a = b;

struct A {
  char ch;
  long l;
//...
  int operator =(B& rhs) {l = rhs.i; ch = rhs.c; return 1;}
  int operator =(A& rhs) {l = rhs.l; ch = rhs.ch; return 1}
};

A a1;
a1 = a = b;

a = b

struct A {
  char ch;
  long l;
//...
  int operator =(const B& rhs) {l = rhs.i; ch = rhs.c; return 1;}
  A& operator =(const A& rhs) {l = rhs.l; ch = rhs.ch; return *this;}
};