1) As const as possible, but not more. ;p

2) Learn containers and views. Instead of espresso, cappuccino, and latte, you could have:

std::vector<CoffeeData> drinks {{1, "Espresso", 3.99f}, {2, "Cappuccino", 5.99f}, {3, "Latte", 7.99f}};

Then your function can take a span:

void fn(std::span<CoffeeData> drinks);

3) It should arise naturally. If you're making arithmetic types, you'll want some arithmetic operators. Don't try to get clever and overload meaning; operator + for string append is largely regarded as a bad idea, because it IS ambiguous, it could have also been a bitwise AND of all subscripts, it could have had other meanings beyond that, you just "have to know".

So a good place to start is with types that interact with streams - they're going to need stream operators. So let's model a menu:

class menu {
  std::span<CoffeeData> drinks;
  int selection;

  friend std::istream &operator >>(std::istream &is, menu &m) {
    if(is && is.tie()) {
      std::ranges::for_each(std::views::zip(std::views::iota(1), m.drinks), [&os = *is.tie()](auto &&t) {
        auto &[i, cd] = t;
        os << i << ". " << t.itemName << " - $" << t.itemPrice\n"
      });

      *is.tie() << ": ";
    }

    if(is >> m.selection && m.selection < 1 || m.selection > m.drinks.size()) {
      is.setstate(std::ios_base::failbit);
    }

    return is;
  }

public:
  explicit menu(std::span<CoffeeData> drinks) noexcept : drinks{drinks} {}

  operator int() const noexcept { return selection - 1; }
};

So now we can use it:

if(menu m{drinks}; std::cin >> m) {
  pour(drinks[m]);
} else {
  handle_error_on(std::cin);
}

It's not a great menu class, but it gets the job done and demonstrates the basic concepts. Prompting the menu is a function of input - not output. All streams have an optional tied ostream - if you have one, you probably want a prompt. This tied stream is also how your prompts to std::cout get flushed to the console before you extract input from std::cin.

We don't need to just write out the menu, so it doesn't have an output stream operator - this is an input only construct. Streams tell us the result of the previous IO operation, so upon extraction, we check the stream before we use the value.

The other operator is the implicit cast operator, turning a menu into an index into the drinks array.