Vector de punteros cuando muda a otro lado

[dmorill]

Hola amigos, estoy con el siguiente dilema, estoy trabajando sobre un grafo con nodos conectados entre sí. Y creé una clase llamada así, "SuperNodos":

Código C++:

class SuperNode{
private:
    int _id;
    int _alias;
    int _level;
    int _pos;
    vector<vector<SuperNode*>> _roadtoit;
    vector<SuperNode*> _Neighbor;
public:
    SuperNode(){ ; }
    SuperNode(int id, int alias, int level, int pos){ _id = id, _alias = alias, _level = level, _pos = pos; }
    void add_Neighbor(SuperNode &n){ _Neighbor.push_back(&n); }
    void add_roadtoit(vector<SuperNode*> &n){ _roadtoit.push_back(n); }
    int get_id(){ return _id; }
    int get_alias(){ return _alias; }
    int get_level(){ return _level; }
    int get_pos(){ return _pos; }
    void set_pos(int i){ _pos = i; }
    SuperNode* get_oneinroad(int row, int col){ return _roadtoit[row][col]; }
    void set_oneinroad(int row, SuperNode &i){ _roadtoit[row].push_back(&i); }
    vector<SuperNode*> get_roadtoit(int i){ return _roadtoit[i]; }
    SuperNode get_neighbor(int i){ return *_Neighbor[i]; }
};
 

Como ven tiene algunos métodos y sus atributos el importante para la pregunta es el

Código C++:

vector<vector<SuperNode*>> _roadtoit;
 

. Que es un vector de punteros que apuntan a unos SuperNodos.

En el main inicializo un vector de Nodos, llamado "s";

Código C++:

int main(){
 
n = lectraDedatos(); // lee los datos y lee cuantos nodos hay n
vector<SuperNode> s (n); // se crea con un vector con n nodos
 
//aquí va un for muy largo. 
 
return 0;
}
 

La cuestión es que cada nodo de s tiene su información y eso, en el _roadtoit él guarda todos los posibles caminos para llegar a ese nodo, con punteros a nodos del vector s.

Dentro del for muy largo, luego de recorre el grafo, adiciono nodos ficticios a s con un pushback (quedando más de n claro). Pero me dí cuenta que como el vector estaba a su maxima capacidad, <vector> muda a otro sector de memoria donde si alcanza y le da una capacidad mayor al size, eso está bien, pero ahora lodos los punteros (cada componente de _roadtoit) que apuntaban a s, quedan apuntando a un lugar de memoria donde ya no hay nada. Cómo puedo evitar eso o bien actualizar a dichos punteros?

Muchas gracias,

--------------ejemplo claro---------------

Código C++:

#include <iostream>;
#include <vector>;
 
 
using namespace std;
 
int main() {
    int i = 0;
    vector<int> v(10,50);
    int *p = &v[0];
    cout << "Dirección del puntero:  " << p << endl;
    cout << "contenido del puntero:  " << *p << endl << endl;
 
    v.push_back(100);
 
    cout << "Dirección del puntero:  " << p << endl;
    cout << "contenido del puntero:  " << *p << endl << endl;
    
    int *p2 = &v[0];
    cout << "Dirección del puntero 2:  " << p2 << endl;
    cout << "contenido del puntero 2:  " << *p2 << endl << endl;
 
    cin.get();
    return 0;
}
 

El puntero p se pierde una vez se muda vector.

[eferion]

Y por qué no usas shared_ptr o unique_ptr??

Si tienes claro que la vida de 's' siempre va a ser superior a los nodos del grafo puedes usar unique_ptr. Si la vida de los objetos pasa a ser más difusa entonces es más recomendable usar shared_ptr:

Ejemplo para unique_ptr:

Código C++:

vector<std::unique_ptr<SuperNode>> s(n);
for( auto& node : s )
  node = std::make_unique<SuperNode>();
 
// make_unique<> es un template que crea un unique_ptr ya inicializado
// make_unique<SuperNode>()  es equivalente a
// std::unique_ptr<SuperNode>(new SuperNode); 
// make_unique también admite parámetros:
// make_unique<SuperNode>(1) es equivalente a
// std::unique_ptr<SuperNode>(new SuperNode(1));
 

