How to make a function which works with array of pointers as well as with array of structs?

I have got a function which sorts incoming vector

std::vector<Item> SimpleSort(std::vector<Item>&& items) {
   
   std::sort(items.begin(), items.end(), 
      [](const auto& left,const auto& right) { return left.id > right.id; }
   );

   return std::move(items); 
}

Also, I have got a second vector defined as:

std::vector<const Item*> items;

My goal is to make some function that can works with both types of vector.

I think I can do something like this:

template<typename ItemType>
std::vector<ItemType> SimpleSort(std::vector<ItemType>&& items) {
   if(std::is_pointer_v<ItemType>) {
      std::sort(items.begin(), items.end(), 
      [](const auto left,const auto right) { return left->id > right->id; });
   } else {
      std::sort(items.begin(), items.end(), 
      [](const auto& left,const auto& right) { return left.id > right.id; });
   }
   return std::move(items);
}

It is not that I want, because I don't want to copy logic, so overriding of that function is not suitable too. Is there any way to make it better than I offered?

Just extract your sorting function to a named lambda (or a function if you will):

template<typename ItemType>
std::vector<ItemType> SimpleSort(std::vector<ItemType>&& items) {
   constexpr auto sorter = [](const auto& left,const auto& right) { return left.id > right.id; };

   if constexpr (std::is_pointer_v<ItemType>) { //note the constexpr here
      std::sort(items.begin(), items.end(), 
      [sorter](const auto& left,const auto& right) { return sorter(*left, *right); });
   } else {
      std::sort(items.begin(), items.end(), sorter);
   }
   return std::move(items);
}

if constexpr must be used, otherwise it will not compile unless Item has unary operator* overloaded.

This would be a really good use-case for std::invoke() with a pointer to data member.
std::invoke will automatically take care of unwrapping the object parameter (you can pass it a reference, a pointer, or a std::reference_wrapper<T> and it'll automatically do the right thing)

Example: godbolt

template<class ItemType>
void SimpleSort(std::vector<ItemType>& items) {
    using Type = std::decay_t<std::remove_pointer_t<std::unwrap_ref_decay_t<ItemType>>>;

    std::sort(
        items.begin(),
        items.end(),
        [](auto const& lhs, auto const& rhs) {
            return
                std::invoke(&Type::id, lhs) >
                std::invoke(&Type::id, rhs);
        }
    );
}

// (1) can sort a vector of items
std::vector<Item> items = /*...*/;
SimpleSort(items);

// (2) can sort a vector of pointers to items
std::vector<Item*> items = /*...*/;
SimpleSort(items);

// (3) can sort a vector of reference_wrappers to items
std::vector<std::reference_wrapper<Item>> items = /*...*/;
SimpleSort(items);

An even easier option would be to use the new std::ranges::sort() instead of std::sort.

The range variant allows you to pass a projection as the third parameter, which will be invoked with std::invoke(). (the result of this will then be compared with the comparator passed as the second argument)

So sorting a vector of items / pointers / reference wrappers is as easy as:

Example: godbolt

// (1) sort a vector of items
std::vector<Item> items = /*...*/;
std::ranges::sort(items, std::ranges::greater(), &Item::id);

// (2) sort a vector of pointers to items
std::vector<Item*> items = /*...*/;
std::ranges::sort(items, std::ranges::greater(), &Item::id);

// (3) sort a vector of reference_wrappers to items
std::vector<std::reference_wrapper<Item>> items = /*...*/;
std::ranges::sort(items, std::ranges::greater(), &Item::id);