Incrementar un iterador de un vector<MyClass>

[dmorill]

Hola eferion, no quiero ser pesado y sé que te agradezco en cada respuesta pero creo que es necesario. Gracias por responder ya que puedo seguir aprendiendo de tu conocimiento .

Iniciado por eferion

Código C++:

struct Punto{
  int x;
  int y;
 
  Punto(int x=0, int y=0) : x(x), y(y){ }
};
 
int main(){
  Punto p = 1;
  
  std::cout << "(" << p.x << "," << p.y << ")" << std::endl;
}
 

[

Me he quedado de piedra, no debería compilar pues según entiendo el "="no está definido para esas estructuras. (creo que a eso se le llama sobrecarga, definir un uso al operador "="). Tuve que compilarlo yo mismo y si de hecho funciona, que peligro usarlo así de ese modo, por qué permite c++ eso? Cambie el struct por un class y ya no compila, es decir que solo es para estructuras.

Iniciado por eferion

Con lo que expones no veo motivo para que esa función exista. Si necesitas iterar sobre un vector no hay necesidad de llamar a una función. Tendrás que poner un caso de uso más concreto que explique la necesidad de usar esa función... y algo de código también sería de agradecer.
[

El código es super largo pero pondré lo respecto a la pregunta, si quieres el resto solo de dices y con gusto lo pongo todo. Te describo lo que estaba haciendo.

Imagina que tengo los nodos a. de la siguiente gráfica:


Sé que la siguiente explicación es larga y eso que no pongo todo jeje espero no aburrirte:

Y quiero encontrar todos los posibles ciclos, para ello hay que hacer de dos algoritmos, el primero (kosajaru algorithm) nos permite encontrar los componentes fuertemente conexas, es decir aquellos nodos en los que se pueden ir de uno a otro. en el ejemplo en b. nos muestra el el algoritmo encontró 3 componente fuertemente conexas (CFC). El segundo (johnson algorihtm) permite encontrar todos los ciclos de una CFC.
luego de que el algoritmo de johson encuentra los ciclos de una componente, borra un nodo y pide calcular de nuevo las CFC de ese nuevo grafo sin un nodo.

En el algoritmo de johnson lo que hace es una especie de arbol para recorrer todos los nodos y de cada uno de ellos sus nodos adyacentes. primero se selecciona por ejemplo el primer vecino hasta que se revisa si es o no ciclo luego de regresa al nodo anterior y se va por el siguiente vecino.

Código C++:

include <iostream> 
#include <vector>
 
using namespace std;
 
 
class nodo{
private:
    int _id;
    vector<int> _vVecinos;   //vector con los vecinos adyacentes del nodo
    // por ejemplo nodo 3 tiene vecinos 2,4 y 6
    // otros atributos
public:
    nodo(int id, vector<int>& v) { _id = id; _vVecinos = v; }   //constructor para el ejemplo
    //otras funciones miembro
};
 
vector<vector<nodo>> kosajaru(vector<nodo>& vNodos);    
//enctrega un vector donde cada componente es un                                            
//conjunto de nodos según nuestro ejemplo al principo es así                                            
// 0 {1, 2, 3, 4, 5, 6}                                         
// 1 {8, 9}                                         
// 2 {7}
 
vector<int>::iterator nextVecino(vector<int>::iterator itAct, vector<int>& vVecino, vector<int>::iterator itNULL){
    if (*itAct == *itNULL){   // para saber si es la primera vez que pido vecino.
        return vVecino.begin();
    }else{
        return itAct + 1;   //se supone que esto es itAct++ pero no me funciona así jeje.
    }
}
 
int main(){
    //lectura de datos de todos los nodos, pongo uno como ejemplo
    vector<int> v{ 2, 4, 6};    //estos son int pero podrían ser nodos
    nodo n(3, v);
    vector<nodo> vNodos{nodo(3,v)}; //este debe tener todos los nodos
    //
    vector<vector<nodo>> CFC = kosajaru(vNodos);
 
    while (CFC.empty() == false){   //cada vez el CFC queda con menos componentes hasta que queda vacío
        // aqui va el algoritimo de johson y es aqui donde nicesito lo del iterador que hice como te comenté
        // necesito recorrer cada componente la priemra tiene los nodos 1,2,3,4,5,6 y cada nodo tiene su
        // vector de vecinos que debo recorrer pero guardando en un vector de stack el ciclo que voy probando
        // y también debo recordar en que vecino voy para el algoritmo así que cree un vector
        //  punteros donde la pocición del vector es el vecino del nodo del stack.
        // Todo es mejor con un ejemplo por ejemplo primero defino mi origen en 1 y lo pongo en el stack
        // , luego veo sus vecinos, seleccionó uno y lo pongo en en mi stack y ahora veo los vecínos de éste 
        // y así, pero cuando regrese debo recordar qué vecino iba para seleccionar el siguiente. Aquí esta 
        // dicha función next de la que te hable. 
        //stack ejemplo: {1,2,3,6,4,5} esto es un posible ciclo que estoy revisando
        //vector de iteradores ejemplpo: {2*,3*,6*,4*,5*,1*} donde por ejemplo 2* es la dirección del vecino
        // del vector de vecinos del nodo 1. 
        vector<vector<int>::iterator> vit;
        vector<int> stack();
        //entonces cuando regreso yo solo le pregunto en que vecino va y que me de el siguiente, con la función nextVecino.
        
        //resto del codigo jeje
    }
 
    cin.get();
}
 

No sé si quedo más claro jeje. Si quieres más información con gusto te la pongo, pero no quiero extender tanto el tema para que sea más fácil de leer pues valoro tu tiempo.

saludos,