Reference
A reference is an indirect value, binding, or relationship that identifies or provides access to another object, value, resource, or source.
Rust in Action: Systems programming concepts and techniques
A reference is a non-owning value that provides access to another value without transferring its ownership.
- How it is used
- Uses references to access values without transferring ownership, including during iteration and function calls.
- How deep it goes
- Explains reference and dereference syntax, mutable borrowing, and memory addresses, then contrasts references with raw pointers.
- Examples
- Uses an integer addition, collection iteration, and a satellite mailbox to demonstrate references.
- What you can do after
- Apply references in Rust loops and functions to read or modify values while retaining ownership.
Read how Rust in Action: Systems programming concepts and techniques explains reference →
100 C++ Mistakes and How to Avoid Them
A pointer is a C++ value or object that refers to another object or function through an address and can represent no object with a null value.
- How it is used
- Uses pointers and references to access objects while addressing ownership, copying, lifetime, and polymorphism.
- How deep it goes
- Explains ownership and lifetime failures through examples and corrections, including double deletion and returns referring to local objects.
- Examples
- Demonstrates a double-deleted Buffer, a concatenation function returning a local reference, and a reference-returning assignment operator.
- What you can do after
- Diagnose/debug dangling returns and duplicate deletion, and apply reference returns and unique_ptr ownership in C++ code.
Read how 100 C++ Mistakes and How to Avoid Them explains reference →
Refactoring to Rust
A pointer is a value representing a memory address that can be used to access data indirectly.
- How it is used
- Uses borrowing to reuse values without transferring ownership and raw pointers to exchange data across a C interface.
- How deep it goes
- Explains borrowing rules, lifetime inference and annotations, then contrasts reference validity with unsafe raw-pointer dereferencing.
- Examples
- Uses repeated artwork access, a vector element returned by reference, and a C calculator with pointer arguments.
- What you can do after
- Diagnose/debug borrowing and lifetime errors, and apply pointer checks when working with a C interface.
API Design Patterns
A reference is a pointer stored in a resource that identifies official data held elsewhere.
- How it is used
- Defines how API resources point to one another while balancing freshness, request cost, integrity, and compatibility.
- How deep it goes
- Explains field naming, dynamic targets, deletion behavior, cached values, and trade-offs, but stops short of prescribing one universal relationship policy.
- Examples
- Uses Message-User authorship, ChatRoom administration, Book-Author links, ChangeLogEntry dynamic targets, and deleted authors as examples.
- What you can do after
- Designs reference fields, compares references with in-line data, and diagnoses invalid or stale pointers.
Modern C
An object pointer is a pointer whose referenced entity is an object rather than a function.
- How it is used
- Uses object pointers to access and modify objects across function boundaries and navigate arrays and structures.
- How deep it goes
- Explains pointer operations, validity, array access, aliasing, and generic conversions, while treating platform pointer representation as opaque.
- Examples
- Demonstrates swapping two doubles, summing array elements, and accessing structure members through pointers.
- What you can do after
- Apply object pointers in C to modify caller-owned objects, traverse arrays, and recognize invalid dereferences.
Modern C, Third Edition
A pointer type is a C type whose values designate objects or functions in storage.
- How it is used
- Uses pointers to access caller-owned objects and dynamically structured data across code boundaries.
- How deep it goes
- Develops pointer operations and validity from opaque representations through array parameters, object types, and conversions.
- Examples
- Illustrates swapping doubles, summing an array, testing a null pointer, and accessing a one-past pointer.
- What you can do after
- Apply pointers to access and modify objects, traverse arrays, and check bounds and type constraints.
Learn Rust in a Month of Lunches
Referencing is the operation of creating a Rust reference with the & operator.
- How it is used
- Uses references to borrow data for functions without transferring ownership.
- How deep it goes
- Explains reference creation, dereferencing, access rules, and invalid local returns using code and compiler feedback.
- Examples
- Demonstrates repeated function calls with a borrowed String and mutation through a numeric reference.
- What you can do after
- Apply references in Rust functions, choose mutable or immutable access, and recognize invalid returns of local references.
Read how Learn Rust in a Month of Lunches explains reference →
100 Go Mistakes and How to Avoid Them
A pointer is a Go value that holds the memory address of another value or represents the absence of such an address.
- How it is used
- Uses pointers to represent absence, share values, and avoid copying synchronization primitives.
- How deep it goes
- Traces pointer sharing, range-variable addresses, and slice retention through observed failures and alternative fixes.
- Examples
- Uses customer pointers stored in a map and a counter whose value receiver copies a mutex.
- What you can do after
- Diagnose/debug incorrect sharing and retention, and choose pointer-based fixes for configuration, synchronization, and nullable queries.
Read how 100 Go Mistakes and How to Avoid Them explains reference →
Get Programming: Learn to code with Python
- How it is used
- Uses start and end positions to split a multiline word string before checking which words can be made with letter tiles.
- How deep it goes
- Works through initialization, newline detection, word slicing, and pointer resets in a string-scanning loop.
- Examples
- Uses a multiline list of art words and traces pointer movement across newline characters.
- What you can do after
- Build a loop that separates newline-delimited words using start and end indices.
Read how Get Programming: Learn to code with Python explains reference →
The Well-Grounded Rubyist, Fourth Edition
An object reference is a value that identifies a Ruby object rather than containing an independent copy of that object.
- How it is used
- Explains why assignment, in-place string changes, and method calls can affect what another variable observes.
- How deep it goes
- Works through reference copying, reassignment, and argument behavior, while noting immediate-value exceptions without detailing their implementation.
- Examples
- Contrasts `replace` with reassignment, then tests a method argument and a mutable string inside a frozen array.
- What you can do after
- Diagnose/debug with it when a mutation unexpectedly appears through another variable, and use `dup` or `freeze` to limit changes.
Read how The Well-Grounded Rubyist, Fourth Edition explains reference →
Troubleshooting Java, Second Edition
An object reference is a value that identifies an object and can keep that object reachable for memory-management purposes.
- How it is used
- Tracks why objects remain reachable during memory-leak and abnormal-resource investigations.
- How deep it goes
- Defines retention by references, then traces referrers and storage locations in heap dumps; it stops short of prescribing the code fix.
- Examples
- Uses Product instances retained through an ArrayList stored in a static Main variable.
- What you can do after
- Diagnose retained objects with VisualVM by locating referrers and the code-held reference.
Read how Troubleshooting Java, Second Edition explains reference →
Go by Example
A pointer is a Go value that contains the memory address of another value and permits indirect access to it.
- How it is used
- Uses pointers to let flag parsers mutate shared configuration and to let errors.As store matched error values.
- How deep it goes
- Explains pointer sharing, captured field pointers, value-copy trade-offs, and the pointer-to-pointer requirement of errors.As.
- Examples
- Demonstrates a CLI config parser, copied concurrent Result values, and SQLite primary-key error detection.
- What you can do after
- Apply it via Go pointers to update caller-owned fields and use errors.As correctly with pointer-typed errors.
Object-Oriented Software Design in C++
A C++ reference is an alias bound to an existing object or function and used to access it without storing a separate object value.
- How it is used
- Uses references to access existing objects while discussing C++ value semantics and vector-related performance surprises.
- How deep it goes
- Defines references briefly and demonstrates a const reference parameter, but does not develop reference internals or a broader usage guide.
- Examples
- Demonstrates const Appointments& in a tester and contrasts Date values with pointers in appointment storage.
- What you can do after
- Evaluate when accessing an existing object through a reference can avoid value-oriented copying in a vector example.
Read how Object-Oriented Software Design in C++ explains reference →
Grokking Data Structures
A reference is a language-level value that identifies or provides access to an object or memory location.
- How it is used
- Uses references to connect noncontiguous linked-list nodes and support traversal, insertion, and deletion.
- How deep it goes
- Defines links through singly and doubly linked lists, then works through pointer updates and deletion edge cases.
- Examples
- Demonstrates references through array indexing, linked-list traversal, pointer-based insertion, and predecessor-aware deletion.
- What you can do after
- Evaluate/understand how references affect linked-list reachability, memory use, traversal cost, and structural updates.
Idiomatic Rust
A raw pointer is a pointer value that can be manipulated and dereferenced without Rust's ordinary ownership and borrowing guarantees.
- How it is used
- Provides temporary access to caller-owned values, including mutation without ownership transfer.
- How deep it goes
- Explains borrowing syntax and lifetime validity through function and struct examples, without developing raw-pointer operations.
- Examples
- Demonstrates `reverse(&str)`, `reverse_inplace(&mut String)`, and a struct field typed `&'a str`.
- What you can do after
- Apply it via Rust borrowing syntax to choose read-only access, mutation, or ownership transfer for function arguments.
Learn Go with Pocket-Sized Projects
A pointer is a Go value that represents the memory address of another value.
- How it is used
- Connects command-line flag parsing and HTTP client design to passing addresses and controlling shared state.
- How deep it goes
- Defines addresses, &, *, copy semantics, and absent pointer arithmetic, then applies them to flags, clients, and timeout errors.
- Examples
- Uses flag.StringVar, http.DefaultClient, private HTTP clients, and *url.Error timeout checks.
- What you can do after
- Apply pointers via flag.StringVar and diagnose pointer-bearing timeout errors with errors.As.
Read how Learn Go with Pocket-Sized Projects explains reference →
The Quick Python Book, Fourth Edition
An object reference is a binding or pointer-like association through which a name identifies a runtime object.
- How it is used
- Explains Python assignment, aliasing, mutation, and argument behavior through references to runtime objects.
- How deep it goes
- Works through mutable and immutable assignment and function-parameter effects, but does not descend into interpreter implementation.
- Examples
- Uses aliased lists, reassigned integers, and a function that mutates one list while reassigning another parameter.
- What you can do after
- Diagnose whether assignment or mutation will affect other names and function callers.
Read how The Quick Python Book, Fourth Edition explains reference →
MongoDB 8.0 in Action, Third Edition
A data pointer is an index component that identifies the location of corresponding data within a database.
- How it is used
- Guides MongoDB schema choices between embedding related data and linking documents across collections.
- How deep it goes
- Explains relationship types and trade-offs, but stops short of command-level reference implementation.
- Examples
- Uses airline routes, airports, embedded flight data, movie runtime searches, and MongoDB’s immutable _id index.
- What you can do after
- Evaluate whether to embed related data or use references, and understand how indexed pointers support efficient retrieval.
Read how MongoDB 8.0 in Action, Third Edition explains reference →
Related concepts
- array parameterequivalent to · An array parameter is a C function parameter declared with array syntax that is adjusted to a pointer to its element type.
- borrowingproduced by · Borrowing is Rust’s mechanism for accessing a value through a reference without transferring ownership, subject to rules governing reference validity and aliasing.
- arraycontrasts with · An array is an ordered collection of elements whose positions provide a way to access them, often across one or more dimensions.
These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.

















