What is (in simple understanding) narrow contract and wide contract in terms of c++ interface(s)?

Question

While walking through some c++11 concepts, I came across the terms narrow contract and wide contract.

But I failed to figure out a simple function example(s) which is/are written for these contracts.

Can I see a simple function example that distinguishes between these two contracts?

Answer 1

Wide contract functions have well-defined behavior for all possible inputs, while narrow contracts mean that the functions can only be called when certain preconditions are met.

Some caveats:

• "Input" might also include global state or the object for which a member function is called.
• All possible inputs don't include invalid objects (e.g., the result of an invalid cast).
• Well-defined behavior might mean throwing an exception.

For example, std::vector<int>-s .size() member function has a wide contract because it can be called on any instance of a vector (as in std::vector<int> v; /* anything can happen with v here... */; auto s = v.size(); is always valid). The operator[](size_t index) (as in int x = v[10]) has a narrow contract, because it can only be called with a parameter that is less than .size(), otherwise it is undefined. The .at(size_t i) member function (as in int y = v.at(10)) however has a wide contract, because it is specified to throw an exception when the index is out of range.

Preconditions are not always easy to verify: For pointers such as int* p, the * operator has a narrow contract, because you can only dereference a pointer when it points to a valid object, but there is no general way to verify a pointer before dereferencing it.