int palabras_found=0;
 
// ...
 
arch.write((char *)palabras_found,sizeof(int));

¿por qué motivo tratas palabras_found como si fuese un puntero? Me da que no terminas de entender el significado y funcionamiento de los punteros.

En este caso concreto, "palabras_found" no es puntero, y dado que la función "write" necesita un puntero, lo que tienes que facilitarle a la función es la posición de memoria donde se encuentra "palabras_found", es decir:

arch.write((char *)&palabras_found,sizeof(int));

Lo que tu estabas almacenando antes en el fichero era guarrería... además le estabas dando al sistema operativo motivos más que suficientes para que matase tu programa por acceder a memoria que no le corresponde.

Que tal algo del tipo...

char buffer[ 100 ];
strcat( buffer, "palabra1" );
strcat( buffer, " " );
strcat( buffer, "palabra2" );

Por cierto, esta línea, por ejemplo:

scanf ("%s",&pal);

Está mal... pal es de por sí un puntero, si pasas la referencia en vez del puntero vas a escribir donde no debes.

Además:

char cad[ 100 ];
// ...
strcat( cad, pal );

¿Dónde has inicializado "cad"?? strcat concatena a partir del final de cadena, es decir, de que encuentra el carácter nulo... si la cadena no está inicializada vas a tener basura y la función va a concatenar donde le de la gana... y seguro que no coincide con el sitio donde tú quieres que escriba.

Para que el código aparezca "correcto" tienes que añadirle a la etiqueta "code" el lenguaje empleado:

code=cpp -> C++
code=c -> C
...

Si la etiquetas la dejas como "code" a secas al código se le da una interpretación que puede no ser la correcta... en tu caso [ s ] se está interpretando como texto tachado, por lo que te tacha todo lo que se encuentra entre esa etiqueta y la de cierre... que como no hay te tacha hasta el final del código.

char sopa[20][20];
arch.read(sopa[0], 20*20*sizeof(sopa));

Si sopa es un array bidimiensional... tu quieres sobreescribir dicho array al completo... ¿por qué accedes a sopa[0]? Si pretendes modificar "sopa"... el puntero que debes pasar es "sopa"... no "sopa[0]". Además, "20*20*sizeof(sopa)"... si sopa es un array de 20*20... entonces esa expresión es equivalente a "20*20*20*20*sizeof(char)"... y creo que no es tu intención leer semejante cantidad de información. Tienes que tener en cuenta que de la forma en la que has declarado el array, el compilador sabe en todo momento el tamaño de esa variable... que serán 400 bytes.

Dicho esto aquí tienes dos opciones:

Opción 1:

arch.read(sopa, sizeof(sopa));

Opción 2:

arch.read(sopa, 20*20*sizeof(char));

Yo, personalmente, prefiero la primera opción ya que si te da por cambiar el tamaño del array y te olvides de cambiar esta otra línea vas a tener errores en el código.

El resto de lecturas y escrituras presentan los mismos problemas.

Un saludo.

Si usas C++, mi consejo es que, salvo que sea una "obligación" o estés aprendiendo y quieras pasar por ello, tengas en cuenta lo siguiente:

No uses char* para la gestión de cadenas de texto. En su lugar usa la clase "string".

Porque es más bonito, más legible y da menos problemas esto:

std::string cadena = "algo";
std::string otra_cadena = cadena;
 
cadena += "otra cosa";

que esto otro:

char cadena[ 40 ];
char otra_cadena[ 40 ];
 
strcpy( cadena, "algo" );
strcpy( otra_cadena, cadena );
 
strcat( cadena, "otra cosa" );

No uses variables globales, son más problemáticas de lo que te imaginas.

El problema de las variables globales es que no queda clara la forma en que se usan... además es fácil que puedan quedar "tapadas" por variables locales, lo que dificulta muchísimo la lectura del código y la búsqueda de errores. En serio, es mejor evitar las variables globales.

Puede que haya alguna rara excepción en la que sea mejor usarlas... pero no creo que te veas en esas mientras aprendes. Además siempre es mejor tener una clase estática o un singleton que tener variables globales.

Intenta marcarte una longitud máxima para cada línea de código.

Tener líneas de código con, por ejemplo 3000 caracteres no ayuda a que el código sea legible. Lo ideal es que el código entre en la pantalla sin necesidad de hacer scroll horizontal.

