Club Builder - Foros de discusión Club Builder
Foro de C++Builder en español
 
 FAQFAQ   BuscarBuscar   MiembrosMiembros   Grupos de UsuariosGrupos de Usuarios   RegistrarseRegistrarse 
 PerfilPerfil   Entra para ver tus mensajes privadosEntra para ver tus mensajes privados   EntrarEntrar 

Urgente guardar grilla con apuntador

 
Publicar nuevo tema   Responder al tema    Foros de discusión -> Consultas
Ver tema anterior :: Ver tema siguiente  
Autor Mensaje
Mensaje    Asunto: Urgente guardar grilla con apuntador Responder citando

alguien me podria decir como guardar el
contenido de un stringrid de 500 filas *100 columnas
en un archivo sin necesidad de recorrerla toda,
que es lo que estoy haciendo en este momento y se demora
bastante en guardar todos los datos.
mi inquietud es si se podria guardar como un un apuntador
a la grilla y luego cargarlo para que fuera mas rapido.
gracias por la info. Wink
_________________
Gracias por la colaboracion att. fcotillo
Volver arriba
Ver perfil de usuario Enviar mensaje privado
Mensaje    Asunto: Responder citando

No se como lo estarás guardando para que te funcione tan lento como dices. Recorrerla tendrás que recorrerla.

Prueba las siguientes funciones, para mi van suficientemente rápido, al menos en las últimas versiones y algo más lento en el BCB1:

- Añadimos: #include <memory>
Código:
void StringGrid_Guardar(TStringGrid* grid, String NombreArchivo)
{
    std::auto_ptr<TMemoryStream> stream(new TMemoryStream);

    stream->Write(&(grid->RowCount), sizeof(grid->RowCount));
    stream->Write(&(grid->ColCount), sizeof(grid->ColCount));

    for (int y=0; y < grid->RowCount; y++)
        for (int x=0; x < grid->ColCount; x++)
        {
            int tamanyo = grid->Cells[x][y].Length();
            stream->Write(&tamanyo, sizeof(tamanyo));
            if (tamanyo > 0)
                stream->Write(grid->Cells[x][y].c_str(), tamanyo);
        }

    stream->SaveToFile(NombreArchivo);
}


void StringGrid_Cargar(TStringGrid* grid, String NombreArchivo)
{
    std::auto_ptr<TMemoryStream> stream(new TMemoryStream);
    stream->LoadFromFile(NombreArchivo);

    stream->Read(&(grid->RowCount), sizeof(grid->RowCount));
    stream->Read(&(grid->ColCount), sizeof(grid->ColCount));

    for (int y=0; y < grid->RowCount; y++)
        for (int x=0; x < grid->ColCount; x++)
        {
            int tamanyo;
            stream->Read(&tamanyo, sizeof(tamanyo));
            String str = "";
            str.SetLength(tamanyo);
            if (tamanyo > 0)
                stream->Read(str.c_str(), tamanyo);
            grid->Cells[x][y] = str;
        }
}


Y para usarlas:
    StringGrid_Guardar(StringGrid1, "c:\\datos.g");
    StringGrid_Cargar(StringGrid1, "c:\\datos.g");


PD: Palabras como "urgente" sobran en un foro *gratuito*. Se presupone que para cada uno sus cosas son urgentes y se presupone también que se espera una respuesta lo más pronto posible.
Volver arriba
Ver perfil de usuario Enviar mensaje privado
Mensaje    Asunto: respuesta Responder citando

yo tambien la recorro con dos cilclos

grabar
TIniFile *Ini=new TIniFile("C:\\ec50099.txt");
for(int x=0;x<ta->ColCount;x++) //500 filas
{
for(int y=0;y<ta->RowCount;y++) //99 columnas
Ini->WriteString(x,y, ta->Cells[x][y]);
}
delete Ini;

cargar
TIniFile *Ini=new TIniFile("C:\\archivo1.txt");
ta->RowCount=501;
for(int x=0;x<ta->ColCount;x++)
{
for(int y=0;y<ta->RowCount;y++)
ta->Cells[x][y]= Ini->ReadString(x,y,"");
}
delete Ini;

a eso es que me referia con que se demoraba por que es de 500*99
lo mismo en la cargar de los datos Very Happy
gracias por la informacion ya lo probe.
_________________
Gracias por la colaboracion att. fcotillo
Volver arriba
Ver perfil de usuario Enviar mensaje privado
Mensaje    Asunto: Responder citando

Si, la diferencia es que la rutina que has puesto tu en mi P4-1,7GHZ tarda unos 5 minutos en guardar una grilla de 500 filas por 99 columnas, todas rellenas con una cadena de unos 6 caracteres, y unos 20 segundos en leerla. Mientras que usando TMemoryStream como te he puesto arriba en las mismas condiciones tarda menos de 300 milisegundos tanto en guardarla como en leerla.

La desventaja es que al usar TMemoryStream, durante el momento de leer o guardar usa más RAM, aunque no creo que sea un gran problema al menos para una rejilla de ese tamaño. De todos modos si quieres puedes cambiar TMemoryStream por TFileStream, tardara un poco más, en mi equipo alrededor de 500 milisegundos, pero no necesitara tanta memoria extra.
Volver arriba
Ver perfil de usuario Enviar mensaje privado
Mensaje    Asunto: Responder citando

