Легальность проверки указателя на нахождение внутри массива

A* begin;
size_t size;

A* item;

if(item >= begin && item < begin+size)
{
    //элемент принадлежит массиву
}

bool is_item(A* begin, A* item, size_t size)
{
  //элемент принадлежит массиву?
  return (item >= begin) && (item < begin + size) &&
         !((intptr_t(item) - intptr_t(begin)) % sizeof(A));
}

#include <iostream>
 
typedef  uint64_t A;
 
bool is_item(A* begin, A* item, size_t count)
{
  //элемент принадлежит массиву?
  bool result = (item >= begin) && 
                (item < begin + count) &&
                !((intptr_t(item) - intptr_t(begin)) % sizeof(A));
                
  if (result) 
  {
    size_t idx = (intptr_t(item) - intptr_t(begin)) / sizeof(A);
    printf("%p is item[%u] = %zu of array [%p]\n",
           item, idx, *item, begin); 
  }
  else     
    printf("%p is NOT item of array [%p]\n", item, begin);   
    
  return result;
}
 
 
int main()
{
  A begin[] = {1, 2, 3, 4, 5};
  const auto count = sizeof(begin) / sizeof(A);
  A* item1 = &begin[2]; // 3
  auto item2 = (A*)((unsigned char*)(&begin[2]) + 1); // +1 байт
  
  is_item(begin, item1, count); 
  is_item(begin, item2, count); 
 
  return 0;
}

//элемент принадлежит массиву?
  bool result = (item >= begin) && 
                (item < begin + count) &&
                !((intptr_t(item) - intptr_t(begin)) % sizeof(A))

#include <iostream>
 
struct A
{
    int n1;
    int n2;
};
 
bool ArrayContainsTheItem(const A* begin , size_t size, const A* item)
{
    if(item >= begin && item < begin+size)
    {
        //проверяем выравнивание
        const auto offset=((const char*)item) - ((const char*)begin);
        if(offset%sizeof(A) == 0)
        {
            //элемент принадлежит массиву
            return true;
        }
    }
    return false;
}
 
int main()
{
    A arr[10];
    A a;
 
    std::cout<<std::boolalpha;
    
    std::cout<<ArrayContainsTheItem(arr,std::size(arr),&arr[5])<<'\n';//true
    std::cout<<ArrayContainsTheItem(arr,std::size(arr),&a)<<'\n';//false
 
    char C[10 * sizeof(A)]{};
    auto begin = (const A*)C;
    auto size = std::size(C)/sizeof(A);
    auto item0 = (const A*)(C+0);
    auto item1 = (const A*)(C+1);
    auto item2 = (const A*)(C+2);
    
    std::cout<<ArrayContainsTheItem(begin,size,item0)<<'\n';//true
    std::cout<<ArrayContainsTheItem(begin,size,item1)<<'\n';//false - невыровнено
    std::cout<<ArrayContainsTheItem(begin,size,item2)<<'\n';//false - невыровнено
}

int main()
{
// объявите контейнер test
    const A * begin = &test[0];
    const A * target = &test[1];
    
    bool c1 = (target - begin > 0);
    bool c2 = (target < begin + 10);
    bool c3 = (((char *) target - (char *) begin) % sizeof(A) == 0);
    printf("%d, %d, %d\n", int(c1), int(c2), int(c3));
 
    return 0;
}

char C[10 * sizeof(A)]{};
...
auto item0 = (const A*)(C+0);
auto item1 = (const A*)(C+1);
auto item2 = (const A*)(C+2);

if (std::less_equal<A*>{}(begin, item) && std::less<A*>{}(item, begin + size))

if (!std::less()(item, begin) && std::less()(item, begin + size))
{
    //элемент принадлежит массиву
}