Incrementar un iterador de un vector<MyClass>

[dmorill]

Hola eferion muchas gracias por tu tiempo estoy aprendiendo mucho de tus comentarios.

Las funciones lambda y el mantenimiento me ha quedado muy claro. Son cosas que no sabía y iré incluyéndolo en mis programas.

Iniciado por eferion

explicit es un modificador que se pone en los constructores (y en los operadores de conversión para C++11 en adelante). Al añadir esta palabra a un constructor evitamos que se realicen conversiones implícitas. Por ejemplo:

Código C++:

struct Foo{
  Foo(int v): valor(v) { }
 
  int valor;
};
 
struct Foo2{
  explicit Foo2(int v): valor(v)  { }
  
  int valor;
};
 
void func(Foo foo){ 
 std::cout << foo.valor << std::endl; 
}
 
void func2(Foo2 foo){ 
 std::cout << foo.valor << std::endl; 
}
 
int main(){
  // Compila. Se llama de forma implícita a Foo(int)
  func(1);
 
  // No compila. La llamada a Foo2(int) ha de indicarse de forma explícita.
  func2(1);
 
  // Compila
  func2(Foo2(1));
}
 

Esta palabra evita que se realicen determinadas operaciones de forma colateral. Nos obliga a indicar de forma explícita las conversiones lo que hace que seamos un poco más conscientes de qué es lo que realmente se está ejecutando.

Un saludo.

Los explicit no los entendí del todo, en el ejemplo que me diste (modifiqué los espacios a los que yo estoy más acostumbrado jeje) en las dos estructuras definiste un constructor idéntico salvo por el explicit (llamando a una función valor(v), que no las has definido pero al tener el nombre de la atributo de la estructura supongo que es una asignación), y al usarlo también se hace de forma idéntica, donde está lo diferente? solo es a nivel de compilación?

Una pregunta aprovechando que estamos hablando de iteradores, cree una función cuya declaración es:

Código C++:

vector<int>::iterator next(vector<int>& v, vector<int>::iterator it);
 

Y lo que hace es que si se llama por primera vez retorna v.begin(); y sino retorna it +1 (intenté usar it++ pero me retornaba el anterior sin sumarle uno). El problema está en como identificar ese "por primera vez"para lo cual lo que pensé fue, cuando creo un iterador que debo pasarlo como argumento la primera vez puedo hacer que éste sea un iterador uno así:

Código C++:

vector<int>::iterator it2 = 0;  // o NULL
 

Y dentro de la función next me pregunto si ese iterador es nulo, en tal caso retorna v.begin(); sino pues le suma al iterador y lo devuelve. La cosa es que no se puede hacer esa asignación del 0 o NULL al iterador de un vector. Al final me toco crear otro vector y tomarlo como referencia y no usarlo sino para apuntar a él al principio. Cómo lo habrías hecho?

saludos,