Antes, cuando los editores iban sobre shell, el límite aceptado eran 80 caracteres... hoy en día gracias a dios no hace falta ser tan estricto... pero aún así en serio, intenta evitar scroll horizontal en tu código:

// Linea dificil de leer
cout<<"Usuario 1:"<<persona[1].cedula<<" , "<<persona[1].nombre<<" , "<<persona[1].correo<< " , "<<persona[1].telefono<<" , "<<persona[1].padres[1].cedula<<" , "<<persona[1].padres[1].nombre<<" , "<<persona[1].padres[1].cedula<<" , "<<persona[1].padres[1].nombre<<" , " <<endl;
 
// Linea mas legible
cout << "Usuario 1:" << persona[1].cedula << " , "
                     << persona[1].nombre << " , "
                     << persona[1].correo << " , "
                     << persona[1].telefono << " , "
                     << persona[1].padres[1].cedula << " , "
                     << persona[1].padres[1].nombre << " , "
                     << persona[1].padres[1].cedula << " , "
                     << persona[1].padres[1].nombre << " , " << endl;

Creo que la diferencia es evidente.

En C++ no uses includes de C

Los includes de la librería de C tienen TODOS el sufijo ".h", los includes de C++ carecen de dicho sufijo. Si en algún momento tienes que usar una función propia de C en C++, has de saber que estas funciones tienen un include tipo C++. Por ejemplo:

• El include de math.h, en C++ es cmath
• El include de stdio.h, en C++ es cstdio

Piensa que, aunque son compatibles, son lenguajes diferentes y no queda claro que vayan a ser compatibles eternamente... mejor diferenciar claramente cada lenguaje.

Tabula el codigo

Si todo el código es "plano", es decir, está todo al mismo nivel, resulta complicado saber qué código está dentro de un determinado bucle:

void func( )
{
int i=1, j=5;
while(i++)
{
if (i==j)
{
std::cout << i << std::endl;
j += 5;
}
if (i%30==0)
{
if (i==j)
{
std::cout << i << j << std::endl;
}
} // <<<
}
}

¿Está bien escrito el código de arriba?
¿A qué bucle o condición pertenece la llave que tiene el comentario?

Desde luego es complicado responder a estas preguntas sin estar un ratito mirando el código... sin embargo si tabulamos el código la cosa cambia:

void func( )
{
  int i=1, j=5;
  while(i++)
  {
    if (i==j)
    {
      std::cout << i << std::endl;
      j += 5;
    }
 
    if (i%30==0)
    {
      if (i==j)
      {
        std::cout << i << j << std::endl;
      }
    } // <<<
  }
}

Ahora se entiende mejor, ¿no? pues eso mismo.

Intenta "abusar" de los bucles.

Un concepto básico de la programación es intentar reutilizar el código lo máximo posible (dentro, claro está, de unos límites aceptables).

En tu caso, estás sacando por pantalla 5 registros diferentes copiando, literalmente, el código 5 veces... si tienes un problema en ese código, o si necesitas hacer algún cambio, tendrás que aplicar el cambio 5 veces... lo cual es poco eficiente y bastante propenso a errores.

Para este tipo de tareas repetitivas se inventaron los bucles. Saca tus propias conclusiones:

Sin bucles:

cout<<"Usuario 1:"<<persona[1].cedula<<" , "<<persona[1].nombre<<" , "<<persona[1].correo<< " , "<<persona[1].telefono<<" , "<<persona[1].padres[1].cedula<<" , "<<persona[1].padres[1].nombre<<" , "<<persona[1].padres[1].cedula<<" , "<<persona[1].padres[1].nombre<<" , " <<endl;
cout<<endl;
cout<<"Usuario 2:"<<persona[2].cedula<<" , "<<persona[2].nombre<<" , "<<persona[2].correo<< " , "<<persona[2].telefono<<" , "<<persona[2].padres[2].cedula<<" , "<<persona[2].padres[2].nombre<<" , "<<persona[2].padres[2].cedula<<" , "<<persona[2].padres[2].nombre<<" , "<<endl;
cout<<endl;
cout<<"Usuario 3:"<<persona[3].cedula<<" , "<<persona[3].nombre<<" , "<<persona[3].correo<< " , "<<persona[3].telefono<<" , "<<persona[3].padres[3].cedula<<" , "<<persona[3].padres[3].nombre<<" , "<<persona[3].padres[3].cedula<<" , "<<persona[3].padres[3].nombre<<" , "<<endl;
cout<<endl;
cout<<"Usuario 4:"<<persona[4].cedula<<" , "<<persona[4].nombre<<" , "<<persona[4].correo<< " , "<<persona[4].telefono<<" , "<<persona[4].padres[4].cedula<<" , "<<persona[4].padres[4].nombre<<" , "<<persona[4].padres[4].cedula<<" , "<<persona[4].padres[4].nombre<<" , "<<endl;
cout<<endl;
cout<<"Usuario 5:"<<persona[5].cedula<<" , "<<persona[5].nombre<<" , "<<persona[5].correo<< " , "<<persona[5].telefono<<" , "<<persona[5].padres[5].cedula<<" , "<<persona[5].padres[5].nombre<<" , "<<persona[5].padres[5].cedula<<" , "<<persona[5].padres[5].nombre<<" , "<<endl;
cout<<endl;

