COMS W4995 C++ for C Programmers

Index of 2025-1/code/10

Parent directory
Makefile
concept.cpp
itraits.cpp

Makefile

CC  = g++
CXX = g++

CFLAGS   = -g -Wall
CXXFLAGS = -g -Wall -std=c++20

executables = itraits concept

.PHONY: default
default: $(executables)

itraits: itraits.o

concept: concept.o

.PHONY: clean
clean:
	rm -f *~ a.out core *.o $(executables)

.PHONY: all
all: clean default

concept.cpp

#include <array>
#include <vector>
#include <deque>
#include <list>
#include <forward_list>
#include <iostream>
#include <iterator>
#include <algorithm>
using namespace std;

template <bidirectional_iterator I>
void MyReverse(I b, I e) {
    while ((b != e) && (b != --e)) {
        std::iter_swap(b,e);
        ++b;
    }
}

template <input_iterator I>
void MyReverse(I b, I e) {
    throw invalid_argument("BidirectionalIterator required");
}

template <typename I>
void MyReverse(I b, I e) {
    throw invalid_argument("You are not even trying...");
}

int main() {
    try {
        list v { 100, 101, 102, 103, 104 };

        //forward_list v { 100, 101, 102, 103, 104 };

        MyReverse(v.begin(), v.end());

        //MyReverse(100, 200);

        copy(v.begin(), v.end(), ostream_iterator<int>{cout, "\n"});
    } catch (const exception& e) {
        cerr << e.what() << '\n';
    }
}

/*  Lecture outline:

1.  Concepts in C++20

    - We can write "template <bidirectional_iterator I>" instead of
      "template <typename I>"

    - See the definistion of the concept bidirectional_iterator:

        https://en.cppreference.com/w/cpp/iterator/bidirectional_iterator
*/

itraits.cpp

#include <array>
#include <vector>
#include <deque>
#include <list>
#include <forward_list>
#include <iostream>
#include <iterator>
#include <algorithm>
using namespace std;

// MyReverse, simple version

template <typename I>
void MyReverse_simple(I b, I e) {
    while ((b != e) && (b != --e)) {
        std::iter_swap(b,e);
        ++b;
    }
}

// MyReverse, smart version

template <typename I>
void __doMyReverse(I b, I e, bidirectional_iterator_tag) {
    while ((b != e) && (b != --e)) {
        std::iter_swap(b,e);
        ++b;
    }
}

template <typename I>
void __doMyReverse(I b, I e, forward_iterator_tag) {
    throw invalid_argument("BidirectionalIterator required");
}

template <typename I>
void MyReverse(I b, I e) {
    __doMyReverse(b, e, typename I::iterator_category());
    
    // The following change makes this work for C pointers as well because
    // iterator_traits<T*>::iterator_category = random_access_iterator_tag
    //
    // __doMyReverse(b,e,typename iterator_traits<I>::iterator_category())
}

int main() {
    try {
        list v { 100, 101, 102, 103, 104 };
        // forward_list v { 100, 101, 102, 103, 104 };
        // deque v { 100, 101, 102, 103, 104 };

        MyReverse_simple(v.begin(), v.end());
        // MyReverse(v.begin(), v.end());

        copy(v.begin(), v.end(), ostream_iterator<int>{cout, "\n"});
    } catch (const exception& e) {
        cerr << e.what() << '\n';
    }
}

/*  Lecture outline:

1.  MyReverse_simple() does not work on forward_list as expected

    - Would it be possible to have a little more helpful error message?
      More generally, can template code do different things depending on
      what type parameters are passed?

2.  A small taste of Template Metaprogramming: tag dispatching

    - MyReverse() calls different versions of __doMyReverse() depending on
      the "Container<T>::iterator::iterator_category" type

    - xxx_iterator_tag class hierarchy

    - iterator_traits<I> and template specialization
*/