elhacker.net cabecera Bienvenido(a), Visitante. Por favor Ingresar o Registrarse
¿Perdiste tu email de activación?.

 

 


Tema destacado: Introducción a Git (Primera Parte)


+  Foro de elhacker.net
|-+  Programación
| |-+  Programación C/C++ (Moderadores: Eternal Idol, Littlehorse, K-YreX)
| | |-+  Asignar valores a un vector
0 Usuarios y 1 Visitante están viendo este tema.
Páginas: [1] Ir Abajo Respuesta Imprimir
Autor Tema: Asignar valores a un vector  (Leído 1,733 veces)
el_doctor

Desconectado Desconectado

Mensajes: 57


Ver Perfil
Asignar valores a un vector
« en: 3 Septiembre 2013, 18:46 pm »

Saludos quiero  probar si un vector me devuelve bien los datos antes de programar los datos que va recibir el constructor tengo un contructor en una biblioteca que he creado llamada NetXh.h y la forma del constructor es:
struct NetxInfo
{
public:
   ULONG pid;
   WCHAR filename[MAX_PATH];
   WCHAR pathname[MAX_PATH];

   WCHAR protocol[10];
   WCHAR state [MAX_PATH];
   WCHAR srcip[MAX_PATH];
   WCHAR destip[MAX_PATH];
};

ahora bien donde incluyo el archivo Netxh.h creo un vector:

vector<NetxInfo>* initialNetxes = new vector<NetxInfo>();

quiero agregarle valores (basura) sólo para probar si la función que me va devolver este vector funciona bien.

como puedo agregarle valores de forma estática



no se si lo puedo hacer de la forma:
initialNetxes[0].pid = <dato>;
initialNetxes[0].filename = <dato>;
.
.
.
initialNetex[0].destip = <dato>;
para todo el vector que contiene la estructura NetxInfo


« Última modificación: 3 Septiembre 2013, 19:07 pm por Eternal Idol » En línea

eferion


Desconectado Desconectado

Mensajes: 1.248


Ver Perfil
Re: Asignar valores a un vector
« Respuesta #1 en: 4 Septiembre 2013, 08:49 am »

Antes de nada: El código enciérralo con las etiquetas GeSHi, así quedará más claro. es el combobox que está en la ventana de escritura de mensajes encima del combo que dice "Cambiar Color". Elige el lenguaje correspondiente, en tu caso c++.

Saludos quiero  probar si un vector me devuelve bien los datos antes de programar los datos que va recibir el constructor tengo un contructor en una biblioteca que he creado llamada NetXh.h y la forma del constructor es:
struct NetxInfo
{
public:
   ULONG pid;
   WCHAR filename[MAX_PATH];
   WCHAR pathname[MAX_PATH];

   WCHAR protocol[10];
   WCHAR state [MAX_PATH];
   WCHAR srcip[MAX_PATH];
   WCHAR destip[MAX_PATH];
};

Una aclaración: Lo que has puesto no es ningún constructor, tu ahí has definido una estructura. Un constructor es una función que crea e inicializa una estructura como la que tú has puesto.

En el caso de c++ el constructor tiene esta forma:

Código
  1. class NextInfo
  2. {
  3.  public:
  4.  
  5.    // ...
  6.  
  7.    // Constructor por defecto
  8.    NextInfo( );
  9.  
  10.    // Constructor copia
  11.    NextInfo( const NextInfo& original );
  12. };

La implementación es libre, pero con lo que tienes lo más lógico es que fuese algo así:

Código
  1. NextInfo::NextInfo( )
  2. {
  3.  pid = 0;
  4.  *filename = '\0';
  5.  *pathname = '\0';
  6.  *protocol = '\0';
  7.  // ...
  8. }

Como norma general, en c++ se usa la palabra clave "class" para definir clases nuevas. La diferencia entre "class" y "struct" en c++ es que por defecto en "class" los miembros son privados, mientras que en "struct" son públicos. En cualquier caso lo lógico y normal, como te he comentado, es usar "class".

Además, no se hasta qué punto es lógico que uses arrays de caracteres al estilo de C cuando en C++ tienes la clase string para gestionar cadenas de caracteres:

Código
  1. struct NetxInfo
  2. {
  3. public:
  4. ULONG pid;
  5. std::string filename;
  6.        std::string pathname;
  7.  
  8. std::string protocol;
  9. std::string state;
  10. std::string srcip;
  11. std::string destip;
  12. };

Si en algún momento necesitas recuperar la cadena siguiendo la codificación de C, puedes usar el método c_str de la clase string:

Código
  1. char* cad_estilo_c = filename.c_str( );

Por defecto, en C++ no suele ser necesario la mayoría de las veces gestionar la memoria de forma dinámica ( muchas veces se hace más por inercia que por necesidad ). En tu caso no veo sentido a que el vector lo declares como un puntero:

Código
  1. // No tiene demasiado sentido
  2. vector< NextInfo > * initialNetxes = new vector< NextInfo >( );
  3.  
  4. // Forma que yo creo sería más correcta
  5. vector< NextInfo > initialNetxes;

La ventaja de definirlo de forma estática es que no tienes que preocuparte por la liberación de recursos. Además, si luego este vector lo vas a manejar en diferentes funciones no es necesario que pases "copias" del mismo, sino que lo puedes pasar por referencia:

Código
  1.  
  2. // Al ser netxes una referencia, los cambios que realizemos en netxes se veran reflejados en el vector original
  3. void RellenaVector( vector< NextInfo >& netxes )
  4. {
  5.  // ...
  6. }
  7.  
  8. // En esta funcion se pone el modificador const para evitar que netxes pueda ser modificado dentro de la funcion.
  9. // Si no pasamos el vector como referencia entonces se hara una copia en memoria del vector junto a todo su contenido
  10. // y esa es una operacion que puede resultar bastante costosa, por lo que el rendimiento se resiente.
  11. void ImprimeVector( const vector< NextInfo >& netxes )
  12. {
  13.  // ...
  14. }
  15.  
  16. void main( )
  17. {
  18.  vector< NextInfo > initialNetxes;
  19.  
  20.  RellenaVector( initialNetxes );
  21.  
  22.  ImprimeVector( initialNetxes );
  23. }

La ventaja de usar en la medida de lo posible objetos no dinámicos es que la gestión de la memoria puede llegar a ser algo realmente problemático y, con frecuencia, se suelen generar lagunas de memoria como consecuencia de despistes.

Para rellenar el vector puedes hacer algo como esto

Código
  1. void RellenaVector( vector< NextInfo >& netxes )
  2. {
  3.  NextInfo info;
  4.  info.pid = 1;
  5.  info.filename = "prueba.txt"; // lo trato como si fuese un string de c++, si lo dejas con tu implementacion estas lineas no valen
  6.  info.pathname = "c:/dir_de_prueba";
  7.  // ...
  8.  
  9.  netxes.push_back( info );
  10.  
  11.  info = NextInfo( ); // Reiniciamos el objeto info
  12.  info.pid = 2;
  13.  info.filename = "otro_fichero.bin";
  14.  // ...
  15.  
  16.  netxes.push_back( info );
  17.  
  18.  // ...
  19. }

Consideración final: No escribas código en los archivos de cabecera (.h), el código SIEMPRE debe ir en los cpp. Acostúmbrate a ser ordenado con tu código o luego lo vas a pasar realmente mal para corregir tus propios errores.


En línea

Páginas: [1] Ir Arriba Respuesta Imprimir 

Ir a:  

WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines