Modern C++ Coding Style

This post is based upon the standard - not supported with VC compiler ! Try these techniques using GCC / LLVM compilers and QtCreator / CLion IDEs

Avoid C programming style idioms 

• = rather than strcpy() for copying , == rather than strcmp() for comparing

• use const , constexpr functions rather than #DEFINE, macros

• Avoid void*, unions, and raw casts (use static_cast instead)

• use std:string instead of char*

• avoid pointer arithmetic

• To obey C linkage conventions, a C++ function must be declared to have C linkage 

Avoid C# / Java programming style idioms 

• Minimize the use of reference and pointer variables: use local and member variables

• Use abstract classes as interfaces to class hierarchies; avoid “brittle base classes,” that is, base classes with data members.

• Use scoped resource management (“Resource Acquisition Is Initialization”; RAII) 

• Use constructors to establish class invariants (and throw an exception if it can’t)

• Avoid “naked” new and delete; instead, use containers (e.g., vector, string, and map) and handle classes (e.g., lock and unique_ptr).

  
  

• minimal run-time reflection: dynamic_cast and typeid

• Namespaces are non-modular - headers can introduce name clashes - avoid using directives in header files, because it increases the chances of name clashes.

 C++11 new features 

        Constructor Controls =delete and =default

        type deduction - auto

        constant expression compile time evaluation - constexpr

        In-class member initializers

        Inheriting constructors

struct derived : base {

   using base::base; // instead of deriving multiple constructor sigs

};

        Lambda expressions

        Move semantics

        specify function may not throw exceptions - noexcept

        A proper name for the null pointer - nullptr (instead of NULL)

        The range-for statement

        Override controls: final and override

        Template Type aliases- binding arguments of another template

template<class T> struct Alloc {};

template<class T> using Vec = vector<T, Alloc<T>>;

// type-id is vector<T, Alloc<T>>

Vec<int> v; // Vec<int> is the same as vector<int, Alloc<int>>

        Typed and scoped enumerations: enum class

        Universal and uniform initialization 

        Variadic templates

        Hashed containers, such as unordered_map

        basic concurrency library components: thread, mutex, and lock

        asynchronous computation: future, promise, and async()

        regexp

        unique_ptr, shared_ptr

        tuple

        bind(), function

decltype(expr)  // reuse a type

Basics 

The stream idiom

      cout << ,   cin >> // stdio streams

 getline() // helper function for making it easier to read from stdin

  If a pointer to function is given as the second argument to <<, the function pointed to is called.  cout<<pf means pf(cout). Such a function is called a manipulator

• <sstream> istringstream - A stream that reads from a string 

• c_str() returns a C-style pointer to a zero-terminated array of characters 

determine the memory footprint of a variable, or the size of an array

        sizeof(T)

extent <decltype( T )> ::value

// size of an array must be a constant expression

 Utilize initializer lists, auto, constexpr 

        use initializer lists {} instead of =, ()       - prevents narrowing conversions

        with auto, need to use =

        prefer constexpr to const       - compile time evaluation

 iterating over a container:

v.begin() and v.end() or begin(v) and end(v)

for (const auto& x : v)            // for each x in v

for (int& x : v)        // to modify an element in a range-for loop, the element variable should be a reference

Mechanisms: pass by ref, const functions, operator overloading, subscripting

        void doSomething(MyClass& c) {} // pass by ref

        const function:         double real() const { return re; } 

        operator overload:      complex& operator+=(complex z) { re+=z.re, im+=z.im; return *this; } // add to re and im

        double& operator[](int i) { return elem[i]; } // element access: subscripting

    

