Noncopyability

Noncopyability is a property of a type or value that cannot be duplicated through a copy operation. It is often by design to enforce unique ownership of a resource, to avoid expensive or unsafe copies, or to express transfer of ownership rather than duplication.

In languages like C++, noncopyability is typically implemented by deleting or making private the copy constructor and copy assignment operator. The type can then provide move constructors and move assignment to transfer ownership. This pattern is common for resource-managing types such as file handles, mutexes, or smart pointers. For example: class X { X(const X&) = delete; X& operator=(const X&) = delete; public: X(); ~X(); X(X&&); X& operator=(X&&); };

In Rust, noncopyability is expressed by not implementing the Copy trait. Types without Copy are moved on assignment rather than copied, guaranteeing a single owner unless shared through references or smart pointers. Cloning is explicit via the Clone trait. This design supports safe resource management and prevents unintended duplications. Common noncopyable types include String and Vec<T>, and ownership can be shared via Rc or Arc when needed.

In other languages, noncopyability is often achieved through API design rather than language rules. Objects may be cloned only when an explicit interface is implemented. Noncopyability influences how functions accept arguments (by reference or move), how resources are released, and how containers store elements, since some containers require copyable or movable values.

Noncopyability can simplify resource safety and correctness but may complicate API use and testing, requiring callers to pass by reference, use pointers, or restructure ownership. It is frequently balanced with move semantics and explicit cloning strategies to maintain safety while preserving usability.