Con bucles ( y aplicando lo comentado anteriormente tambien ):

for ( int i = 0; i < 5; i++ )
{
  cout << "Usuario " << i << ": " << persona[ i ].cedula
                                  << " , " << persona[ i ].nombre
                                  << " , " << persona[ i ].correo
                                  << " , " << persona[ i ].telefono
                                  << " , " << persona[ i ].padres[ i ].cedula
                                  << " , " << persona[ i ].padres[ i ].nombre
                                  << " , " << persona[ i ].padres[ i ].cedula // duplicado
                                  << " , " << persona[ i ].padres[ i ].nombre // duplicado
                                  << endl;
}

Por cierto, fíjate que ahora se aprecian varios errores:

* para cada "persona" solo imprimes un "padre"... eso huele mal.
* Para el "padre" estás sacando dos veces la misma información... líneas con comentario

Seguro que si intentas ver estos errores en tu código te va a costar más encontrarlos (sobretodo si no sabes que están ahí)

Y bueno, de momento creo que te he comentado bastantes cosillas, deberías repasar un poco tu código. Si después de eso sigues teniendo dudas aquí estamos.

Un saludo.

Suponiendo que tuvieses algo del tipo

<?xml version="1.0" encoding="UTF-8"?>
<NewTable name="nueva_tabla">
  <cols>
    <col>
      <name>columna1</name>
      <dataType>int</dataType>
     </col>
  </cols>
</NewTable>

Tendrías que leer el XML y, simplificando, seguir el siguiente esquema. Nota que el código es una especie de pseudocódigo... el código final dependerá de la clase que uses para leer el XML.

XmlReader reader( fichero );
 
while ( reader.NextNode( ) )
{
  if ( reader.CurrentNode( ).Name( ) == "NewTable" )
    NewTable( reader );
}
 
void NewTable( XmlReader& reader )
{
  std::string tableName = reader.CurrentNode( ).Attribute( "name" ); // Recuperamos 'nueva_tabla'
  std::vector< DBCol > columns;
 
  while ( reader.NextNode( ) )
  {
    if ( reader.CurrentNode( ).Name( ) == "cols" )
      columns = ReadColumns( reader );
  }
 
  std::string sql = "CREATE TABLE " + tableName + " (";
 
  for ( const auto& col : columns )
  {
    sql += col.Name( ) + ...
  }
  sql += ")";
 
  // Solo falta ejecutar la sentencia SQL
}
 
