deque-blog

RandomAccessIterator<LinkedListIterator>
BidirectionalIterator<VectorIterator>

deque-blog

template<typename Iterator, typename Distance>
void advance(BidirectionalIterator<Iterator>& it, Distance n)
{
   // Bidirectional implementation	
}

template<typename Iterator, typename Distance>
void advance(RandomAccessIterator<Iterator>& it, Distance n)
{
   // Random access implementation	

deque-blog

struct LinkedListIterator
{
   // No tag here
};

struct VectorIterator
{
   // No tag here
};

deque-blog

struct LinkedListIterator
{
   using iterator_category = std::bidirectional_iterator_tag;
};

struct VectorIterator
{
   using iterator_category = std::random_access_iterator_tag;
};

deque-blog

template<typename Iterator, typename Distance>
void advance(Iterator& it, Distance n, std::bidirectional_iterator_tag)
{
   // Bidirectional implementation
}

template<typename Iterator, typename Distance>
void advance(Iterator& it, Distance n, std::random_access_iterator_tag)
{
   // Random access implementation

deque-blog

// O(n) complexity
std::advance(linkedList.begin(), n);

// O(1) complexity (taking advantage of random access iterator)
std::advance(vector.begin(), n);

deque-blog

class MyClass
{
public:
    enum ContructionWay {ConstructThisWay, ConstructThatWay};
    explicit MyClass(ContructionWay);
    // ...
};

MyClass x(MyClass::ConstructThisWay);

deque-blog

std::vector<MyClass> xs;
std::generate_n(std::back_inserter(xs), n, MyClass::constructThisWay);

deque-blog

class MyClass
{
public:
    static MyClass constructThisWay();
    static MyClass constructThatWay();
    // ...
};

auto x = MyClass::constructThatWay();

deque-blog

class MyClass
{
public:
    static struct ConstructThisWay{} constructThisWay;
    static struct ConstructThatWay{} constructThatWay;
 
    explicit MyClass(ConstructThisWay);
    explicit MyClass(ConstructThatWay);
    // ...
};