Julia中何时应使用Ptr{T}而非Ref{T}？

Great question! While Ref{T} is indeed the safer, go-to choice for most cases where you need a reference to Julia-managed data, there are specific scenarios where Ptr{T} is necessary or more appropriate. Let’s break them down:

• Interfacing with C/C++ code
  When calling functions from C libraries, raw pointers are the standard—and this is exactly what Ptr{T} is built for. C functions expect types like int* or void*, which map directly to Julia’s Ptr{Int} or Ptr{Cvoid}. For example, if a C function requires you to pass a pointer to an output buffer, you can’t use a Ref here; you’ll need to convert your data to a Ptr (using pointer() on an array, for instance) to match the C function’s signature. Similarly, if a C function returns a raw pointer to memory it allocated, you have to receive it as a Ptr since that memory isn’t managed by Julia’s garbage collector.

• Manual memory management
  If you’re allocating memory directly via low-level functions like Libc.malloc() or Libc.calloc(), you must use Ptr{T} to reference that memory. Ref{T} is tightly tied to Julia’s GC, which only tracks memory it allocated itself. Using a Ref for manually allocated memory would lead to undefined behavior—Julia’s GC might try to free memory it doesn’t own, or ignore memory that needs explicit cleanup.

• Working with non-Julia-allocated memory
  This includes memory-mapped files, buffers returned by system calls, or memory shared with other processes/languages. Since this memory isn’t tracked by Julia’s GC, Ref{T} can’t guarantee its validity (it’s designed exclusively for Julia-managed data). Ptr{T} is the right tool here, as it makes no assumptions about who owns or maintains the underlying memory.

• Low-level pointer arithmetic
  Ptr{T} supports pointer arithmetic operations (like ptr + 4 to shift 4 elements forward in a buffer), which is critical for tasks like manually iterating over a contiguous memory block. Ref{T} intentionally blocks this behavior—its safety guarantees restrict it to referencing a single, valid Julia object, not arbitrary memory locations.

Quick Rule of Thumb: #

Use Ref{T} whenever you’re dealing with data managed by Julia’s garbage collector (most everyday cases). Reach for Ptr{T} only when you need to interact with unmanaged memory, interface with C code, or perform low-level memory operations that require raw pointer access.

内容的提问来源于stack exchange，提问作者Julie96