¿Cómo requiero semantics const_iterator en una firma de función de plantilla?

Question

Estoy creando un constructor que tomará un par de iteradores de entrada. Quiero que la firma del método para tener tiempo de compilación const semántica similar a:

DataObject::DataObject(const char *begin, const char *end) 

Sin embargo, no puedo encontrar ningún ejemplo de esto. Por ejemplo, el constructor de mi rango de aplicación de STL para vector se define como:

template<class InputIterator> 
vector::vector(InputIterator first, InputIterator last) 
{ 
    construct(first, last, iterator_category(first)); 
} 

que no tiene tiempo de compilación const garantías. iterator_category/iterator_traits<> no contienen nada relacionado con const, tampoco.

¿Hay alguna manera de indicar para garantizar al llamante que no puedo modificar los datos de entrada?

edición, 2010-02-03 16:35 UTC

Como un ejemplo de cómo me gustaría utilizar la función, me gustaría ser capaz de pasar un par de punteros char* y saber, en función de la firma de la función, los datos a los que apuntan no se modificarán.
Esperaba poder evitar crear un par de punteros const char* para garantizar la semántica de const_iterator. Puedo ser obligado a pagar el impuesto de plantilla en este caso.

Answer 1

simplemente podría crear una función ficticia que llama a su plantilla con char * const punteros. Si su plantilla intenta modificar sus objetivos, entonces su función ficticia no se compilará. A continuación, puede poner dicho maniquí dentro de las guardias #ifndef NDEBUG para excluirlo de las versiones de lanzamiento.

Answer 2

¿Qué hay de

#include <vector> 

template <class T> 
class MyClass{ 
public: 
    MyClass(typename T::const_iterator t1,typename T::const_iterator t2){ 
    } 
    // *EDITED*: overload for pointers (see comments) 
    MyClass(const T* t1,const T* t2){ 
    } 
}; 

void main(){ 
    std::vector<int> v; 
    std::vector<int>::const_iterator it1 = v.begin(); 
    std::vector<int>::const_iterator it2 = v.end(); 
    MyClass<std::vector<int> > mv(it1,it2); 

    // with pointers: 
    char* c1; 
    char* c2; 
    MyClass mc(c1,c2); 
} 

Answer 3

que Vector constructor está recibiendo sus argumentos por valor, lo que significa que los iteradores de quien llama se copian antes de ser utilizados en el constructor, que por supuesto significa que no pasa nada a los iteradores de quien llama.

const para argumentos de entrada solo importa cuando pasa por referencia. p.ej.

void foo(int& x)

vs

void foo(const int& x)

En el primer ejemplo, la entrada del llamante para x puede ser modificado por foo. En el segundo ejemplo, puede que no, ya que la referencia es const.

Answer 4

El que llama puede simplemente usar la plantilla con const iterators. Si lo hace, y el compilador no se queja, se garantiza que la función no modifique los datos. Si modificaría los datos, crear una instancia de la plantilla con un iterador de const derivaría en errores.

Realmente no tiene que forzar la persona que llama para utilizar iteradores const simplemente porque no modifica nada.

Answer 5

Esto es fácil (pero no bastante) si no puede pagar impulso:

#include <boost/static_assert.hpp> 
#include <boost/type_traits.hpp> 

template<class It> 
void f(It b, It e) 
{ 
    using namespace boost; 
    typedef typename std::iterator_traits<It>::reference reference; 
    BOOST_STATIC_ASSERT(is_const<typename remove_reference<reference>::type>::value); 
} 

void test() 
{ 
    f((char const*)0, (char const*)0); // Compiles 
    f((char*)0, (char*)0); // Does not compile 
} 

EDITAR: si usted quiere tener e indicación acerca de esto en su firma, entonces es común para explotar el nombre de la parámetro de plantilla:

template<class ConstIt> 
void f(ConstIt b, ConstIt e) 
...