void ReadColumns( XmlReader& reader )
{
  std::vector< DBCol > columns;
 
  while ( reader.NextNode( ) )
  {
    if ( reader.CurrentNode( ).Name( ) == "col" )
      columns.push_back( ReadColumn( reader );
  }
 
  return columns;
}
 
void ReadColumn( XmlReader& reader )
{
  DBCol column;
 
  while ( reader.NextNode( ) )
  {
    if ( reader.CurrentNode( ).Name( ) == "name" )
      column.SetName( reader.CurrentNode( ).ReadText( ) ); // Nombre de la columna
    else if ( reader.CurrentNode( ).Name( ) == "dataType" )
      column.SetType( reader.CurrentNode( ).ReadText( ) );
  }
 
  return column;
}

Crear una tabla es algo bastante más complejo. Hay que indicar también qué campos hay, que nombre tienen, de qué tipo es cada campo y ajustar algúnas configuraciones adicionales (longitud de los caracteres, si es clave primaria, campos que se autoincrementan ). Luego aparte también se suelen configurar reglas de acceso o disparadores ( para trabajar con tablas relacionales )....

Vamos, que por poder, sí prodrías conseguirlo, pero vas a tener que añadir más profundidad a esa etiqueta

Si luego quieres subir un escalón... también lo puedes hacer con templates:

template< int N >
struct Factorial 
{
    enum { value = N * Factorial< N - 1 >::value };
};
 
template<>
struct Factorial< 0 > 
{
    enum { value = 1 };
};
 
int main( )
{
  std::cout << "Factorial de 4: " << Factorial< 4 >::value << std::endl;
  std::cout << "Factorial de 5: " << Factorial< 5 >::value << std::endl;
}

stream lo he puesto a modo de ejemplo. Cuando "serializas" un objeto, es decir, cuando extraes de el su estado para poder reconstruir el objeto en el futuro, forzosamente tienes que guardar esta información en algún sitio: un fichero, enviarlo por red, ... curiosamente todas estas opciones funcionan mediante streams.

Si vas a almacenar la información en disco entonces podrías usar "ofstream" para guardar y "ifstream" para leer... como ves no dejan de ser streams. Los métodos concretos que te permitan manejar cada una de estas clases los tienes en internet, buscando un poco se encuentran.

En cuanto al 'readFloat' no es más que un hipotético método que me permite obtener un float del stream... simplemente. Dependiendo de la interfaz del stream, este método puede llamarse así, o simplemente 'read' o vete tu a saber como... depende de la interfaz del stream.

Y tratando el tema de "avanzar en el stream", se supone que cada vez que tu haces una lectura de un stream el puntero de lectura que tiene interno avanza solo, por lo que, por norma general, no debes preocuparte de este aspecto.

No es por ser un rancio pero... ¿has probado a buscar en google? La mayoría de los enlaces que se acaban poniendo en este tipo de mensajes salen de ahí....

En este mundo es muy importante saber sacarse las castañas del fuego... y eso implica saber dónde buscar. Creo que este foro se desvirtúa si empezamos a pedir enlaces que se pueden encontrar fácilmente en google:

* Ejemplo1. Palabras clave "sockets c++ tutorial winsock". Salen varios tutoriales sólo mirando en la primera página...

* Ejemplo 2. Palabras clave "sockets c++ example winsock". Igualmente, salen varios ejemplos sólo en la primera página.

Dado que los objetos de C++ son bastante propensos a utilizar memoria dinámica: punteros internos, contenedores de la stl, ... no suele ser buena idea hacer una copia "a lo bestia" del contenido de la memoria, ya que así pierdes la información almacenada mediante punteros.

La mejor forma de guardar objetos ( para almacenarlos en disco, enviarlos por red, etc. ) es hacer el trabajo "a mano", es decir, extraer toda la información que permite reconstruir el objeto y almacenar dicha información:

class POO
{
  public:
 
    int Numero( ) const
    { return numero; }
 
    std::string Nombre( ) const
    { return nombre; }
 
    const std::vector< float >& Valores( ) const
    { return valores; }
 
  private:
    int numero;
    std::string nombre;
    std::vector< float > valores;
}
 
void Serializar( POO* poo, Stream* stream )
{
  stream.write( poo->Numero( ) );
  stream.write( poo->Nombre( ) );
 
  stream.write( poo->Valores( ).size( ) ); // Numero de elementos del array
  for ( const auto& valor : poo->Valores( ) )
    stream.write( valor );
}
 
POO* Deserializar( Stream* stream )
{
  POO* poo = new POO( );
  poo->SetNumero( stream->readNumber( ) );
  poo->SetNombre( stream->readString( ) );
 
  int numValores = stream->readNumber( );
  std::vector< float > valores;
  for ( int i = 0; i < numValores; i++ )
    valores.push_back( stream->readFloat( ) );
  poo->SetValores( valores );
 
  return poo;
}

El ejemplo es ambigüo ya que la forma concreta de "serializar" el objeto depende en gran medida del formato en el que se va a almacenar: archivo binario, XML, base de datos, ...

Faltan algunos métodos en "POO"... pero no deberían suponer ningún problema para entender el código.