Y para que los nodos apunten al puntero:

Código C++:

class Node
{
  SuperNode* superNode;
};
node->superNode = s[0].get();
 

Opción con shared_ptr (1):

Código C++:

vector<std::shared_ptr<SuperNode>> s(n);
for( auto& node : s )
  node = std::make_shared<SuperNode>();
 

Y para referenciar el puntero:

Código C++:

class Node
{
  std::weak_ptr<SuperNode> superNode;
};
 
node->superNode = s[0]; // La conversión a weak es implícita
 

¿Por qué usar weak? shared_ptr es una clase que gestiona un puntero que va a utilizarse en varias secciones del código. Lo que hace shared_ptr es mantener vivo el puntero mientras existan referencias al mismo (una referencia = una instancia de shared_ptr referenciando al puntero). Cuando ya no hay elementos shared_ptr referenciando el puntero la memoria es liberada de forma automática.

Si resulta que tienes una referencia circular (A referencia a B y B a A), entonces la memoria nunca se liberaría porque ambos punteros tendrían siempre una referencia.... en estos casos es donde entra en acción weak_ptr. weak_ptr representa una referencia débil a un puntero compartido. Es debil porque no impide que el puntero sea destruído (no cuenta como referencia). Para evitar problemas el propio weak_ptr incluye funcionalidad que indica si el puntero está vivo o no.

Un ejemplo ilustrativo:

Código C++:

void CrearShared(std::weak_ptr<int> weakPtr)
{
  if( std::shared_ptr<int> miShared = weakPtr.lock() )
  {
    std::cout << "El puntero esta referenciado " << weakPtr.use_count() << " vece(s)\n";
    std::cout << "shared_ptr = " << *miShared << '\n';
  }
  else
  {
    std::cout << "El puntero ha sido eliminado\n";
  }
}
 
int main()
{
  std::weak_ptr<int> weak;
 
  {
    std::shared_ptr<int> shared = std::make_shared<int>(4);
 
    weak = shared;
 
    std::cout << "El puntero esta referenciado " << weak.use_count() << " vece(s)\n";
 
    auto shared2 = shared;
    std::cout << "El puntero esta referenciado " << weak.use_count() << " vece(s)\n";
 
    // Si el puntero está vivo podremos usarlo
    CrearShared(weak);
 
    // Este mensaje muestra como el número de referencias ha bajado porque el shared_ptr
    // que creamos dentro de la función ya no existe
    std::cout << "El puntero esta referenciado " << weak.use_count() << " vece(s)\n";
 
  } // En este punto los dos shared_ptr serán eliminados, eso da lugar a que el puntero
    // se elimine
 
  // Cuando ya no exista el puntero, weak_ptr nos avisará
  CrearShared(weak);
}
 

Un saludo

[dmorill]

Hola eferion. No me cansaré de agradecerte, siempre que tengo una duda y Google no me ayuda, tu me das una luz.
No conocía los shared_ptr ni los unique_ptr estudiaré que son y tu codigo para poder responderte gracias.

[eferion]

Iniciado por dmorill

No conocía los shared_ptr ni los unique_ptr.

Son lo que se conoce como punteros inteligentes. La gracia de estas clases es que se encargan de la gestión de un puntero, destruyéndolo cuando el mismo ya no es necesario.

unique_ptr es una clase que se encarga de la gestión de un puntero que no va a ser compartido. Cuando la ejecución abandona el ámbito de la variable el puntero se destruye automáticamente:

Código C++:

struct Test
{
  ~Test()
  { std::cout << "Test::~Test()\n"; }
}
 
void func()
{
  auto ptr = std::make_unique<Test>();
  std::cout << "Despues de esto se llama al destructor\n";
}
 
int main()
{
  func();
}
 

Por supuesto un unique_ptr puede sacarse de una función (e incluso almacenarse en un contenedor). La única limitación (y es su razón de ser) es que el puntero no está compartido por otros punteros inteligentes:

