Lines Matching full:efficient
164 efficient to use the ``InstVisitor`` class to dispatch over the instruction
241 class is an efficient way for APIs to accept concatenated strings. For example,
514 * a :ref:`map-like <ds_map>` container if you need efficient look-up of a
515 value based on another value. Map-like containers also support efficient
517 generally do not support efficient reverse mapping (values to keys). If you
518 need that, use two maps. Some map-like containers also support efficient
524 containers support efficient iteration through the elements in sorted order.
527 * a :ref:`sequential <ds_sequential>` container provides the most efficient way
529 They permit duplicates and support efficient iteration, but do not support
530 efficient look-up based on a key.
535 * a :ref:`bit <ds_bit>` container provides an efficient way to store and
609 ``vector<Type>``: it supports efficient iteration, lays out elements in memory
610 order (so you can do pointer arithmetic between elements), supports efficient
611 push_back/pop_back operations, supports efficient random access to its elements,
626 SmallVector also provides a nice portable and efficient replacement for
697 properties, but it also provides efficient access to the front of the list. It
715 In exchange for this high cost, std::list supports efficient access to both ends
891 SmallVector. Each of these cases has an efficient implicit conversion to
956 are much more efficient than intermediate std::string temporaries, and they work
1033 representation that guarantees efficient access (for most types, it falls back
1051 efficient access (constant time insertion/deleting/queries with low constant
1096 elements sharing a key. It is often a more efficient choice than using composite
1158 important property that this provides is efficient insertion with uniquing
1243 uses std::lower_bound to get efficient log(n) lookup) should only compare the
1267 efficient for lookups, the hash value of strings in buckets is not recomputed
1462 more space efficient than BitVector when the set is sparse, as well as making
1626 this is a constant time operation (very efficient). The following code snippet
