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++.


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:

class NextInfo
{
  public:
 
    // ...
 
    // Constructor por defecto
    NextInfo( );
 
    // Constructor copia
    NextInfo( const NextInfo& original );
};

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

NextInfo::NextInfo( )
{
  pid = 0;
  *filename = '\0';
  *pathname = '\0';
  *protocol = '\0';
  // ...
}

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:

struct NetxInfo
{
public:
	ULONG pid;
	std::string filename;
        std::string pathname;
 
	std::string protocol;
	std::string state;
	std::string srcip;
	std::string destip;
};

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:

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:

// No tiene demasiado sentido
vector< NextInfo > * initialNetxes = new vector< NextInfo >( );
 
// Forma que yo creo sería más correcta
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:

 
// Al ser netxes una referencia, los cambios que realizemos en netxes se veran reflejados en el vector original
void RellenaVector( vector< NextInfo >& netxes )
{
  // ...
}
 
// En esta funcion se pone el modificador const para evitar que netxes pueda ser modificado dentro de la funcion.
// Si no pasamos el vector como referencia entonces se hara una copia en memoria del vector junto a todo su contenido
// y esa es una operacion que puede resultar bastante costosa, por lo que el rendimiento se resiente.
void ImprimeVector( const vector< NextInfo >& netxes )
{
  // ...
}
 
void main( )
{
  vector< NextInfo > initialNetxes;
 
  RellenaVector( initialNetxes );
 
  ImprimeVector( initialNetxes );
}

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

void RellenaVector( vector< NextInfo >& netxes )
{
  NextInfo info;
  info.pid = 1;
  info.filename = "prueba.txt"; // lo trato como si fuese un string de c++, si lo dejas con tu implementacion estas lineas no valen
  info.pathname = "c:/dir_de_prueba";
  // ...
 
  netxes.push_back( info );
 
  info = NextInfo( ); // Reiniciamos el objeto info
  info.pid = 2;
  info.filename = "otro_fichero.bin";
  // ...
 
  netxes.push_back( info );
 
  // ...
}

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.