Mensajes

Si la duración del vídeo es conocida... programa una función con javascript para que salte pasados X minutos de espera y sea la encargada de mostrar la capa en la que se encuentra el formulario.

La eficiencia muchas veces se consigue disponiendo de algoritmos óptimos. No se hasta que punto el andar calculando máximos, mínimos, raices y demás puede suponerte una ventaja en cuanto a rapidez de cálculo ( otra cosa es cuando la tienes que pintar a mano ), pero me da que sólo sería una ventaja en casos más o menos concretos.

Normalmente lo más lógico para graficar una función ( sobretodo si es en el eje xy) es recorrerla a intervalos discretos para un valor X y calcular Y o viceversa.

El problema normalmente está en que realizar esos cálculos, en algunos casos, puede llevar su tiempo, por lo que el graficado se puede demorar.

El proceso se puede simplificar eligiendo, por ejemplo, intervalos acordes al tamaño de la gráfica ( puede no tener sentido calcular con precisión de centésimas cuando en la gráfica un pixel representa 2 unidades enteras ).

Además también se pueden incorporar "atajos" que permitan reducir el tiempo necesario para calcular los resultados:

* precompilando la ecuación
* utilizando optimizaciones específicas para casos concretos

Por ejemplo, para calcular el cuadrado de un número puedes hacer una operación de multiplicación ( lenta ) o un desplazamiento de bits ( rápido )

[SIEMPRE]

( a + 5 * 2 ) * ( b + 6 / 2 ) + ( a * 2 )
( a + 10 ) * ( b + 3 ) * ( a * 2 )
( 5 + 10 ) * ( 1 + 3 ) * ( 5 * 2 )
15 * 4 + 10
60 + 10
70

Los operadores de multiplicación y división SIEMPRE tienen prioridad sobre los de suma y resta... son matemáticas básicas.

Bajo el nuevo estándar C++11 la declaración de un vector es similar a la de un array y al utilizar "auto" nos olvidamos de indicar el tipo de la variable en el único bucle del programa.

En C++11 también se puede simplificar el bucle:

Código (cpp) [Seleccionar] Expandir


#include <iostream>
using std::cout;
using std::endl;

#include <string>
using std::string;

#include <vector>
using std::vector;

int main()
{
   vector<string> foo = {
      "Aitor",
      "Lluvia",
      "Luna",
      "Azul"
   };

   for ( auto str : foo )
      cout  << str << endl;

   return 0;
}

Código (c) [Seleccionar] Expandir


