c++ - una - habilitar calculo iterativo excel

¿Por qué std:: search necesita enviarlo?

Question

mi problema es idéntico al siguiente hilo, me cuesta entender las respuestas dadas, o más bien mi código no debería funcionar, ya que solo usa los iteradores de entrada ... pero parece que mi func funciona y se comporta de forma idéntica a std :: search. .so que estoy perdido y detesto seguir adelante sin entender bien ... tal vez si alguien puede sugerir una entrada que rompa mi función, pero no la de std ::

De ¿Por qué necesito un revisor por adelantado para implementar mi std :: búsqueda personalizada ?

Estoy estudiando el libro "Acelerado C ++" de Koenig & Moo.

El ejercicio 8-2 me pide que implemente por mi cuenta algunas funciones de funciones de <algorithm> y <numeric>, y que especifique qué tipo de iterador requiere mi implementación.

Al intentar implementar std :: search, determiné que solo necesito iteradores de "entrada".

Sin embargo, mirando la implementación de std :: search instalada con mi compilador, puedo ver que usan iteradores "hacia adelante", pero no puedo entender por qué, porque no hay necesidad de escribir, solo leer, y los iteradores de entrada cumplen con el requisito.

¿Puede alguien aquí ayudarme a entender esto, por favor? ¿Por qué necesitaría usar iteradores "forward" para implementar std :: search?

Gracias por adelantado.

myfunction:

template <class In>
In search( In begin, In end, In begin2, In end2 )
{
In found ; // iter: 1st element in pattern match(in content)
In pattern_begin = begin2 ; // iter: 1st element in search pattern.
int flag = 0 ; // flag: partial match found?
// search content for pattern
while ( begin < end ) {
// if pattern-match fails ..reset vars
// & continue searching remaining content/elements
if ( *begin != *begin2 ) {
In ret ;
begin2 = pattern_begin ;
flag = 0 ;
begin++ ;
} else {
// compare next element in pattern with next element in content.
// if: 1st element of ''pattern'' is found, store iter to it''s pos
// ..then if entire pattern is found, we can ret an iter to where it starts
if ( flag == 0 ) {
found = begin ;
flag = 1 ;
}
// inc iters to compare next elements in partial match
begin++ ;
begin2++ ;
}
// if: iter is 1-past end of search pattern
// then entire pattern has been found
// return the iter to where it starts
if( begin2 == end2 ) { return found ; }
}
// end of content reached, no complete pattern found
// begin should? equal an iter 1-past the end of content
return begin ;
}

conductor:

///* // Driver: custom::search( b, e, b2, e2 )
#include <string>
#include <vector>
#include <iostream>
//#include <algorithm>
#include "library_algorithms.h"
int main() {
// init string test
std::string content = "fo The fox foxu jumped foxe foxy " ;
std::string search_pattern = "foxy" ;
// func test on string
std::string::iterator ret_iter =
custom::search( content.begin(), content.end(), search_pattern.begin(), search_pattern.end() ) ;
//std::search( content.begin(), content.end(), search_pattern.begin(), search_pattern.end() ) ;
// output
if ( ret_iter != content.end() ) {
std::cout << std::endl << std::endl << search_pattern << ": found at position: " << int( ret_iter - content.begin() ) << std::endl;
} else {
std::cout << std::endl << std::endl << search_pattern << ": ...not found" << std::endl;
}
// Init vec test:
// create content values in range: 10 20 30 <......> 9970 9980 9990
std::vector<int> myvector;
for (int i=1; i<1000; i++) myvector.push_back(i*10);
// create pattern values to search for
std::vector<int> pattern ;
pattern.push_back( 3730 ) ;
pattern.push_back( 3740 ) ;
pattern.push_back( 3750 ) ;
pattern.push_back( 3760 ) ;
// test: func on vector<int>
std::vector<int>::iterator it;
it = custom::search ( myvector.begin(), myvector.end(), pattern.begin(), pattern.end() );
// output
if (it!=myvector.end())
std::cout << std::endl << std::endl << "pattern found at position " << int(it-myvector.begin()) << std::endl;
else
std::cout << std::endl << std::endl << "pattern not found" << std::endl;
return 0 ;
}

Answer 1

Has entendido mal lo que puede hacer un iterador de entrada.

No puede "guardar" o copiar un iterador de entrada. Le permite recorrer la secuencia exactamente una vez. En otras palabras, esta línea, entre otras, se romperá: begin2 = pattern_begin .

Un iterador de entrada puede representar algo que no puede "rebobinar" fácilmente, como, por ejemplo, la secuencia de datos recibidos de un adaptador de red. Un iterador que apunta a "6 elementos atrás" ya no es significativo, porque es posible que esos datos ya no estén disponibles en la memoria. Solo tienes la posición actual en la transmisión.

Debería ser obvio que para implementar la search correctamente, necesita poder recorrer partes de la secuencia más de una vez.