Георгий Гуминов's questions

Eu estava experimentando com std::iterator_traitsand std::views::iota. E de repente descobri que std::iterator_traitsreturn unexpected type para uma categoria de iterador.

libc++:

#include <ranges>

int main() {
    auto view = std::views::iota(0ULL, 10000000000ULL);

    static_assert(
      std::is_same_v<
        std::iterator_traits<decltype(view.begin())>::iterator_category
      , std::input_iterator_tag>
    );
}

libstdc++:

#include <ranges>

int main() {
    auto view = std::views::iota(0ULL, 10000000000ULL);

    static_assert(
      std::is_same_v<
        std::iterator_traits<decltype(view.begin())>::iterator_category
      , std::output_iterator_tag>
    );
}

Qual a razão para isso? Por que a categoria de características difere de std::random_access_tag?

Tenho uma classe com método sobrecarregado:

#include <iostream>
#include <utility>

struct Overloads {
    void foo() {
        std::cout << "foo" << std::endl;
    }

    void foo() const {
        std::cout << "const foo" << std::endl;
    }
};

Eu sei que posso trabalhar com ponteiros para funções membro ( &Overloads::foo). Como a função está sobrecarregada aqui, static_castdeve ser feito um:

int main() {

    auto overloads = Overloads{};

    auto foo_func = static_cast<void (Overloads::*)()>(&Overloads::foo);

    (overloads.*foo_func)();  // foo is printed - as expected

    // No idea where to put const and why:
    // auto const_foo_func = static_cast<void (Overloads::*) ()>(&Overloads::foo);

    //(overloads.*const_foo_func)();  // const foo output is expected
}

Entendi, como obter um functor para foo não-const. Como posso obter um para sobrecarga de foo const?

Implementei um exemplo de iterador que conta cada incremento:

#include <vector>
#include <iostream>
#include <algorithm>
#include <iterator>

template <class IteratorCategory = std::vector<int>::iterator::iterator_category>
class DereferenceCountingIterator : public std::vector<int>::iterator {
  public:
    using iterator_category = IteratorCategory;
  public:
    static std::size_t increaseCnt;

    DereferenceCountingIterator(
        typename std::vector<int>::iterator iter)
            : std::vector<int>::iterator(iter) {}

    auto& operator++() {
      ++increaseCnt;
      return std::vector<int>::iterator::operator++();
    }

    DereferenceCountingIterator<IteratorCategory> operator+(difference_type diff) {
        return static_cast<std::vector<int>::iterator&>(*this).operator+(diff);
    }
};

Esta classe de modelo pode funcionar tanto como RandomAccess quanto como iterador de entrada:

template<class IteratorCategory>
std::size_t DereferenceCountingIterator<IteratorCategory>::increaseCnt = 0;

using RandomAccessDereferenceContingIterator = DereferenceCountingIterator<>;
using NonRandomAccessDereferenceContingIterator
    = DereferenceCountingIterator<std::input_iterator_tag>;

O aplicativo com um exemplo:

int main() {
    auto vec = std::vector<int>{3, 4, 5};

    auto rAVecBegin = RandomAccessDereferenceContingIterator(vec.begin());
    auto nonRAVecBegin = NonRandomAccessDereferenceContingIterator(vec.begin());

    {
        const auto incBefore = RandomAccessDereferenceContingIterator::increaseCnt;
        auto out = std::vector<int>{};
        std::copy_n(rAVecBegin, 3, std::back_inserter(out));
        const auto incAfter = RandomAccessDereferenceContingIterator::increaseCnt;
        std::cout << incAfter - incBefore << std::endl;
    }

    {
        const auto incBefore = NonRandomAccessDereferenceContingIterator::increaseCnt;
        auto out = std::vector<int>{};
        std::copy_n(nonRAVecBegin, 3, std::back_inserter(out));
        const auto incAfter = NonRandomAccessDereferenceContingIterator::increaseCnt;
        std::cout << incAfter - incBefore << std::endl;
    }


    return 0;
}

A saída deste programa é a seguinte (in libstdc++e libc++):

3
2

Posso ter certeza de que isso aumenta copy_nexatamente n-1o iterador de origem se não for RandomAccessIterator e naumenta se for?