while (fgets(leer, 1000, fichero) != NULL) //detecta cuando acaba la informacion del fichero datos.txt
{                                         
fgets(leer,1000,fichero); //lee una linea del fichero , la guarda en leer y pasa a la siguiente linea

dos fgets seguidos?? con esto estas perdiendo la primera lectura.

Código (cpp) [Seleccionar] Expandir


// teniendo ...
registro.setIdCuenta(idCliente);
registro.setNombre(nombre);
registro.setApellido(apellido);
registro.setIngreso(ingreso);

// la escritura quedaria ...
binary_write( escrituraBin, registro.getIdCuenta( ) );
binary_write( escrituraBin, registro.getNombre( ) );
binary_write( escrituraBin, registro.getApellido( ) );
binary_write( escrituraBin, registro.getIngreso( ) );

Y lo mismo para la lectura

Efectivamente, no puedes meter una clase literalmente en el código. La razón es que las clases pueden tener más cosas aparte de los miembros ( por ejemplo información RTTI relativa a la herencia de las clases ).

En C estas cosas no pasan porque no existe la herencia, pero en C++...

Así que lo dicho, copia miembro a miembro y no deberías tener problemas.

El problema que tienes ( al menos uno de ellos ) es que los strings no se "deben" escribir alegremente en un archivo binario. El motivo es que no tiene un tamaño conocido y C++ no va a insertar un carácter de terminación en el archivo... si escribes un dos strings seguidos, en la lectura vas a leer los dos del tirón.

El ejemplo que te he puesto ( que se basa en unas funciones que encontré y mejoré hace ya unos años ) te permiten leer y escribir datos en archivos binarios de una forma sencilla y te permite despreocuparte del tipo de dato concreto... bueno si, el string tiene su función independiente... pero es así para permitir su lectura desde estructuras de C ( que suelen tener tamaño fijo ).

Se puede modificar el código fácilmente para que los strings no sean de tamaño fijo y que su lectura sea símplemente hasta encontrar el caracter nulo:

Código (cpp) [Seleccionar] Expandir


#include <iostream>
#include <fstream>
#include <string>

using namespace std;

template< class T > void
binary_write( ostream& stream, const T& value )
{
  stream.write( reinterpret_cast< const char* >( &value ), sizeof( T ) );
}

template< > void
binary_write( ostream& stream, const string& value )
{
  stream.write( value.c_str( ), value.length( ) );
  stream << '\0';
}

template< class T > void
binary_read( istream& stream, T& value )
{
  stream.read( reinterpret_cast< char* >( &value ), sizeof( T ) );
}

template< > void
binary_read( istream& stream, string& value )
{
  value.clear( );

  while ( true )
  {
    char c;
    stream >> c;
    if ( c == '\0' )
      break;

    value += c;
  }
}

int main()
{
  ofstream fich( "text.txt", ios::out | ios::binary );

  string text1 = "Prueba1";
  string text2 = "Prueba2";
  int dato = 1234;

  binary_write( fich, text1 );
  binary_write( fich, text2 );
  binary_write( fich, dato );

  fich.close( );

  ifstream fich2 = ifstream( "text.txt", ios::in | ios::binary );

  binary_read( fich2, text1 );
  binary_read( fich2, text2 );
  binary_read( fich2, dato );

  cout << text1 << endl << text2 << endl << dato << endl;
}

No no. No tienes que "copiar" un fichero en otro.

Tienes que leer el contenido de uno de los archivos y escribir en el otro.

Lo que sucede es que escribir en binario requiere algún proceso adicional.

El proceso de grabación y lectura de binarios es un poco más escabroso en C++ con respecto a C.

Yo utilizo un par de funciones de ayudas ( me apoyo en templates para evitar reescribir código ):

Código (cpp) [Seleccionar] Expandir


#include <iomanip>
#include <iostream>
#include <fstream>
#include <string>

using namespace std;

template< class T > void
binary_write( ostream& stream, const T& value )
{
  stream.write( reinterpret_cast< const char* >( &value ), sizeof( T ) );
}

void
binary_write_string( ostream& stream, const string& value, int max_size )
{
  int max = max_size - 1;

  if ( value.length( ) < max )
    max = value.length( );
  stream.write( value.c_str( ), max );

  for ( ; max < max_size; max++ )
    stream << '\0';
}

template< class T > void
binary_read( istream& stream, T& value )
{
  stream.read( reinterpret_cast< char* >( &value ), sizeof( T ) );
}

void
binary_read_string( istream& stream, string& value, int max_size )
{
  value.clear( );
  value.reserve( max_size );

  int pos;
  for ( pos = 0; pos < max_size; ++pos )
  {
    char c;
    stream >> c;
    if ( c == '\0' )
      break;

    value += c;
  }

  stream.ignore( max_size - pos - 1 );
}

int main()
{
  ofstream fich( "text.txt", ios::out | ios::binary );

  string text1 = "Prueba1";
  string text2 = "Prueba2";
  int dato = 1234;

  binary_write_string( fich, text1, 10 );
  binary_write_string( fich, text2, 10 );
  binary_write( fich, dato );

  fich.close( );

  ifstream fich2 = ifstream( "text.txt", ios::in | ios::binary );

  binary_read_string( fich2, text1, 10 );
  binary_read_string( fich2, text2, 10 );
  binary_read( fich2, dato );

  cout << text1 << endl << text2 << endl << dato << endl;
}

En tu caso, para pasar de uno a otro primero tienes que leer el contenido del archivo de texto y después grabar el contenido en el archivo binario.

Entendiendo por archivo de texto uno con un contenido legible tal que

Código [Seleccionar] Expandir


100   Pedro   Rodriguez   2000
101   Laura   Fernandez   1890
102   Sergio  Berbes      2685

Pasar esto a binario es tan "sencillo" como volcar la información al fichero sin tratar previamente. Es decir, el código, por ejemplo, en un archivo de texto lo almacenas como si fuese un string, con X caracteres, uno por dígito... en binario este mismo campo ocuparía 4 bytes independientemente del valor del código ( 4 bytes = tamaño por defecto de un int ). Esto es aplicable a floats, booleanos, y demás tipos básicos. En el caso de las cadenas de texto, éstas no sufren ningún cambio.

Dicho esto, para generar un fichero binario desde C++ hay que pasarle un flag especial en la creación para que no haga las conversiones a string ( ios::binary ):

Código (cpp) [Seleccionar] Expandir

ofstream fichero( "fichero.bin", ios::out | ios::binary);

El resto del proceso es el mismo que para generar un fichero de texto normal.

Y para leer este archivo... pues lo mismo, el ifstream lo tienes que configurar con el flag ios::binary;