Capacity
Capacity is the maximum amount of resources, workload, or contents that a system, structure, or process can accommodate or handle under specified constraints.
100 Go Mistakes and How to Avoid Them
Slice capacity is the number of elements in the underlying array available to a Go slice from its starting position.
- How it is used
- Uses capacity to explain indexing limits, append behavior, allocation costs, and memory retained by shortened slices.
- How deep it goes
- Defines capacity against length, traces shared backing arrays and growth, and works through preallocation and retention fixes without runtime implementation details.
- Examples
- Shows a length-three, capacity-six slice, a preallocated conversion function, and a shortened slice retaining pointer-bearing elements.
- What you can do after
- Diagnose/debug with it to distinguish invalid indexing, shared-array append effects, repeated allocations, and memory retained after slicing.
Read how 100 Go Mistakes and How to Avoid Them explains capacity →
Grokking Data Structures
Array capacity is the maximum number of elements allocated for an array.
- How it is used
- Uses capacity to determine whether an array can accept an element and when a dynamic array should resize.
- How deep it goes
- Defines capacity against current size, then explains full-array insertion and doubling or halving policies.
- Examples
- Uses a full static array, dynamic order tracking during a holiday peak, and stack growth to illustrate capacity.
- What you can do after
- Evaluate how allocated capacity limits static arrays and affects dynamic-array growth, shrinking, and memory use.
Go in Action, Second Edition
Slice capacity is the maximum number of elements a Go slice can contain by extending from its first element within its underlying storage.
- How it is used
- Uses capacity to reason about slice growth, preallocation, and how far a derived slice can extend into existing storage.
- How deep it goes
- Explains slice-header fields and walks through append allocation and copying, without establishing a general formula for capacity growth.
- Examples
- Compares length and capacity before and after an integer-slice append, and contrasts two-index with three-index slicing.
- What you can do after
- Operate/configure it with make and three-index slicing to reserve growth space or limit a derived slice’s capacity.
Classic Computer Science Problems in Swift: Essential techniques for practicing programmers
Knapsack capacity is the maximum total weight that the selected items may occupy.
- How it is used
- Constrains which item combinations are feasible in the 0/1 knapsack optimization problem.
- How deep it goes
- Defines capacity and develops it as a linear dynamic-programming dimension, stopping short of formal proof.
- Examples
- Uses a three-item table and a robber’s 75-pound selection of household items to demonstrate capacity choices.
- What you can do after
- Apply capacity as the limit in a Swift knapsack function and recover the selected items.
Refactoring to Rust
Buffer capacity is the number of elements a string buffer can hold before it requires additional allocation.
- How it is used
- Controls when a mutable Rust String needs reallocation as characters are appended.
- How deep it goes
- Defines capacity and explains when appending triggers reallocation, but leaves the buffer growth strategy unspecified.
- Examples
- Demonstrates preallocating a Rust String for ten million appended dots.
- What you can do after
- Apply it via String::with_capacity to reserve space before appending a known amount of string data.
Related concepts
- makeconfigures · make is a Go built-in function that initializes slices, maps, or channels, optionally specifying size or capacity.
- slice lengthcontrasts with · Slice length is the number of elements currently contained in a slice and accessible through its indices.
- headroommeasured by · Headroom is the remaining margin between current usage and an applicable capacity, power, or budget limit.
- appendused by · append is a Go built-in function that adds elements to a slice and returns a slice representing the resulting sequence.
- storage capacityincludes · Storage capacity is the amount of persistent data a storage resource can hold or has available for use.
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.