Código C++:

std::unique_ptr<Test> func()
{
  return std::make_unique<Test>();
  std::cout << "Aun no se llama al destructor\n";
}
 
int main()
{
  auto ptr = func();
  std::cout << "El objeto se destruye a continuacion\n";
}
 

Para mover el puntero de una variable a otra... por ejemplo un bucle intermedio que pretende localizar un elemento en cuestión, se debe usar la sintaxis move (recuerda que al ser un elemento único no se puede llamar al constructor copia ni al de asignación alegremente):

Código C++:

void Print(std::unique_ptr<int>& var)
{
  if( var )
    std::cout << *var << '\n';
  else
    std::cout << "Puntero vacio\n";
}
 
int main()
{
  std::unique_ptr<int> a = std::make_unique<int>(2);
  std::unique_ptr<int> b;
 
  Print(a); Print(b);
 
  //b = a; -> ERROR de compilación
 
  b = std::move(a); // sintaxis MOVE. a y b intercambian sus estados
 
  Print(a); Print(b);
}
 

Gestionar los punteros con punteros inteligentes ayuda a reducir las fugas de memoria:

Código C++:

std::unique_ptr<Test> func()
{
  auto obj = std::make_unique<Test>();
  throw 1; // Al lanzar la excepción el objeto se destruye automáticamente
  return obj;
}
 
int main()
{
  try
  {
    func();
  }
 
  catch(...)
  { }
}
 

shared_ptr sigue la misma filosofía (proporcionar un mecanismo de gestión de la memoria) pero permite que el puntero esté compartido por varias variables. Lo que hace shared_ptr es invocar al destructor automáticamente cuando el puntero ya no tiene referencias.

El uso de shared_ptr requiere prestar atención a las referencias circulares. Recordemos que si un shared_ptr tiene al menos una referencia el objeto no se va a destruir, luego si A apunta a B y B a A, ninguno de los dos objetos se va a destruir.

Un saludo.

[dmorill]

Hola Eferion, según he leído y estudiado tus ejemplos creo que estos punteros inteligentes básicamente te ayudan a que no existan fugas de memoria. Estoy en lo cierto?

Pero el problema que tengo, no es solo que los punteros se queden apuntando a la nada (fugas de memoria) sino que me gustaría que apunten a donde el vector se mude automáticamente, porque hacerlo manual es muy largo estamos hablando de millones de punteros.

Es como si un puntero se queda "anclado" al vector y si éste se mueve, el puntero también. Se puede hacer algo así?

Saludos y gracias.

[xKuZz]

Ten en cuenta qué, siguiendo la propuesta que te da eferion

Código C++:

std::vector<std::unique_ptr<SuperNode>> _neighbor;
...
 

Tienes un vector de punteros inteligentes que a apuntan a SuperNodos. Si aumenta la dimensión del vector y se cambia sus posiciones en memoria, lo que cambian son las posiciones de memoria dónde se guardan los punteros inteligentes que apuntan a los nodos, no la dirección de memoria en las que se guardan los SuperNodos.

Por lo cual mientras lo que vayas almacenando sea el puntero del SuperNodo(ya sea raw(*), shared o weak) en las otras estructuras o una referencia al SuperNodo y no un iterador o referencia sobre el vector no deberías de tener problema.

[eferion]

xKuZz se me ha adelantado con la respuesta :).

Efectivamente los punteros inteligentes no son necesarios, pero entiendo que cuando creaste el vector de SuperNode elegiste meter los elementos por valor para despreocuparte de la memoria... luego te ofrecí una solución en la que no tuvieses que lidiar con la misma.

Por otro lado, manejar la memoria directamente es un tema muy delicado y es muy sencillo meter la pata. Hacer uso de herramientas que gestionen este apartado es altamente recomendable.

Un saludo

[dmorill]

Hola amigos, no he dejado olvidado el tema, sino que he estado con muchos cosas y sé que necesito una tarde para estudiar ésto. Así que gracias y ya les escribiré pronto.