How are pointers modeled on bit-based computer models?

Why bit-based computer models?

The perhaps most commonly used computer model is a random access machine that can store natural (or even real) numbers in infinitely many cells indexed by natural numbers. This model's main benefit is that it greatly simplifies calculating Runtimes, as arithmetic and indexing are simply assumed to be O(1), so that there is no need to estimate the size of numbers and pointers used, greatly simplifying runtime estimation.

This model is however obviously not realistic, as real computers simply cannot save natural numbers of any length in one "cell", or operate on them in constant time. This sort of constitutes the necessity of bit-based (or byte-based) computer models, where any cell holds either 1 or 0. The best known one of those is the Turing Machine.

The indexing problem

While one certainly can simulate indexing on a Turing Machine or similar, it is probably painstakingly slow. In reality, this problem is solved by building computers with specialized indexing hardware, and this remedy obviously is not accounted for in the Turing Machine model.

The question

Now the question is, is there a bit-based computer model that models faster indexing (which in reality is achieved by specialized hardware) in a senseful way?

In particular, is there a bit-based model where indexing is in O(1), regardless of index length? Would such a model even make sense?

There's also easy ways to equip a Turing machine with random access capabilities. You give it an extra "index" tape that it can only write to (so it can't use it for extra read-memory), and the Turing machine has an extra operation which is "Query". Upon doing a "Query" operation, you look at the position on the (main) tape pointed to by the "index" tape, take the symbol there, write it under the Turing machine's head on the (main) tape. So in this way, the Turing machine writes out the location that it wants to read, in binary, and then the query lets it copy the appropriate data from there. Similarly, then, there's a "Store" operation that takes the symbol under the Turing machine's head and writes it somewhere else in memory based on what's on the index tape. This generally captures efficient pointer operation. It does mean that copying pointers takes $$\log(n)$$ time, where $$n$$ is the size of memory in use. Typically $$\log(n)$$ factors are happily ignored of course; they only come into play when doing very fine-grained runtime analysis. It also adds a factor of $$\log(n)$$ to space complexity over a RAM-style "register machine", which is slightly more likely to be an issue.