A common pattern: templatized RAII Handles as custom container wrappers

          template<typename T>

        class Handle {          // Parameterized Type

        private:

                T* elem;

...

           Handle(int s) :elem{new double[s]}, sz{s}  { ... } // constructor: acquire resources, initializer_list<T>

            ~Handle() { delete[] elem; }                       // destructor: release resources

       virtual double& operator[](int) = 0;     // pure virtual function

        void doSomething(vector<Item*>& v, int x) { //  do something to all items

                for (auto p : v)

                        p–>doSomething(x);

        }

Optimal techniques to pass arguments and retvals

• pass & return references & from functions.

• never return a pointer *. can return a smart pointer.

• Return containers by value (relying on move for efficiency)

• Each time a function is called, a new copy of its arguments is created. 

• a pointer or a reference to a local non-static variable should never be returned.

• non-primative arguments should be passed as const &

• For template arguments, an rvalue reference is  used for “perfect forwarding”

  
  

• Default arguments may be provided for trailing arguments only

•  the recommended way to pass containers in and out of functions: pass Containers by reference, return them as objects by value (implicitly uses move)            

range-for over a handle

        // To support the range-for loop for a container handle, must define suitable begin() and end() functions:

        template<typename T>

        T* begin(Handle<T>& x)

        {

 functors, lambdas, variadic templates

        // functor

        bool operator()(const T& x) const { return x<val; } // call operator

bind - // forward call wrapper

        // lambda  - eg capture all by ref

        [&](const string& a){ return a<s; }

        // variadic template

        template<typename T, typename... Tail>

        void f(T head, Tail... tail)

ISO C++ standard char types 

• character types: char (8), [signed | unsigned ] char, wchar_t (unicode), char16_t (UTF), char32_t. L'AB'

• <cctype>:: isspace(), isalpha(), isdigit(), isalnum()

ISO C++ standard int types 

• integer types: [signed | unsigned] short | int | long | long long

• ::size_t x = sizeof(xxx) ; // implementation defined type

• <limits>::numeric_limits // query arithmetic type properties

initialization gotchas – narrowing, default values, initialization lists

• bool b2 {7};      // error: narrowing 

• {} indicates default value (nullptr for pointers)

• if (p) {  // equivalent to p!=nullptr

• auto - use =, because {} is deduced to std::initializer_list<T>

• The only really good case for an uninitialized variable is a large input buffer. 

• only stack variables are default initialized !

 function pointers 

• using PF = int(*)(double);  // pointer to function taking a double and returning an int

        void (*pf)(string)  = &DoSomething;  

        pf("blah");

        using F = void(*)(string);

• beware: cannot dereference or increment void*

problems with passing arrays as arguments 

• arrays cannot be copied, assigned, or passed by val

• extern "C" int strlen(const char*);       // from <string.h> - the size of the array is lost to the called function. 

• an argument of type T[] will be converted to a T* by val - preferable to pass a reference to some container

    

 Prefer references 

• must be initialized from an object / primitive,

• read only,

• object like syntax,

• used for passing by ref params / retvals

        int var = 0;

        int& rr {var};

        ++rr;               // var is incremented by 1

        int* pp = &rr;      // pp points to var

       move uses “ref ref”

        move(x) means static_cast<X&&>(x) where X& is the type of x.

Simple constructs:       

• struct, union, enum, enum class
•  enum class vs enum        

        enum class Color { red, blue, green };  auto col = Color::red;   // must be 

• struct vs class - struct can be initialized using the {} notation - order is important , no need for constructor. all members public.

 function signature keywords

[[noreturn]] virtual inline auto f(const unsigned long int *const) –> void const noexcept;

• avoid argument conversions for params: explicit // no implicit conversions 

• 2 ways to specify an inline function:A) A member function defined within the class declaration is taken to be an inline member function. B)  Use inline keyword

•  specify a static function - keyword static in declaration - is not repeated in the definition

eg

What makes a function signature unique          

• unique function signature check ignores const in params

• Function argument names are not part of the function type

• an argument is unused in a function definition by not naming it

    

Error handling

 gracefully / ungracefully halting execution 

        if (something_wrong) exit(1);

        terminate() // does not invoke destructors. calls abort()

        std::set_terminate()

quick_exit() , at_quick_exit() 

 basic guarantee vs strong guarantee 

• basic guarantee for all ops: invariants of all objects are maintained, and no resources are leaked

• strong guarantee for key ops: either the operation succeeds, or it has no effect

• nothrow guarantee for some operations

handling errors 

• errno vs <stdexcept>

• throw ex

• throw; //rethrow

• catch (std::exception& err) {

• catch (...)

Catch common exceptions in main

        catch (...) {

                cerr <<

the standard exception hierarchy 

• exception: logic_error, runtime_error,  bad_exception, bad_alloc, bad_cast, bad_typeid, 

• logic_error: length_error, domain_error, invalid_argument, out_of_range, future_error

• runtime_error: overflow_error, range_error, underflow_error, system_error, regex_error, ios_base::failure

 useful members of the exception class 

        exception::what(), current_exception(), rethrow_exception(), make_exception_ptr(), exception_ptr, nested_exception, terminate()

 catch exception& best practices for handling exceptions 

• destructors do not throw 

• can throw runtime_error in ctor

• an exception is potentially copied several times up the stack before it is caught - don’t put huge amounts of data in exception body

• innocent-looking operations (such as <, =, and sort()) might throw exceptions

• error in a thread can crash a whole program -  add a catch-all handler to main()

• The body of a function can be a try-block.

• handle RAII is neater than try catch finally

   

assertions 

  compiletime static_assert vs runtime macro <cassert> assert

       

 handling exceptions in multithreaded code    

   

packaged_task does the following:  

catch(...) { myPromise.set_exception(current_exception());

     

Source Files and Programs

 the C++ compilation and linkage process 

• A program is a collection of separately compiled units combined by a linker

• file is unit of compilation

• precompiler --> translation unit       

• A program must contain exactly one function called main()

• An entity must be defined exactly once in a program. It may be declared many times, but the types must agree exactly.

• Outside a class body, an entity must be declared before it is used 

   static vs shared libraries 

 include semantics 

        #include <iostream>     // from standard include directory

        #include "myheader.h"   // from current directory

external linkage 

external linkage - when definition is not in same TU as declaration. 

extern // used for external linkage

        #ifdef __cplusplus

        extern "C" {}   // a linkage block

…

using, constexpr, static & const not accessible from other TUs - hence extern const

best practices for reducing compile time 

• Precompiled headers - modern C++ implementations provide precompiling of header files to minimize repeated compilation of the same header.

• avoid global variables

• a header should never contain: ordinary function definitions, fields, global variables, unnamed namepsaces, using directives

• To ensure consistency (identical definition), place using aliases, consts, constexprs, and inlines in header files

• dont abuse #include

• minimize dependencies

• compiler include guards

• An unnamed namespace {} can be used to make names local to a compilation unit - internal linkage

Classes and OOP

       

A class provides 6 default methods 

by default a class provides 6 things

        class X {

             X();                     // default constructor

             X(const X&);             // copy constructor

             X(X&&);                  // move constructor

             X& operator=(const X&);  // copy assignment: clean up target and copy

             X& operator=(X&&);       // move assignment: clean up target and move

             ~X();                    // destructor: clean up

When to customise the default functions of a class:

• If a class has a virtual function, it needs a virtual destructor

•  If a class has a reference member, it probably needs copy operations

•  If a class is a resource handle, it probably needs copy and move operations, constructor, a destructor, and non-default copy operations

•  If a class has a pointer member, it probably needs a destructor and non-default copy operations

•  Don't need a copy constructor just to copy an object - objects can by default be copied by assignment. default semantics is memberwise copy.

 =default and =delete 

• if you implement custom class, for default functions that are default, specify = default;

• prevent destruction of an object by declaring its destructor =delete (or private)

  
  

• prevent slicing - Prohibit copying of the base class: delete the copy operations.

constructor call order:

• be aware that constructor is called on every copy and move

• delegating constructor - when one constructor calls another

• Constructors execute member and base constructors in declaration order (not the order of initializers)

• A constructor can initialize members and bases of its class, but not members or bases of its members or bases

• Prevent conversion of a pointer to a derived to a pointer to a base: make the base class a protected base

  
  

Defining a class

constructor initialization lists

const functions and mutable fields

friend class / functions

defining an abstract base class 

        virtual ~Base() = 0;   // abstract base class definition (.cpp)

Nested Classes

• A nested class has access to non-static members of its enclosing class, even to private members (just as a member function has), but has no notion of a current object of the enclosing class. 

• A class does not have any special access rights to the members of its nested class

 different types of initialization: default, copy, memberwise

         MyClass o1 {};                     // default initialization

        MyClass o2 {   "aaa", 77 };          // memberwise initialization

        MyClass o3 { o2 };   // copy initialization

Operator Overloading

ostream& operator<<(ostream&, const string&); 

 calling  std::cout << s; is the same as operator<<(std::cout,s);

// overload the + and += operators for a Complex number type ?   

        complex operator+(complex a, complex b) {

                return a += b; // access representation through +=.  arguments passed by value, so a+b does not modify its operands.

        inline complex& complex::operator+=(complex a) {

                re += a.re;

                im += a.im;

                return *this;

        MyClass::operator int() const { return i; }      // a conversion operator resembles a constructor

        const MyClass& operator[] (const int&) const;

        int operator()(int);

        pair<int,int> operator()(int,int);

smart pointers overload operator –>, new 

increment / decrement   operators:

        Ptr& operator++();             // prefix

        Ptr operator++(int);           // postfix

        Ptr& operator––();             // prefix

        Ptr operator––(int);           // postfix

allocator / deallocator operators - implicitly static

        void* operator new(size_t);               // use for individual object

        void* operator new[](size_t);             // use for array

        void operator delete(void*, size_t);      // use for individual object

        void operator delete[](void*, size_t);    // use for array

        constexpr complex<double> operator"" i(long double d) ;

the order of construction / destruction in a class hierarchy

• Objects are constructed from the base up and destroyed top-down from derived

• destructors in a hierarchy need to be virtual

• the constructor of every virtual base is invoked (implicitly or explicitly) from the constructor for the complete object 

• destructors are simply invoked in reverse order of construction - a destructor for a virtual base is invoked exactly once.

keywords virtual, override, final:

• override and final are compiler hints

• keywords virtual, override, final should only appear in .h files

• override - The override specifier comes last in a declaration.

• Virtual functions - vtbl efficiency within 75%

• final - can make every virtual member function of a class final - add final after the class name

        class Derived final : public Base {

         

Scope rules for deriving from a base class 

• deriving from a base class can be declared private, protected, or public

• If B is a private base, its public and protected members can be used only by member functions and friends of D. Only friends and members of D can convert a D* to a B*

• If B is a protected base, its public and protected members can be used only by member functions and friends of D and by member functions and friends of classes derived from D. Only friends and members of D and friends and members of classes derived from D can convert a D* to a B*.

• If B is a public base, its public members can be used by any function. In addition, its protected members can be used by members and friends of D and members and friends of classes derived from D. Any function can convert a D* to a B*.

       

 Best practices for abstract classes and virtual functions 

• An abstract class should have a virtual destructor 

• A class with a virtual function should have a virtual destructor;

• An abstract class typically doesn’t need a constructor

Best practices for declaring  interfaces and data members

• Prefer public members for interfaces;

• Use protected members only carefully when really needed;  a protected interface should contain only functions, types, and constants.

• Don’t declare data members protected;  Data members are better kept private & in the derived classes to match specific requirements.

Best practices deriving from a base class

• Don’t call virtual functions during construction or destruction

• Copy constructors of classes in a hierarchy should be used with care (if at all) to avoid slicing

• A derived class can override new_expr() and/or clone() to return an object of its own type

• covariant return rule - Return Type Relaxation applies only to return types that are pointers or references

• a change in the size of a base class requires a recompilation of all derived classes

       

Almost Reflection

type traits to inspect code elements 

        <type_traits>

eg is_class<X> , is_integral<X>

 eg static_assert(std::is_floating_point<T>::value ,"FP type expected");

            Add_pointer<T>

            enable_if and conditional,

            declval<X>         

Casting

Custom Allocators

Templates

 Advantages of Templates 

• faster & easier to inline - no casting , or double dispatch

• code for a member function of a class template is only generated if that member is used

• Use templates to express containers

• excellent opportunities for inlining, pass constant values as arguments --> compile-time computation.

• resembles dynamic programming with zero runtime cost

• 
  

 Limitations of templates 

• no way to specify generic constraints ... until concepts. so errors that relate to the use of template parameters cannot be detected until the template is used

• A member template cannot be virtual

• copy constructors, copy assignments, move constructors, and move assignments must be defined as non-template operators or the default versions will be generated.

• A virtual function member cannot be a template member function

• Source Code Organization: #include the .cpp definition of the templates in every relevant translation unit  long compile times

• caution is recommended when mixing object-oriented and generic techniques - can lead to massive code bloat for virtual functions

creating and using a template

        template<typename C>

        class MyClass { };

        MyClass<string> o;      // called a specialization          

Members of a template class are themselves templates parameterized by the parameters of their template class.

        template<typename C>

        MyClass<C>::MyClass() {}        // ctor

    

template compile-time polymorphism 

        template<typename T> 

        void sort(vector<T>&);          // declaration

        void f(vector<int>& vi, vector<string>& vs) {

                sort(vi);  // sort(vector<int>&);

                sort(vs);  // sort(vector<string>&);

• Function Template Arguments - Use function templates to deduce class template argument types

        template<typename T, int max>

        struct MyClass {};

        template<typename T, int max>

        void f1(MyClass<T,int>& o);

        void f2(MyClass<string,128>& o){

            f1(o);      // compiler deduces type and non-type arguments from a call, 

        }

 function template overloads 

        sqrt(2);     // sqrt<int>(int)

        sqrt(2.0);   // sqrt(double)

        sqrt(z);     // sqrt<double>(complex<double>)

 SFINAE 

A template substitution failure is not an error. It simply causes the template to be ignored;    

use enable_if to conditionally remove functions from overload resolution

           

 Template Aliases 

        using IntVector = vector<int>;   

 Best practices for implementing Templates    

• If a class template should be copyable, give it a non-template copy constructor and a non-template copy assignment - likewise for move

• Avoid nested types in templates unless they genuinely rely on every template parameter

• Define a type as a member of a template only if it depends on all the class template’s arguments

• lifting - design for multiple type arguments

 Concepts Generic Constraints 

• Estd namespace – template constraints

• Ordered<X>, Equality_comparable<T>, Destructible<T>, Copy_assignable<T>, etc

• implement a concept as a constexpr templated function with static_assert

• parameterized --> constraint checks

Passing parameters to templates 

• template Parameters can be template types, built in types, values, or other class templates!

• literal types cannot be used as template value parameters;  function templates cannot be used as template params

• can specify default types !

        template<typename Target =string, typename Source =string>

        Target to(Source arg)       // convert Source to Target

        { ... }

        auto x1 = to<string,double>(1.2);  // very explicit (and verbose)

        auto x2 = to<string>(1.2);         // Source is deduced to double

        auto x3 = to<>(1.2);               // Target is defaulted to string; Source is deduced to double

        auto x4 = to(1.2);                 // the <> is redundant

        

 partial specialization vs complete specialization

• partial specialization    curbing code bloat - replicated code can cost megabytes of code space, so cut compile and link times dramatically

• complete specialization - Specialize templates to optimize for important cases

template<> argument deduction         

        // template argument can be deduced from the function argument list, we need not specify it explicitly:

        template<>

        bool less(const char* a, const char* b)

    

techniques to reduce compilation time when implementing templates :

• Partial specialization       

• to declare a pointer to some templated class, the actual definition of a class is not needed:

        X* p;    // OK: no definition of X needed

• one explicit instantiation for a specialization then use extern templates for its use in other TUs.

 The curiously recurring template pattern (CRTP)  

a class X derives from a class template instantiation using X itself as template argument

template<class T>

class Base {

// methods within Base can use template to access members of Derived

};

class Derived : public Base<Derived> {

use for static polymorphism (generic meta-programming )

Template Metaprogramming 

• templates constitute a complete compile-time functional programming language

        constexpr

• it is achieved via type functions, iterator traits

        is_polymorphic<T>

        Conditional<(sizeof(int)>4),X,Y>{}(7);   // make an X or a Y and call it

        Scoped<T>,On_heap<T>

    

        template<typename T>

        using Holder = typename Obj_holder<T>::type;

        is_pod<T>::value

        iterator_traits

        <type_traits>

        Enable_if<Is_class<T>(),T>* operator–>();   // select a member (for classes only)

        std::is_integral and std::is_floating_point,

variadic templates 

template<typename T, typename... Args>      // variadic template argument list: one or more arguments

void printf(const char* s, T value, Args... args)    // function argument list: two or more arguments

• One of the major uses of variadic templates is forwarding from one function to another

• pass-by-rvalue-reference of a deduced template argument type “forward the zero or more arguments from t.”

        template<typename F, typename... T>

        void call(F&& f, T&&... t){

                f(forward<T>(t)...);

        }

        

        auto t = make_tuple("Hello tuple", 43, 3.15);

        double d = get<2>(t);  

    

Know the Standard-Library

        <utility> operators & pairs

        <tuple>

        <type_traits>

        <typeindex> use a type_info as a key or hashcode

        <functional> function objects

        <memory> resource management pointers

        <scoped_allocator>

        <ratio> compile time rational arithmetic

        <chrono> time utilities

        <iterator>              begin, end

        <algorithm>

        <cstdlib> bsearch(), qsort()

        <exception> exception class

        <stdexcept> standard exceptions

        <cassert> assert macro

        <cerrno> C style error handling

        <system_error> system error support            error_code, error_category, system_error

        <string>                strlen(), strcpy(),

        <cctype> character classification        atof() , atoi()

        <cwctype> wide character classification

        <cstring> C-style string functions

        <cwchar> C-style wide char functions 

        <cstdlib> C-style alloc functions

        <cuchar> C-style multibyte chars

        <regex>

        <iosfwd> forward declerations of IO fascilities

        <iostream>

        <ios> iostream bases

        <streambuf> stream buffers

        <istream> input stream template

        <ostream> output stream template

        <iomanip> Manipulator

        <sstream> streams to/from strings

        <cctype> char classification functions

        <fstream> streams to/from files

        <cstdio> printf family of IO

        <cwchar> printf family of IO for wide chars

        <locale> cultures

        <clocale> cultures C-style

        <codecvt> code conversion facets

        <limits> numerical limits

        <climits> C-style integral limits 

        <cfloat> C-style float limits 

        <cstdint> standard integer type names

        <new> dynamic memory management

        <typeinfo> RTTI

        <exception>

        <initializer_list>

        <cstddef> C-style language support        sizeof(), size_t, ptrdiff_t, NULL

        <cstdarg> variable length function args 

        <csetjmp> C-style stack unwinding         setjmp , longjmp

        <cstdlib> program termination , C-style math functions             abs() , div() 

        <ctime> system clock

        <csignal> C-style signal handling

        <complex>

        <valarray>

        <numeric>

        <cmath>        

        <random>

        <atomic>

        <condition_variable>

        <future>

        <mutex>

        <thread>

        <cinttypes> type aliases for integrals

        <cstdbool> C bool, true, false

        <ccomplex>

        <cfenv> C floating point stuff

        <ctgmath>

STL Containers

STL features:

• concepts: sequence vs associative containers; adapters, iterators, aglorithms, allocators 

• container adapters - eg stack, queue, deque - double ended queue

• Iterators are a type of pointer used to separate algorithms and containers

• push_back does a copy via back_inserter

• forward_list - SLL

• multiset / multimap - values can occur multiple times

• unordered_X

• Xstream_iterator

• How to implement a range check vector – not sure if this is good idea …

//override operator [] with at()

• prefer standard algorithms over handwritten loops

• accumulate - aggregator algo     

• valarray // matrix slicing

• unordered_map / set; multimap / set

• bitset - array of bool

• pair<T,U>  tuple<W,X,Y,Z>

• 
  

functions common to several containers:

        less<T>

        copy(), find(),  sort(), merge(), cmp(), equiv(), swap() , binary_search(),splice() 

        size(), capacity()

        at() - range checks

        emplace // nice and terse

        hash<T> - functor

const iterators, reverse iterators 

        reverse iterators: rbegin, rend

        const iterators: cbegin, cend

Container and Algorithm requirements

• To be an element type for a STL container, a type must provide copy or move operations;
• 
  
• arguments to STL algorithms are iterators, not containers

• _if suffix is often used to indicate that an algorithm takes a predicate as an additional argument.

STL common algorithms:

        lower_bound(), upper_bound(), iter_swap()

        for_each(b,e,f)

        sequence predicates: all_of(b,e,f) , any_of(b,e,f) none_of(b,e,f)

        count(b,e,v) , count_if(b,e,v,f)

        isspace()

        find_if(b,e,f)

        equal(b,e,b2)

        pair(p1,p2) = mismatch(b,e,b2)

        search(b,e,b2,e2)        // find a subsequence

        transform(b,e,out,f)

        copy(b,e,out), move(b,e,out)

        copy_if(b,e,out,f)

        unique, unique_copy

        remove() and replace()

        reverse()

        rotate(), random_shuffle(), and partition() - seperates into 2 parts

        next_permutation(), prev_permutation() , is_permutation() - generate permutations of a sequence

        fill(), generate_n(), uninitialized_copy, uninitialized_fill assigning to and initializing elements of a sequence. (unitialized_ is for low level objects that are not initialized)

        swap(), swap_ranges(), iter_swap()

        sort(), stable_sort() - maintain order of equal elements, partial_sort()

        binary_search() - search sequence that is pre-sorted

        merge() - combine 2 pre-sorted sequences

        set_union, set_intersection, set_difference

        lexicographical_compare() - order words in dictionaries

        min & max

        Use for_each() and transform() only when there is no more-specific algorithm for a task

Iterating over a container       

  [b:e) end points to the one-beyond-the-last element of the sequence. 

        Never read from or write to *end. 

        the empty sequence has begin==end;

        while (b!=e) {       // use != rather than <

                // do something

                ++b;   // go to next element

        }

Iterator operations 

            input (++ , read istream), output (++, write ostream), forward (++ rw), bidirectional(++, --), random access

        iterator_traits - select among algorithms based on the type of an iterator

        ++p is likely to be more efficient than p++.

 3 insert iterators:

            insert_iterator - inserts before the element pointed to using insert().

            front_insert_iterator - inserts before the first element of a sequence using push_front().

            back_insert_iterator - inserts after the last element of the sequence using push_back().

 efficiently moving items from one container to another 

        copy(c1,make_move_iterator(back_inserter(c2)));    // move strings from c1 into c2

 getting an iterator from a reverse_iterator 

    Use base() to extract an iterator from a reverse_iterator

       

raw array vs array type 

• T[N], array<T,N>

• Use array where you need a sequence with a constexpr size

• Prefer array over built-in arrays

 bitset<N> vs vector<bool>

• bitset<N>, vector<bool>

• Use bitset if you need N bits and N is not necessarily the number of bits in a built-in integer type

• Avoid vector<bool>

 pair vs tuple

• pair<T,U>, tuple<T...>

• When using pair, consider make_pair() for type deduction

• When using tuple, consider make_tuple() for type deduction

• tie() can be used to extract elements from a tuple as out params

basic_string<C>, valarray<T> Posted on Wednesday, October 8, 2014 7:53 AM C++ | Back to top