hola he probado el codigo que me sugeriste y no se demora
nada gracias. el problema que tengo con el codigo es que yo al usuario
le digo que digite la cantidad de columnas y filas
que desea cargar; trate de modificarlo por lo que siempre no necesito cargar 500*99 registros, yo lo limite a que sacara el valor de filas y columnas de que el usuario digita pero me saca valores raros, creo que el problema es cuando guardas la longitud de RowCount
y ColCount, sabes como puedo solucionar eso.

hasta el momento hago lo siguiente con el codigo que me distes para que me funcione lo que te mencione arriba.
lo pongo a cargar todo y luego
grilla->colcount=le asigno lo digitado por el usuario.
grilla->rowcount=le asigno lo digitado por el usuario.
pero como puedes analizar no es lo mas ideal.
con el codigo que yo lo hacia no me sacaba valores raros pero como ya te de dije se demora una eternidad.

con tu codigo trate de hacer lo siguiente
void StringGrid_Guardar(TStringGrid* grid, String NombreArchivo, int fil,int col)
std::auto_ptr<TMemoryStream> stream(new TMemoryStream);
stream->Write(&(grid->RowCount), sizeof(grid->RowCount));
stream->Write(&(grid->ColCount), sizeof(grid->ColCount));

for (int y=0; y < fil; y++)
for (int x=0; x < col; x++)
y el resto de codigo.
no me funciono
_________________
Gracias por la colaboracion att. fcotillo
Volver arriba
Ver perfil de usuario Enviar mensaje privado
Mensaje    Asunto: Responder citando

No es necesario cambiar las rutinas, solo tienes que cambiar las propiedades RowCount y ColCount de la grilla y el código automáticamente la salvara completa tenga las dimensiones que tenga. Y luego para cargar los valores anteriormente guardados no hay que hacer nada especial, la propia rutina cambiara RowCount y ColCount para que se cargue con las mismas dimensiones que se guardo.
Volver arriba
Ver perfil de usuario Enviar mensaje privado
Mensaje    Asunto: Responder citando

Hola _leo
creo que explique mal en mi inquietud anterior yo si necito que los 500*99
esten almaenados, lo que necesito es poder cargar 10*10 o 4*2 o todos datos
en cualquier momento que usuario lo desee. cuando el acceso los datos y yo delimito
por ej. rowCount = 10; colcount=10 el saca 10*10 datos pero no corresponden a los que se duardo en 500*99.
_________________
Gracias por la colaboracion att. fcotillo
Volver arriba
Ver perfil de usuario Enviar mensaje privado
Mensaje    Asunto: Responder citando

A ver si te sirve la función para cargar modificada. Si solo usas dos parámetros como en la anterior cargara el archivo completo, y si especificas en los dos nuevos argumentos el número de columnas y filas solo mostrara esa cantidad:
Código:
void StringGrid_Cargar(TStringGrid* grid, String NombreArchivo,
        int columnas=0, int filas=0)
{
    std::auto_ptr<TMemoryStream> stream(new TMemoryStream);
    stream->LoadFromFile(NombreArchivo);

    // rows y cols contendran siempre el tamaño total de filas
    //   y columnas con el que se guardo originalmente el archivo
    int rows, cols;
    stream->ReadBuffer(&rows, sizeof(rows));
    stream->ReadBuffer(&cols, sizeof(cols));

    // Columnas y filas contendran el tamaño total con el que se
    //   guardo originalmente el archivo en caso de que el valor
    //   especificado sea 0 o mayor que las existentes en el archivo
    if (columnas == 0 || columnas > cols)
        columnas = cols;
    if (filas == 0 || filas > rows)
        filas = rows;

    grid->RowCount = filas;
    grid->ColCount = columnas;

    // Recorremos todo el archivo, pero solo copiamos en la
    //   rejilla las celdas que esten en el rango solicitado
    for (int y=0; y < rows; y++)
        for (int x=0; x < cols; x++)
        {
            int tamanyo;
            stream->ReadBuffer(&tamanyo, sizeof(tamanyo));
            String str = "";
            str.SetLength(tamanyo);
            if (tamanyo > 0)
                stream->ReadBuffer(str.c_str(), tamanyo);
            if (y < filas && x < columnas)
                grid->Cells[x][y] = str;
        }
}


Y para usarla:

- Se puede seguir usando como antes, especificando solo dos parametros:
StringGrid_Cargar(StringGrid1, "c:\\datos.g");

- O bien especificando el numero de columnas y filas
StringGrid_Cargar(StringGrid1, "c:\\datos.g", 99, 500);
Volver arriba
Ver perfil de usuario Enviar mensaje privado
Mostrar mensajes de anteriores:   
Cambiar a:  
No puedes publicar temas nuevos en este foro
No puedes responder a temas en este foro
No puedes editar tus mensajes en este foro
No puedes borrar tus mensajes en este foro
No puedes votar en las encuestas de este foro


Hosting WordPress Indedmedia desde 3,99 €
© 2002–2026 Club Builder · Funciona con phpBB.