Łącząc C++ standardowych algorytmów poprzez zapętlenie tylko raz

Question

Obecnie mam ten kod i działa:

string word="test,"; 
string::iterator it = word.begin(); 
for (; it != word.end(); it++) 
{ 
    if (!isalpha(*it)) { 
     break; 
    } 
    else { 
     *it = toupper(*it); 
    } 
} 
word.erase(it, word.end()); 
// word should now be: TEST 

chciałbym uczynić go bardziej zwarty i czytelny go:

1. Komponowanie istniejącej standardowej C++ algorytmów (*)
2. Wykonać pętli tylko raz

(*) mi zakładając, że c ombining istniejących algorytmów sprawia, że ​​mój kod bardziej czytelny ...

Alternatywnym rozwiązaniem

Oprócz definiowania algorytmu zwyczaj transform_until, jak sugeruje jrok, może to być możliwe określenie adaptera zwyczaj iterator że iterację korzystania podstawowym iteratorem, ale przedefiniuj operatora *(), modyfikując bazowe odniesienie przed zwróceniem go. Coś takiego:

template <typename Iterator, typename UnaryFunction = typename Iterator::value_type (*)(typename Iterator::value_type)> 
class sidefx_iterator: public std::iterator< 
         typename std::forward_iterator_tag, 
         typename std::iterator_traits<Iterator>::value_type, 
         typename std::iterator_traits<Iterator>::difference_type, 
         typename std::iterator_traits<Iterator>::pointer, 
         typename std::iterator_traits<Iterator>::reference > 
{ 
    public: 
    explicit sidefx_iterator(Iterator x, UnaryFunction fx) : current_(x), fx_(fx) {} 

    typename Iterator::reference operator*() const { *current_ = fx_(*current_); return *current_; } 
    typename Iterator::pointer operator->() const { return current_.operator->(); } 
    Iterator& operator++() { return ++current_; } 
    Iterator& operator++(int) { return current_++; } 
    bool operator==(const sidefx_iterator<Iterator>& other) const { return current_ == other.current_; } 
    bool operator==(const Iterator& other) const { return current_ == other; } 
    bool operator!=(const sidefx_iterator<Iterator>& other) const { return current_ != other.current_; } 
    bool operator!=(const Iterator& other) const { return current_ != other; } 
    operator Iterator() const { return current_; } 

    private: 
    Iterator current_; 
    UnaryFunction fx_; 
}; 

Oczywiście jest to nadal bardzo surowy, ale powinny dać pomysł. Z powyższej karty, mógłbym wtedy napisać następujące:

word.erase(std::find_if(it, it_end, std::not1(std::ref(::isalpha))), word.end()); 

z następujących zdefiniowane wcześniej (co może być uproszczona przez jakiś szablon magii):

using TransformIterator = sidefx_iterator<typename std::string::iterator>; 
TransformIterator it(word.begin(), reinterpret_cast<typename std::string::value_type(*)(typename std::string::value_type)>(static_cast<int(*)(int)>(std::toupper))); 
TransformIterator it_end(word.end(), nullptr); 

Jeśli średnia obejmowałyby takiego adaptera użyłbym, ponieważ oznaczałoby to, że był bezbłędny, ale ponieważ tak nie jest, prawdopodobnie zachowam pętlę taką, jaka jest.

Taki adapter pozwoli na ponowne wykorzystanie istniejących algorytmów i mieszanie ich w inny sposób nie jest możliwe dzisiaj, ale może mieć także wady, które ja prawdopodobnie widokiem na chwilę ...

Answer 1

Nie sądzę, jest to czysty sposób, aby to zrobić z jednym standardowym algorytmu.Żadna, o której wiem, nie bierze predykatu (potrzebujesz jednego, aby zdecydować, kiedy przerwać) i pozwala modyfikować elementy sekwencji źródłowej.

Możesz napisać swój własny ogólny algorytm, jeśli naprawdę chcesz zrobić to w "standardowy" sposób. Nazwijmy to, hmm, transform_until:

#include <cctype> 
#include <string> 
#include <iostream> 

template<typename InputIt, typename OutputIt, 
     typename UnaryPredicate, typename UnaryOperation> 
OutputIt transform_until(InputIt first, InputIt last, OutputIt out, 
         UnaryPredicate p, UnaryOperation op) 
{ 
    while (first != last && !p(*first)) { 
     *out = op(*first); 
     ++first; 
     ++out; 
    } 
    return first; 
} 

int main() 
{ 
    std::string word = "test,"; 
    auto it = 
    transform_until(word.begin(), word.end(), word.begin(), 
        [](char c) { return !::isalpha(static_cast<unsigned char>(c)); }, 
        [](char c) { return ::toupper(static_cast<unsigned char>(c)); }); 
    word.erase(it, word.end()); 
    std::cout << word << '.'; 
} 

Jest wątpliwe, czy ten jest lepszy niż to, co masz :) Czasami zwykły dla pętli jest najlepszy.

Answer 2

Po lepszego zrozumienia Twoje pytanie, mam pomysł, który może działać, ale wymaga Boost.

można użyć transform_iterator który nazywa toupper na wszystkich znaków i użyć jej jako inputiterator do find_if lub remove_if. Nie jestem wystarczająco zaznajomiony z Boostem, aby podać przykład.

Jak @jrok wskazuje, transform_iterator tylko transformuje wartość podczas iteracji i nie modyfikuje oryginalnego kontenera. Aby obejść ten problem, zamiast obsługiwać tę samą sekwencję, należy skopiować do nowej, używając czegoś takiego jak remove_copy_if. Kopiuje tak długo, dopóki predykat NIE jest prawdziwy, więc potrzebowałby std::not1. To zastąpi obudowę remove_if.

Użyj polecenia std::copy, aby kopiować, dopóki iterator nie zostanie zwrócony przez std::find_if, aby druga sprawa mogła działać.

Na koniec, jeśli wyjściowy ciąg znaków jest pusty, do jego wyniku potrzebny będzie iterator typu std::inserter.