## Assignable |

## Detailed Description

A type is Assignable if it is possible to copy objects of that type and to assign values to variables.

**Refinement Of:**

**Associated Types:**

**Notation:**`X`

A type that is a model of Assignable `x`

,`y`

Object of type `X`

**Definitions:**

**Valid Expressions:**Name Expression Type requirements Return type Copy constructor `X(x)`

`X`

Copy constructor X x(y); X x = y;

Assignment `x = y`

[1]`X&`

Swap `adobe::swap(x,y)`

`void`

**Expression Semantics:**Name Expression Precondition Semantics Postcondition Copy constructor `X(x)`

`X(x)`

is a copy of`x`

[2]Copy constructor `X(x)`

`X(x)`

is a copy of`x`

[2]Copy constructor X x(y); X x = y;

`x`

is a copy of`y`

[2]Assignment `x`

=`y`

[1]`x`

is a copy of`y`

[2]Swap `adobe::swap(x,y)`

[3]Equivalent to { X tmp = x; x = y; y = tmp; }

**Complexity Guarantees:**

**Invariants:**

**Type(s) Modeling this Concept:**- int

**Notes:**- [1] One implication of this requirement is that a
`const`

type is not Assignable. For example,`const int`

is not Assignable: if`x`

is declared to be of type`const int`

, then`x = 7`

is illegal. Similarly, the type`pair<const int, int>`

is not Assignable.

- [2] The reason this says "
`x`

is a copy of`y`

", rather than "`x == y`

", is that`operator==`

is not necessarily defined: equality is not a requirement of Assignable. If the type`X`

is EqualityComparable as well as Assignable, then a copy of`x`

should compare equal to`x`

.

- [3]
`adobe::swap`

will not throw an exception for an assignable type. For types with remote parts,`adobe::swap`

must be specialized to swap the remote parts.

- [4] It is assumed that adobe::swap() will not throw an exception. Items with remote parts much specialize swap as described in swap.

**See Also:**