• LOCOMOTORA..!!..(Primer Nodo)
  Preguntamos si ya hay una. Si no la hay colocamos una sobre la via.. (La Lista..!!)

• PRIMER VAGON..!!(Segundo Nodo)
  Preguntamos si ya hay una locomotora. Si la hay colocamos una sobre la via.. (La Lista..!!).. luego la enganchamos con la locomotora

• SEGUNDO VAGON..!!(Tercer Nodo)
  Buscamos el último vagón, o sea el primero. Si lo encontramos, colocamos el segundo vagón sobre la via.. (La Lista..!!).. luego la enganchamos con el último vagón.

• SIGUIENTE VAGON..!!(Siguiente Nodo)
  Buscamos el último vagón,  Si lo encontramos, colocamos este vagón sobre la via.. (La Lista..!!).. luego la enganchamos con el último vagón.

Este proceso ha sido aplicado en el siguiente algoritmo..

////////////////////////////////////////////////////////
// C++BUILDER 5               LISTA SIMPLE CON ARCHIV0
//  ListaPrograma.cpp            Wilucha    17/09/98
// Graba sobre en archivo Simple.txt
//---------------------------------------------------------------------------

*PrimerNodo,*NodoActual,*NuevoNodo,*UltimoNodo;
 MiNodo *FichaAuxiliar,FichaTrucha;
 int MensajePorBox,ParametroOrdenar,FlagBaja,Fila;
 int BuscarCodigo(AnsiString);

void AltaDeNuevoNodo(char ParamNombre[30],char ParamEmail[40])
{
  NuevoNodo = new MiNodo[sizeof(MiNodo)];
  strcpy(NuevoNodo->CampoNodoNombre,ParamNombre);
  strcpy(NuevoNodo->CampoNodoEmail,ParamEmail);
  NuevoNodo->FlagNodoBaja=0;
  NuevoNodo->SiguienteNodo=NULL;
  UltimoNodo=NuevoNodo;
  if(PrimerNodo==NULL)
      PrimerNodo=NuevoNodo;
    else
     {
       NodoActual=PrimerNodo;
       while(NodoActual->SiguienteNodo != NULL)
             NodoActual=NodoActual->SiguienteNodo;
       NodoActual->SiguienteNodo=NuevoNodo;
     }
}

..Ojito observa que este proceso inserta nuevos nodos en la lista, pero no en el archivo..!!

//---------------------------------------------------------------------------
__fastcall TMiFormulario::TMiFormulario(TComponent* Owner)
        : TForm(Owner)
{
}
//---------------------------------------------------------------------------
void __fastcall TMiFormulario::FormActivate(TObject *Sender)
{
 FlagBaja=0;
}

//---------------------------------------------------------------------------
void __fastcall TMiFormulario::FormCreate(TObject *Sender)
 {
   Archivo = fopen("Simple.txt","rb");
   while(!feof(Archivo))
        {
          fread(&MiFicha,sizeof(MiFicha),1,Archivo);
          if(!feof(Archivo))
             AltaDeNuevoNodo(MiFicha.CampoFichaNombre,MiFicha.CampoFichaEmail);
        }
   fclose(Archivo);
 }

//---------------------------------------------------------------------------

void __fastcall TMiFormulario::Altas1Click(TObject *Sender)
{
 MiFormulario->Caption="INGRESO DE DATOS";
 Panel->Visible=true;
 BotonGrabar->Visible=true;
 BotonLimpiar->Visible=true;
 BotonEliminar->Visible=false;
 BotonModificar->Visible=false;
 BoxNombre->Clear();
 BoxEmail->Clear();
 BoxNombre->SetFocus();
 Simple1->Enabled=false;
}

//---------------------------------------------------------------------------
void __fastcall TMiFormulario::BotonLimpiarClick(TObject *Sender)
{
 BoxNombre->Clear();
 BoxEmail->Clear();
 BoxNombre->SetFocus();
}

Por supuesto que los nodos dados de alta están vacios..!!!, por lo tanto veamos cómo les grabamos los datos en cada uno de sus campos...

void __fastcall TMiFormulario::BotonGrabarClick(TObject *Sender)
{
 char Nombre[30], Email[40];
 if((BoxNombre->Text=="")||(BoxEmail->Text==""))
   Application->MessageBox("Introduzca datos","Atencion",MB_OK);
  else
   {
    strcpy(Nombre,BoxNombre->Text.c_str());
    strcpy(Email,BoxEmail->Text.c_str());
    if(BuscarNombre(Nombre)==0)
      {
       AltaDeNuevoNodo(Nombre,Email);
       LlenarCombo();
       BoxNombre->Clear();
       BoxEmail->Clear();
       BoxNombre->SetFocus();
      }
     else
      {
       MensajePorBox=Application->MessageBox("Desea ingresarlo nuevamente","Dato existente",MB_OKCANCEL);
       if(MensajePorBox==IDOK)
         {
          strcpy(NodoActual->CampoNodoNombre,BoxNombre->Text.c_str());
          strcpy(NodoActual->CampoNodoEmail,BoxEmail->Text.c_str());
          BoxNombre->Clear();
          BoxEmail->Clear();
          BoxNombre->SetFocus();
         }
        else
         {
          BoxNombre->Clear();
          BoxEmail->Clear();
          BoxNombre->SetFocus();
         }
       }
    }
}
//---------------------------------------------------------------------------

Ahora ya tenemos nuestro trencito con los vagones cargados.. Oohh.!! perdón, tenemos la lista enlazada con sus nodos con datos en sus campos.

En los siguientes links, veremos las operaciones más comunes que podemos efectuar con estos nodos.

En este link encontrarás la codificación de los algoritmos para visualizar los datos que cargaste en cada uno de los nodos de tu estructura dinámica.

//---------------------------------------------------------------------------

void __fastcall TMiFormulario::Consultas1Click(TObject *Sender)
 {
   MiFormulario->Caption="Consulta de datos";
   if(PrimerNodo != NULL)
     {
       PanelCombo->Visible=true;
       Combo->Clear();
       BotonGrabar->Visible=false;
       BotonLimpiar->Visible=false;
       BotonEliminar->Visible=false;
       BotonModificar->Visible=false;
       LlenarCombo();
     }
   else
     Application->MessageBox("No hay datos para consultar","Lista Vacia",MB_OK);
}

//---------------------------------------------------------------------------

Te ofrezco un combo..!!

//---------------------------------------------------------------------------

void TMiFormulario::LlenarCombo()
{
 Combo->Clear();
 Combo->Items->Clear();
 NodoActual=PrimerNodo;
 while(NodoActual != NULL)
      {
        Combo->Items->Add(NodoActual->CampoNodoNombre);
        NodoActual=NodoActual->SiguienteNodo;
 }
}


//---------------------------------------------------------------------------
void __fastcall TMiFormulario::BotonAceptarClick(TObject *Sender)
{
 int LoHalle;
 char DatoBuscado[40];
 AnsiString DatoDelCombo;
 LoHalle=0;
 NuevoNodo=PrimerNodo;
 DatoDelCombo=Combo->Items->Strings[Combo->ItemIndex];
 strcpy(DatoBuscado,DatoDelCombo.c_str());
 while(NuevoNodo!=NULL)
 {
  if(stricmp(NuevoNodo->CampoNodoNombre,DatoBuscado)==0)
  {
   LoHalle=1;
   if(NuevoNodo->FlagNodoBaja!=1)
   {
    Panel->Visible=true;
    PanelCombo->Visible=false;
    BoxNombre->Text=NuevoNodo->CampoNodoNombre;
    BoxEmail->Text=NuevoNodo->CampoNodoEmail;
    NodoActual=NuevoNodo;
    NuevoNodo=NULL;
   }
  }
  else
  NuevoNodo=NuevoNodo->SiguienteNodo;
 }
 if(LoHalle==0)
 {
  ShowMessage("La ficha que busca no ha sido ingresada");
  PanelCombo->Visible=false;
 }
}

//---------------------------------------------------------------------------
void __fastcall TMiFormulario::Visualizar1Click(TObject *Sender)
{
 Fila=1;
 if(PrimerNodo==NULL)
 {
  Application->MessageBox("No hay datos en la lista","Atencion...",MB_OK);
 }
 PanelVisualizar->Visible = true;
 if (PrimerNodo!=NULL)
 {
  Grilla->Cells[0][0]="Nombre";
  Grilla->Cells[1][0]="Email";
  NuevoNodo = PrimerNodo;
  while (NuevoNodo->SiguienteNodo!= NULL)
  {
   Grilla->Cells[0][Fila]=NuevoNodo->CampoNodoNombre;
   Grilla->Cells[1][Fila]=NuevoNodo->CampoNodoEmail;
   Fila=Fila+1;
   while ( Grilla->Cells[0][Fila+1]!="")
   {
    Grilla->Cells[0][Fila+1]="";
    Grilla->Cells[1][Fila+1]="";
   }
   NuevoNodo=NuevoNodo->SiguienteNodo;
  }
  Grilla->Cells[0][Fila]=NuevoNodo->CampoNodoNombre;
  Grilla->Cells[1][Fila]=NuevoNodo->CampoNodoEmail;
 }
 else
 {
  PanelVisualizar->Visible = false;
 }
}

Si nos equivocamos.. no hay drama..!!, buscamos dónde está el error, lo borramos y a otra cosa.!!!

//---------------------------------------------------------------------------

int BuscarNombre(AnsiString UnNombre)
{
 int HayDato=0;
 NodoActual=PrimerNodo;
 if (NodoActual!=NULL)
    while (NodoActual != NULL)
      {
       if ((UnNombre)==NodoActual->CampoNodoNombre)
          {
           HayDato=1;
           break;
          }
       NodoActual=NodoActual->SiguienteNodo;
      }
 return(HayDato);
}

void __fastcall TMiFormulario::Bajas1Click(TObject *Sender)
{
 MiFormulario->Caption="Eliminacion de datos";
 if(PrimerNodo != NULL)
 {
  PanelCombo->Visible=true;
  BotonGrabar->Visible=false;
  BotonLimpiar->Visible=false;
  BotonModificar->Visible=false;
  BotonEliminar->Visible=true;
  Simple1->Enabled=false;
  LlenarCombo();
  FlagBaja=1;
 }
 else
 Application->MessageBox("No hay datos para eliminar","Lista vacia",MB_OK);
}
//---------------------------------------------------------------------------

//---------------------------------------------------------------------------
//BOTON PARA ELIMNAR LOS DATOS
void __fastcall TMiFormulario::BotonEliminarClick(TObject *Sender)
{
 if(PrimerNodo != NULL)
 {
  MensajePorBox=Application->MessageBox("Desea Eliminar estos datos","Eliminacion de datos",MB_OKCANCEL);
  if(MensajePorBox==IDOK)
  {
   FichaAuxiliar=NodoActual;
   if(NodoActual==PrimerNodo)
   PrimerNodo=NodoActual->SiguienteNodo;
   else
   {
    NodoActual=PrimerNodo;
    while(NodoActual->SiguienteNodo != NULL)
    {
     if(NodoActual->SiguienteNodo==FichaAuxiliar)
     {
      FichaTrucha,NodoActual;
      break;
     }
     NodoActual=NodoActual->SiguienteNodo;
    }
    FichaTrucha,FichaAuxiliar->SiguienteNodo;
   }
   delete(FichaAuxiliar);
   LlenarCombo();
   Application->MessageBox("Los datos fueron eliminados","Eliminacion de datos",MB_OK);
  }
 }
 else
 Application->MessageBox("No hay datos a eliminar","La lista HayDato vacia",MB_OK);
 BoxNombre->Clear();
 BoxEmail->Clear();
}
//---------------------------------------------------------------------------

Si deseas corregir el contenido de un nodo en particular, lo ubicas a este y luego activas el siguiente algoritmo

//---------------------------------------------------------------------------
void __fastcall TMiFormulario::BotonModificarClick(TObject *Sender)
{
 strcpy(NodoActual->CampoNodoNombre,BoxNombre->Text.c_str());
 strcpy(NodoActual->CampoNodoEmail,BoxEmail->Text.c_str());
 Application->MessageBox("Los datos ya han sido modificados","Modificacion de datos",MB_OK);
 BoxNombre->Clear();
 BoxEmail->Clear();
 BoxNombre->SetFocus();
}

//---------------------------------------------------------------------------
void __fastcall TMiFormulario::Modificaciones1Click(TObject *Sender)
{
 MiFormulario->Caption="Modificacion de datos";
 if(PrimerNodo != NULL)
 {
  PanelCombo->Visible=true;
  Combo->Clear();
  BotonGrabar->Visible=false;
  BotonLimpiar->Visible=true;
  BotonModificar->Visible=true;
  BotonEliminar->Visible=false;
  Simple1->Enabled=false;
  LlenarCombo();
 }
 else
 Application->MessageBox("No hay datos para modificar","Lista vacia",MB_OK);
}

//---------------------------------------------------------------------------

A tu sistema le hará falta los siguientes accesorios...

void __fastcall TMiFormulario::BotonRegresarClick(TObject *Sender)
{
 Panel->Visible=False;
 Simple1->Enabled=true;
 MiFormulario->Caption="Agenda de Wilo";
}


//---------------------------------------------------------------------------
void __fastcall TMiFormulario::BotonVolverClick(TObject *Sender)
{
 PanelVisualizar->Visible=false;
}
//---------------------------------------------------------------------------
void __fastcall TMiFormulario::Imprimir1Click(TObject *Sender)
{
 int RespuestaDeBox;
 {
  RespuestaDeBox=Application->MessageBox("Tu impresora HayDato prendida?","Atencion",MB_OKCANCEL);
  if (RespuestaDeBox==IDOK)
     PrintDialog1->Execute();
 }
}
//---------------------------------------------------------------------------

void __fastcall TMiFormulario::PorNombre1Click(TObject *Sender)
{
 if(PrimerNodo != NULL)
 {
  Ordenar(ParametroOrdenar);
 }
 else
 Application->MessageBox("No hay datos para ordenar","Lista vacia",MB_OK);
}

void TMiFormulario::Ordenar(int ParametroOrdenar)
{
  if(PrimerNodo!=NULL)
 {
  MiNodo *a,*b,*c;
  if (Application->MessageBox("Se Ordenarán los Elementos de la Lista","ORDENAR",MB_ICONEXCLAMATION+MB_OKCANCEL)==1)
  {
   a=PrimerNodo;
   while(a->SiguienteNodo!=NULL)
   {
    b=a->SiguienteNodo;
    while(b!=NULL)
    {
     if (strcmp(a->CampoNodoNombre,b->CampoNodoNombre)>0)
     {
      c=new(MiNodo);
      strcpy(c->CampoNodoNombre,a->CampoNodoNombre);
      strcpy(c->CampoNodoEmail,a->CampoNodoEmail);
      strcpy(a->CampoNodoNombre,b->CampoNodoNombre);
      strcpy(a->CampoNodoEmail,b->CampoNodoEmail);
      strcpy(b->CampoNodoNombre,c->CampoNodoNombre);
      strcpy(b->CampoNodoEmail,c->CampoNodoEmail);
     }
     b=b->SiguienteNodo;
    }
    a=a->SiguienteNodo;
   }
  }
 }
 else
 {
  Application->MessageBox("No Hay Datos","ORDENAR",MB_DEFBUTTON1+MB_ICONEXCLAMATION);
 }
}

/////////////////////////////////////////////////////////////////
// C++BUILDER 5               LISTA SIMPLE CON ARCHIV0
//  ListaPrograma.cpp            Wilucha    22/09/02
//---------------------------------------------------------------
// Al iniciar el programa se transfieren los datos grabados en un
// archivo secuencial a los nodos de una lista.
//---------------------------------------------------------------
// Las operaciones ABM y consultas solo se hacen sobre los nodos
//---------------------------------------------------------------
// Al terminar el programa se transfieren los datos registrados en
// los nodos de una lista a un archivo secuencial.
//---------------------------------------------------------------
  #include < vcl.h >
  #include < fstream.h >
  #include < stdlib.h >
  #pragma hdrstop
  #include "ListaPrograma.h"
  #pragma package(smart_init)
  #pragma resource "*.dfm"
//-----------------------------------------------------------------

TMiFormulario *MiFormulario;
//////////////////////////////////////////////////////////
//  DECLARACION DE LA ESTRUCTURA DEL NODO
//////////////////////////////////////////////////////////
struct MiNodo
{
  char CampoNodoNombre[30];
  char CampoNodoEmail[40];
  int  FlagNodoBaja;
  struct MiNodo *PunteroDeNodo;
}

//////////////////////////////////////////////////////////
//   DECLARACION DE VARIABLES GLOBALES
//////////////////////////////////////////////////////////
*PrimerNodo,*NodoActual,*NuevoNodo,*UltimoNodo;
 MiNodo *FichaAuxiliar,FichaTrucha;
 int MensajePorBox,ParametroOrdenar,FlagBaja,FilaNro;
 int BuscarCodigo(AnsiString);

//////////////////////////////////////////////////////////
//   DECLARACION DE LA ESTRUCTURA DE LA FICHA
//////////////////////////////////////////////////////////
 struct UnaFicha
 {
   char CampoFichaNombre[30];
   char CampoFichaEmail[40];
  };

//////////////////////////////////////////////////////////
//  DECLARACION DEL ARCHIVO A USAR
//////////////////////////////////////////////////////////
 FILE *Archivo;
 UnaFicha MiFicha;

//////////////////////////////////////////////////////////
//  DECLARACION DEL UNICO FORMULARIO CONTENEDOR
//////////////////////////////////////////////////////////
__fastcall TMiFormulario::TMiFormulario(TComponent* Owner)
        : TForm(Owner)
{
}
//////////////////////////////////////////////////////////
//  OPERACION AL ACTIVARSE EL FORMULARIO
//////////////////////////////////////////////////////////
void __fastcall TMiFormulario::FormActivate(TObject *Sender)
{
 FlagBaja=0;
}

//////////////////////////////////////////////////////////
//   FUNCION PARA CREAR NUEVO NODO: Tiene 2 parámetros
//////////////////////////////////////////////////////////
void AltaDeNuevoNodo(char ParamNombre[30],char ParamEmail[40])
{
  NuevoNodo = new MiNodo[sizeof(MiNodo)];
  strcpy(NuevoNodo->CampoNodoNombre,ParamNombre);
  strcpy(NuevoNodo->CampoNodoEmail,ParamEmail);
  NuevoNodo->FlagNodoBaja=0;
  NuevoNodo->PunteroDeNodo=NULL;
  UltimoNodo=NuevoNodo;
  if(PrimerNodo==NULL)
      PrimerNodo=NuevoNodo;
    else
     {
       NodoActual=PrimerNodo;
       while(NodoActual->PunteroDeNodo != NULL)
             NodoActual=NodoActual->PunteroDeNodo;
       NodoActual->PunteroDeNodo=NuevoNodo;
     }
}

//////////////////////////////////////////////////////////
//  FUNCIÓN PARA BUSCAR UN DATO EN LA LISTA
//////////////////////////////////////////////////////////
int BuscarNombre(AnsiString UnNombre)
{
 int HayDato=0;
 NodoActual=PrimerNodo;
 if (NodoActual!=NULL)
    while (NodoActual != NULL)
      {
       if ((UnNombre)==NodoActual->CampoNodoNombre)
          {
           HayDato=1;
           break;
          }
       NodoActual=NodoActual->PunteroDeNodo;
      }
 return(HayDato);
}

//////////////////////////////////////////////////////////
//    CARGAR DATOS EN CAMPOS DEL NODO
//////////////////////////////////////////////////////////
void __fastcall TMiFormulario::GrabarDatosDeBoxesClick(TObject *Sender)
{
 char Nombre[30], Email[40];
 if((BoxNombre->Text=="")||(BoxEmail->Text==""))
   Application->MessageBox("Digita los datos","Atencion",MB_OK);
  else
   {
    strcpy(Nombre,BoxNombre->Text.c_str());
    strcpy(Email,BoxEmail->Text.c_str());
    if(BuscarNombre(Nombre)==0)
      {
       AltaDeNuevoNodo(Nombre,Email);
       LlenarCombo();
       BoxNombre->Clear();
       BoxEmail->Clear();
       BoxNombre->SetFocus();
      }
     else
      {
       MensajePorBox=Application->MessageBox("Quieres volver a ingresarlo","OJITO: Dato existente..!!",MB_OKCANCEL);
       if(MensajePorBox==IDOK)
         {
          strcpy(NodoActual->CampoNodoNombre,BoxNombre->Text.c_str());
          strcpy(NodoActual->CampoNodoEmail,BoxEmail->Text.c_str());
          BoxNombre->Clear();
          BoxEmail->Clear();
          BoxNombre->SetFocus();
         }
        else
         {
          BoxNombre->Clear();
          BoxEmail->Clear();
          BoxNombre->SetFocus();
         }
       }
    }
}

/////////////////////////////////////////////////////////////////////
//                ARCHIVOS SECUENCIALES
/////////////////////////////////////////////////////////////////////
// Archivo = fopen("NombreDeArchivo","ModoDeUso")
// Abro archivo secuencial "Simple.txt" en modo lectura "rb"
//------------------------------------------------------------------
// fread(&MiFicha,sizeof(MiFicha),1,Archivo): Leo 1 ficha de Archivo
//------------------------------------------------------------------
// fclose(Archivo)   Cierra el archivo
////////////////////////////////////////////////////////////////////
//  CARGA de la LISTA con el ARCHIVO EXISTENTE: "Simple.txt"
//  Cada ficha se transfiere a cada nodo de la lista
////////////////////////////////////////////////////////////////////
void __fastcall TMiFormulario::FormCreate(TObject *Sender)
{
  Archivo = fopen("Simple.txt","rb");
  while(!feof(Archivo))
    {
      fread(&MiFicha,sizeof(MiFicha),1,Archivo);
      if(!feof(Archivo))
        AltaDeNuevoNodo(MiFicha.CampoFichaNombre,MiFicha.CampoFichaEmail);
    }
 fclose(Archivo);
}
///////////////////////////////////////////////////////////////////////
//  CARGA de los NODOS de la LISTA al ARCHIVO EXISTENTE: "Simple.txt"
//  Cada Nodo se transfiere a cada Ficha del archino
//  fwrite(&MiFicha, sizeof(MiFicha),1,Archivo): Grabo una ficha
////////////////////////////////////////////////////////////////////
void __fastcall TMiFormulario::Salir1Click(TObject *Sender)
 {
   MiNodo *NodoAuxiliar;
   NodoAuxiliar=PrimerNodo;
   if(Application->MessageBox("Deseas grabar las modificaciones en el archivo..", "ESTAS POR CERRAR EL PROGRAMA", MB_OKCANCEL+ MB_DEFBUTTON1|MB_ICONQUESTION)==IDOK)
     {
       Close();
       Archivo=fopen("Simple.txt","wb");
       while(NodoAuxiliar != NULL)
         {
           strcpy(MiFicha.CampoFichaNombre,NodoAuxiliar->CampoNodoNombre);
           strcpy(MiFicha.CampoFichaEmail,NodoAuxiliar->CampoNodoEmail);
           fwrite(&MiFicha, sizeof(MiFicha),1,Archivo);
           NodoAuxiliar=NodoAuxiliar->PunteroDeNodo;
         }
       fclose(Archivo);
     }
 }

//////////////////////////////////////////////////////////
//
//////////////////////////////////////////////////////////
void __fastcall TMiFormulario::Altas1Click(TObject *Sender)
{
 MiFormulario->Caption="INGRESO DE DATOS";
 PanelAltas->Visible=true;
 GrabarDatosDeBoxes->Visible=true;
 BotonLimpiar->Visible=true;
 BotonEliminar->Visible=false;
 BotonModificar->Visible=false;
 BoxNombre->Clear();
 BoxEmail->Clear();
 BoxNombre->SetFocus();
 Simple1->Enabled=false;
}

//////////////////////////////////////////////////////////
//  BOTON LIMPIAR DEL PANEL DE ALTAS
//////////////////////////////////////////////////////////
void __fastcall TMiFormulario::BotonLimpiarClick(TObject *Sender)
{
 BoxNombre->Clear();
 BoxEmail->Clear();
 BoxNombre->SetFocus();
}

//////////////////////////////////////////////////////////
//  CARGAR ComboNombre CON CAMPO DE NODO
//////////////////////////////////////////////////////////
void TMiFormulario::LlenarCombo()
{
 ComboNombre->Clear();
 ComboNombre->Items->Clear();
 NodoActual=PrimerNodo;
 while(NodoActual != NULL)
   {
    ComboNombre->Items->Add(NodoActual->CampoNodoNombre);
    NodoActual=NodoActual->PunteroDeNodo;
   }
}

//////////////////////////////////////////////////////////
//   ORDENAR NODOS POR BURBUJA
//////////////////////////////////////////////////////////
void TMiFormulario::Ordenar(int ParametroOrdenar)
{
  if(PrimerNodo!=NULL)
 {
  MiNodo *a,*b,*c;
  if (Application->MessageBox("Se Ordenarán los Elementos de la Lista","ORDENAR",MB_ICONEXCLAMATION+MB_OKCANCEL)==1)
  {
   a=PrimerNodo;
   while(a->PunteroDeNodo!=NULL)
     {
       b=a->PunteroDeNodo;
       while(b!=NULL)
         {
           if (strcmp(a->CampoNodoNombre,b->CampoNodoNombre)>0)
              {
               c=new(MiNodo);
               strcpy(c->CampoNodoNombre,a->CampoNodoNombre);
               strcpy(c->CampoNodoEmail,a->CampoNodoEmail);
               strcpy(a->CampoNodoNombre,b->CampoNodoNombre);
               strcpy(a->CampoNodoEmail,b->CampoNodoEmail);
               strcpy(b->CampoNodoNombre,c->CampoNodoNombre);
               strcpy(b->CampoNodoEmail,c->CampoNodoEmail);
              }
            b=b->PunteroDeNodo;
          }
        a=a->PunteroDeNodo;
     }
  }
 }
 else
 {
  Application->MessageBox("No Hay Datos","ORDENAR",MB_DEFBUTTON1+MB_ICONEXCLAMATION);
 }
}

//////////////////////////////////////////////////////////
//  ORDENAR POR NOMBRES
//////////////////////////////////////////////////////////
void __fastcall TMiFormulario::PorNombre1Click(TObject *Sender)
{
 if(PrimerNodo != NULL)
 {
  Ordenar(ParametroOrdenar);
 }
 else
 Application->MessageBox("No hay datos para ordenar","Lista vacia",MB_OK);
}

//////////////////////////////////////////////////////////
//                    MODIFICACIONES
//////////////////////////////////////////////////////////
void __fastcall TMiFormulario::Modificaciones1Click(TObject *Sender)
{
 MiFormulario->Caption="Modificacion de datos";
 if(PrimerNodo != NULL)
 {
  PanelCombo->Visible=true;
  ComboNombre->Clear();
  GrabarDatosDeBoxes->Visible=false;
  BotonLimpiar->Visible=true;
  BotonModificar->Visible=true;
  BotonEliminar->Visible=false;
  Simple1->Enabled=false;
  LlenarCombo();
 }
 else
 Application->MessageBox("No hay datos para modificar","Lista vacia",MB_OK);
}

//////////////////////////////////////////////////////////
//                  BAJAS
//////////////////////////////////////////////////////////
void __fastcall TMiFormulario::Bajas1Click(TObject *Sender)
{
 MiFormulario->Caption="Eliminacion de datos";
 if(PrimerNodo != NULL)
 {
  PanelCombo->Visible=true;
  GrabarDatosDeBoxes->Visible=false;
  BotonLimpiar->Visible=false;
  BotonModificar->Visible=false;
  BotonEliminar->Visible=true;
  Simple1->Enabled=false;
  LlenarCombo();
  FlagBaja=1;
 }
 else
 Application->MessageBox("No hay datos para eliminar","Lista vacia",MB_OK);
}

//////////////////////////////////////////////////////////
//               REGRESAR
//////////////////////////////////////////////////////////
void __fastcall TMiFormulario::BotonRegresarClick(TObject *Sender)
{
 PanelAltas->Visible=False;
 Simple1->Enabled=true;
 MiFormulario->Caption="Agenda de Wilo";
}

//////////////////////////////////////////////////////////
//        BAJA DE NODO
//////////////////////////////////////////////////////////
void __fastcall TMiFormulario::BotonEliminarClick(TObject *Sender)
{
 if(PrimerNodo != NULL)
 {
  MensajePorBox=Application->MessageBox("Desea Eliminar estos datos","Eliminacion de datos",MB_OKCANCEL);
  if(MensajePorBox==IDOK)
  {
   FichaAuxiliar=NodoActual;
   if(NodoActual==PrimerNodo)
   PrimerNodo=NodoActual->PunteroDeNodo;
   else
   {
    NodoActual=PrimerNodo;
    while(NodoActual->PunteroDeNodo != NULL)
    {
     if(NodoActual->PunteroDeNodo==FichaAuxiliar)
     {
      FichaTrucha,NodoActual;
      break;
     }
     NodoActual=NodoActual->PunteroDeNodo;
    }
    FichaTrucha,FichaAuxiliar->PunteroDeNodo;
   }
   delete(FichaAuxiliar);
   LlenarCombo();
   Application->MessageBox("Los datos fueron eliminados","Eliminacion de datos",MB_OK);
  }
 }
 else
 Application->MessageBox("No hay datos a eliminar","La lista HayDato vacia",MB_OK);
 BoxNombre->Clear();
 BoxEmail->Clear();
}


//////////////////////////////////////////////////////////
//     MODIFICACIONES
//////////////////////////////////////////////////////////
void __fastcall TMiFormulario::BotonModificarClick(TObject *Sender)
{
 strcpy(NodoActual->CampoNodoNombre,BoxNombre->Text.c_str());
 strcpy(NodoActual->CampoNodoEmail,BoxEmail->Text.c_str());
 Application->MessageBox("Los datos ya han sido modificados","Modificacion de datos",MB_OK);
 BoxNombre->Clear();
 BoxEmail->Clear();
 BoxNombre->SetFocus();
}

//////////////////////////////////////////////////////////
//              CONSULTAS
//////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////
//    BUSQUEDA POR COMBO
//////////////////////////////////////////////////////////
void __fastcall TMiFormulario::AceptarDatoComboClick(TObject *Sender)
{
 int LoHalle;
 char DatoBuscado[40];
 AnsiString DatoDelCombo;
 LoHalle=0;
 NuevoNodo=PrimerNodo;
 DatoDelCombo=ComboNombre->Items->Strings[ComboNombre->ItemIndex];
 strcpy(DatoBuscado,DatoDelCombo.c_str());
 while(NuevoNodo!=NULL)
 {
  if(stricmp(NuevoNodo->CampoNodoNombre,DatoBuscado)==0)
  {
   LoHalle=1;
   if(NuevoNodo->FlagNodoBaja!=1)
   {
    PanelAltas->Visible=true;
    PanelCombo->Visible=false;
    BoxNombre->Text=NuevoNodo->CampoNodoNombre;
    BoxEmail->Text=NuevoNodo->CampoNodoEmail;
    NodoActual=NuevoNodo;
    NuevoNodo=NULL;
   }
  }
  else
  NuevoNodo=NuevoNodo->PunteroDeNodo;
 }
 if(LoHalle==0)
 {
  ShowMessage("La ficha que busca no ha sido ingresada");
  PanelCombo->Visible=false;
 }
}

//////////////////////////////////////////////////////////
//             VOLVER
//////////////////////////////////////////////////////////
void __fastcall TMiFormulario::BotonVolverClick(TObject *Sender)
{
 PanelGrilla->Visible=false;
}

//////////////////////////////////////////////////////////
//       VISUALIZACION DEL COMBO
//////////////////////////////////////////////////////////
void __fastcall TMiFormulario::BuscarOpcionClick(TObject *Sender)
{
 MiFormulario->Caption="Consulta de datos";
 if(PrimerNodo != NULL)
  {
   PanelCombo->Visible=true;
   ComboNombre->Clear();
   GrabarDatosDeBoxes->Visible=false;
   BotonLimpiar->Visible=false;
   BotonEliminar->Visible=false;
   BotonModificar->Visible=false;
   LlenarCombo();
  }
 else
  Application->MessageBox("No hay datos para consultar","Lista Vacia",MB_OK);

}

//////////////////////////////////////////////////////////
//          VER DATOS POR GRILLA
//////////////////////////////////////////////////////////
void __fastcall TMiFormulario::GrillaOpcionClick(TObject *Sender)
{
 FilaNro=1;
 if(PrimerNodo==NULL)
  {
   Application->MessageBox("No hay datos en la lista","Atencion...",MB_OK);
  }
 PanelGrilla->Visible = true;
 if (PrimerNodo!=NULL)
   {
    MiGrilla->Cells[0][0]="Nombre";
    MiGrilla->Cells[1][0]="Email";
    NuevoNodo = PrimerNodo;
    while (NuevoNodo->PunteroDeNodo!= NULL)
       {
         MiGrilla->Cells[0][FilaNro]=NuevoNodo->CampoNodoNombre;
         MiGrilla->Cells[1][FilaNro]=NuevoNodo->CampoNodoEmail;
         FilaNro=FilaNro+1;
         while ( MiGrilla->Cells[0][FilaNro+1]!="")
            {
              MiGrilla->Cells[0][FilaNro+1]="";
              MiGrilla->Cells[1][FilaNro+1]="";
            }
         NuevoNodo=NuevoNodo->PunteroDeNodo;
       }
    MiGrilla->Cells[0][FilaNro]=NuevoNodo->CampoNodoNombre;
    MiGrilla->Cells[1][FilaNro]=NuevoNodo->CampoNodoEmail;
   }
  else
   {
    PanelGrilla->Visible = false;
   }
}

//---------------------------------------------------------------------------
void __fastcall TMiFormulario::SalirOpcionClick(TObject *Sender)
{
   MiNodo *NodoAuxiliar;
   NodoAuxiliar=PrimerNodo;
   if(Application->MessageBox("Deseas grabar las modificaciones en el archivo..", "ESTAS POR CERRAR EL PROGRAMA", MB_OKCANCEL+ MB_DEFBUTTON1|MB_ICONQUESTION)==IDOK)
     {
       Close();
       Archivo=fopen("Simple.txt","wb");
       while(NodoAuxiliar != NULL)
         {
           strcpy(MiFicha.CampoFichaNombre,NodoAuxiliar->CampoNodoNombre);
           strcpy(MiFicha.CampoFichaEmail,NodoAuxiliar->CampoNodoEmail);
           fwrite(&MiFicha, sizeof(MiFicha),1,Archivo);
           NodoAuxiliar=NodoAuxiliar->PunteroDeNodo;
         }
       fclose(Archivo);
     }
}
//////////////////////////////////////////////////////////
//          IMPRIMIR
//////////////////////////////////////////////////////////

void __fastcall TMiFormulario::ImprimeOpcionClick(TObject *Sender)
 {
  if (Application->MessageBox("OJITO: Tu impresora está prendida..??","Atencion",MB_OKCANCEL)==IDOK)
     PrintDialog1->Execute();
 }
//---------------------------------------------------------------------------

	Vector	Matriz	Puntero	Lista	Cola	Arbol	Archivo	Editor	Agenda	Base Datos	Modelo

Amigo virtual en este page podrás apreciar la aplicación de los algoritmos típicos que se requieren para procesar una base de datos compuesta por una sola tabla, que fue creada usando Visual Fox Pro. Por supuesto que la estructura de este sistema, es valido para cualquier otra tabla generada por otro entorno, tal como Access, Paradox, DBase u otro estandar.

Te propongo algoritmos para altas, bajas, consulta, búsqueda e impresión del contenido de la base de datos. Si eres novell en estos menesteres, te recomiendo editar textualmente mi programa fuente, luego compilar.
Dado que una base de datos es el contenedor de información registrada en tablas, conexiones ODBC y procedimientos almacenados; podemos simplificar y afirmar que es el conjunto de tablas e índices pertenecientes a un mismo sistema de información.

Para utilizar una tabla determinada de la base de datos, esta debe ser abierta de manera que tanto la tabla y la base de datos queden activados.

El sistema de gestión de bases de datos incorporado en la versión de C++ Bulder 5, se utiliza como diccionario de datos para apoyar el desarrollo de aplicaciones o su uso interactivo desde la ventana de database desktop.

Por ello, si modificamos un registro, las reglas de validación están automáticamente activas. Asi, si existe una condición que impide grabar un campo determinado con igual contenido, cuando se intenta actualizar el registro actual, se produce una advertencia de validación.

C++ Builder, permite además, guardar nombres largos de campo o su descripción, evitando el problema del uso de nombres crípticos por la limitación de la longitud de los nombres de campo, como ocurría antes.

Otra característica interesante de C++ Builder, son sus vistas o consultas SQL almacenadas en la base de datos, cuya particularidad es pueden hacerse uso como una tabla, de modo que puedes, abrirlas, cerrarlas o actualizar las tablas que han intervenido en tal consulta.

De acuerdo a la ubicación física de la tabla consultada podemos tener una:

• VISTA LOCAL: Utiliza tablas de la propia base de datos

• VISTA REMOTA: Vistas que utilizan a través de ODBC cualquier origen de datos que soporte esta norma.

La base de datos posee los procedimientos almacenados, que permiten incluir código que pueda ser usado desde que se activa la base de datos, pudiendo utilizar tal código, por ejemplo, para incluir una rutina de numeración automática de códigos para los registros que se vayan añadiendo a la tabla.

TABLA LIBRE: Es aquella que no pertenece a una base de datos, por tanto no posee características aplicadas a las tablas pertenecientes a una base de datos.

LA BASE DE DATOS PUEDE CONTENER

1. TABLAS: Guarda el nombre, la descripción y las reglas de validación a nivel de fila.

2. VISTAS: Consultas actualizables realizadas a tablas de la propia base de datos.

   Se guarda información acerca de las columnas seleccionadas, los criterios de recuperación de registros, el orden de las filas o los campos actualizables.

3. CAMPOS: Guarda el nombre, la descripción y las reglas de validación a nivel de columna.

4. INDICE: Guarda el tipo de índice: principal, candidato, regular o normal.

5. VISTAS REMOTAS: Consultas actualizables realizadas a tablas remotas situadas en algún servidor de datos.

   Se guarda información acerca de las columnas seleccionadas, los criterios de recuperación de registros, el orden de las filas o los campos actualizables.

6. CONEXIONES: Con información acerca de una conexión hecha vía ODBC a algún servidor de datos.

   Esta información se utiliza posteriormente para generar vistas remota.

7. PROCEDIMIENTOS: Procedimientos almacenados, consistente en la información generada por el generador de integridad referencial o procedimientos de usuario.

   Los procedimientos contenidos en la base de datos están disponibles en tanto en cuanto la base de datos este abierta.

   Contiene, además, el código relativo a las reglas de validación.

   Por tanto, cada vez que se produce algún evento de inserción, modificación o eliminación, se ejecuta este código.

1.- CREAR BASE DE DATOS con VISUAL FOX

Para crear una base de datos en VISUAL FOX se puede seguir algunos de estos procedimientos:

1. Desde el generador de proyectos, escoja nuevo posicionado en la fila bases de datos de la pagina datos.

2. Desde el menú principal,

   Escoja del menú archivo la opción nuevo (CTRL-N) o escoja el botón de comando nuevo de la barra de herramientas estándar.

   Visualice a continuación el cuadro de dialogo para la elección del nuevo tipo de fichero a crear.

   Escoja base de datos.

3. Desde la ventana de comandos, emitiendo la sentencia create project.

2.- CREAR BASE DE DATOS desde C++Builder

Para efectuar este proceso, proceda de la siguiente forma:

1. Desde el generador de proyectos, escoja Nuevo posicionado en la fila Tablas de la base de datos a la cual quiere que pertenezca la nueva tabla. No es necesario que este editando la base de datos con el generador de bases de datos.

2. Desde el menú principal, escoja del menú Archivo la opción Nuevo (CTRL-N) o escoja el botón de comando Nuevo de la barra de herramientas Estándar. Solo es posible realizar estas acciones cuando se esta editando la base de datos en el generador de bases de datos.

3. Si esta editando la base de datos directamente, escoja el botón de comando Nueva Tabla de la barra de herramientas Generador de bases de datos.

   También puede pulsar el botón derecho en cualquier zona libre de la ventana del generador y escoger del menú subsiguiente la opción Nueva Tabla.

3.- CREAR BASE DE DATOS desde C++ Builder

1. Desde el generador de proyectos, escoja Data Access, y elija Data Source.

2. También debe elegir Table para trabajar con la tabla designada.

3. Una vez que ya tengo la tabla, en las propiedades de Data Source (Data Set), poner el nombre de la tabla que estoy utilizando.

USO de BASE DE DATOS

Crear y mantener la información del contenedor de bases de datos se realiza mediante los comandos CREATE DATABASE NombreArchivo y MODIFY DATABASE [NombreBaseDatos], respectivamente.

El primero crea la base de datos y abre el diseñador de base de datos.

El segundo necesita una base de datos abierta y activa. Si no es así, muestra el cuadro de dialogo Abrir para elegir la base de datos a modificar.

Para que se pueda acceder a la información de un contenedor de base de datos, es necesario, en primer lugar, abrir la base de datos mediante el comando OPEN DATABASE NombreArchivo.

Se puede abrir varias bases de datos a la vez.

Cuando se abre una base de datos, esta queda disponible, pero no activa. Esto quiere decir que algunos comandos y funciones no actuaran correctamente.

La razón es que trabajan sobre la base de datos activa; por tanto, no basta con abrir solo la base de datos, hay que activarla.

Para este ultimo cometido se ha de utilizar SET DATABASE TO [NombreBaseDatos].

Cerrar la base de datos activa es tan sencillo como utilizar el comando CLOSE DATABASE.

Cuando se abre y activa una base de datos, la función DBC() devuelve el nombre de la base de datos activa.

Si existe la seguridad de que una base de datos esta abierta, aunque no este activa, se puede confirmar mediante la función DBUSED (NombreBaseDatos).

De todos modos, aun se puede ir un poco mas allá y almacenar en una matriz todas las bases de datos abiertas. Este resultado se obtiene mediante la función ADATABASES().

Para eliminar físicamente del disco una base de datos se utiliza el comando DELETE DATABASE NombreBaseDatos. Este comando elimina los ficheros DBC, DCT y DCX relacionado con la base de datos. También elimina toda referencia a la base de datos en las tabas que contenía; por tanto, estas pasan a ser tablas libres.

CREAR TABLA de DATOS desde C++ Builder

1. Desde la opción tools, elegir DataBase Desktop, en donde abrirá una ventana.

2. En file, elegir new y luego table, donde te dará la opción de elegir el tipo de tabla que desees utilizar .

3. Una vez elegida apretar ok, en donde aparecerá la tabla para ser creada.

4. Poner los campos a usar y su tipo y tamaño.

5. Luego guardar la tabla con Save As.

USAR TABLA de DATOS desde C++ Builder

1. Con el table elegido de Data Source, utilizar las propiedades para relacionarlo con la tabla creada.

2. En las propiedades, en TableName, escribir el camino de donde se encuentra la tabla que necesitare.

3. Por ultimo, en Active cambiar false por true, si el camino esta bien, no habrá ningún problema. Ya puedo trabajar con mi tabla.

/////////////////////////////////////////////////
//  C++ BUILDER 5        BASE de DATOS
//                      Con una tabla dbf
//   Wilo Carpio           30/11/20001
/////////////////////////////////////////////////


///////////////////////////////////////////////////
//  DECLARACION DE VARIABLES GLOBALES
///////////////////////////////////////////////////
AnsiString DatoBuscado;

CREANDO NUEVA FICHA

Para generar un nuevo tregistro puedes usar los procedimientos SQL o simplemente recurrir a la función Append() cuya sintaxis puedes apreciar en las siguientes lineas.

///////////////////////////////////////////////////
//  ACTIVANDO BOTON ALTAS
///////////////////////////////////////////////////
void __fastcall TMiFormulario::BotonAltasClick(TObject *Sender)
{
  MiFormulario->Caption = "ALTA DE REGISTROS";
  PanelAltas->Caption="Digita los datos, luego graba";
  ActivoPanelAltas();
  MuestroBoxDatos();
  LimpioLosBoxes();
  HabilitoBoxDatos();
  BoxNombre->SetFocus();
};


///////////////////////////////////////////////////
//  GRABACION DE UN REGISTRO EN LA TABLA
///////////////////////////////////////////////////
void __fastcall TMiFormulario::GrabarDatosClick(TObject *Sender)
{
 GrabarDatos->Visible=false;
  AceptarDatos->Visible=false;
  if (MiFormulario->Caption == "ALTA DE REGISTROS")
     {
       TLocateOptions Resultado;
       Resultado = Resultado < < loPartialKey;
       if (MiTabla - > Locate ( "nombre",BoxNombre->Text,Resultado))
            {
              ShowMessage("Ese Mono Ya Está Grabado");
              LimpioLosBoxes();
              BoxNombre->SetFocus();
           }
          else
           {
              MiTabla->Append();
              LeoDatosDeBoxes();
              MiTabla->Post();
              LimpioLosBoxes();
              BoxNombre->SetFocus();
           }
      }
    else
     if (MiFormulario->Caption =="MODIFICAR REGISTRO")
        {
           MiTabla->Edit();
           LeoDatosDeBoxes();
           MiTabla->Post();
        }
       else
        if (MiFormulario->Caption =="BAJA DE REGISTRO")
           {
             MiTabla->Delete();
             MiTabla->Refresh();
           };
};

///////////////////////////////////////////////////
//   CERRANDO PANEL DE ALTAS
///////////////////////////////////////////////////
void __fastcall TMiFormulario::CerrarAltasClick(TObject *Sender)
{
    ActivoPanelABM();
}

GRILLAS DE DATOS

La manera más simple de visualizar el contenido de tu tabla es recurrir a la grilla de datos

///////////////////////////////////////////////////
//  ACTIVANDO PANEL CON LA GRILLA DE DATOS
///////////////////////////////////////////////////
void __fastcall TMiFormulario::BotonGrillaClick(TObject *Sender)
{
  ActivoPanelGrilla();
};
void ActivoPanelGrilla(void)
{
   MiFormulario->Caption="'GRILLA DE DATOS";
   MiFormulario->PanelGrilla->Visible=true;
   MiFormulario->PanelABM->Visible=false ;
};


///////////////////////////////////////////////////
//     CERRANDO LA GRILLA
///////////////////////////////////////////////////
void __fastcall TMiFormulario::CerrarGrillaMouseMove(TObject *Sender,
      TShiftState Shift, int X, int Y)
{
  ActivoPanelABM();
}

ELIMINACION DE UNA FICHA

Para borrar un registro puedes recurrir a la función Delete()

///////////////////////////////////////////////////
//  ACTIVANDO BOTON DE BAJAS
///////////////////////////////////////////////////
void __fastcall TMiFormulario::BotonBajaClick(TObject *Sender)
{
  MiFormulario->Caption="BAJA DE REGISTRO";
  ActivoPanelAltas();
  HabilitoBoxDatos();
  CargoComboNombre();
}

///////////////////////////////////////////////////
//  ELIMINACION DE UN REGISTRO
///////////////////////////////////////////////////
void __fastcall TMiFormulario::BorrarDatosClick(TObject *Sender)
{
 MuestroBoxDatos();
 BorrarDatos->Visible=false;
 if (Application->MessageBox("¿Deseas borrar estos datos..??","ELIMINACION DE UN REGISTRO",MB_YESNO + MB_DEFBUTTON2 + MB_ICONQUESTION ) == IDYES)
    {
       MiTabla->Delete();
       MiTabla->Refresh();
       ComboNombre->Text="";
       LimpioLosBoxes();
    };
};

MODIFICAR REGISTROS

Para editar y modificar el contenido de una ficha de la tabla puedes usar la función Edit()

///////////////////////////////////////////////////
// ACTIVANDO BOTON DE MODIFICACIONES
///////////////////////////////////////////////////
void __fastcall TMiFormulario::BotonCambiosClick(TObject *Sender)
{
  MiFormulario->Caption="MODIFICAR REGISTRO";
  ActivoPanelAltas();
  HabilitoBoxDatos();
  CargoComboNombre();
}

///////////////////////////////////////////////////
//  CAMBIO DE CONTENIDO DE UN BOX
///////////////////////////////////////////////////
void __fastcall TMiFormulario::BoxNombreChange(TObject *Sender)
{
  if ((MiFormulario->Caption == "ALTA DE REGISTROS")||(MiFormulario->Caption =="MODIFICAR REGISTRO"))
     if (BoxNombre->Text == "")
        {
          GrabarDatos->Visible=false;
        }
       else
        {
          GrabarDatos->Visible=true;
        }
};

BUSCANDO FICHAS

La manera más eficiente de buscar una ficha, ya sea para consultas o para modificaciones o para bajas es usar un Combo Box, cuyos algoritmos podras ver en los siguientes renglones.

///////////////////////////////////////////////////
//   OPCIONES DE OPTION GRUP PARA BUSCAR
///////////////////////////////////////////////////
void __fastcall TMiFormulario::OpcionBuscarClick(TObject *Sender)
{
  OpcionBuscar->Visible=false;
  if (OpcionBuscar->Items->Strings[OpcionBuscar->ItemIndex] == "Por Combo" )
      {
        CargoComboNombre();
      }
     else
      {
        PanelAltas->Caption="Digita nombre buscado";
        ComboNombre->Visible=true;
        ComboNombre->SetFocus();
        DatoBuscado=ComboNombre->Text;
      };
};


///////////////////////////////////////////////////
// ACTIVANDO BOTON DE BUSQUEDA
///////////////////////////////////////////////////
void __fastcall TMiFormulario::BotonBuscarClick(TObject *Sender)
{
  MiFormulario->Caption="BUSCAR REGISTRO";
  PanelAltas->Caption="Clikea Opción de Buscar";
  ActivoPanelAltas();
  OpcionBuscar->Visible= true;
}

///////////////////////////////////////////////////
//  CAMBIO DEL CONTENIDO DEL DISPLAY DEL COMBO
///////////////////////////////////////////////////
void __fastcall TMiFormulario::ComboNombreChange(TObject *Sender)
{
 if (MiFormulario->Caption =="BUSCAR REGISTRO")
     {
       VerDato->Visible=true;
     }
    else
     {
       AceptarDatos->Visible=true;
     };
}

///////////////////////////////////////////////////
//  FUNCION DE BUSQUEDA POR COMBO
///////////////////////////////////////////////////
void BuscoMono(void)
{
  LimpioLosBoxes();
  MuestroBoxDatos();
  MiFormulario->AceptarDatos->Visible=false;
  MiFormulario->VerDato->Visible=false;
  TLocateOptions Resultado;
  Resultado = Resultado<MiTabla->Locate("nombre",MiFormulario->ComboNombre->Text,Resultado))
     {
        MiFormulario->BoxNombre->Text = MiFormulario->MiTabla->FieldByName("Nombre")->AsString;
        MiFormulario->BoxEmail->Text  = MiFormulario->MiTabla->FieldByName("Email")->AsString;
     }
    else
     {
        ShowMessage("Ese mono NO EXISTE!!!");
     };
  MiFormulario->ComboNombre->Text="";
};

///////////////////////////////////////////////////
//  CARGA DEL COMBO CON UN CAMPO
///////////////////////////////////////////////////
void CargoComboNombre(void)
{
bool B;
  B=false;
  MiFormulario->PanelAltas->Caption="Selecciona Dato del combo";
  MiFormulario->ComboNombre->Visible=true;
  MiFormulario->ComboNombre->Clear();
  MiFormulario->ComboNombre->SetFocus();
  MiFormulario->MiTabla->First();
  while (B==False)
  {
  if (MiFormulario->MiTabla->Eof)
  {
    B=true;
  }
  else
  {
      MiFormulario->ComboNombre->Items->Add(MiFormulario->MiTabla->FieldValues["nombre"]);
      MiFormulario->MiTabla->Next();
   }
   }
};

///////////////////////////////////////////////////
// ACEPTAR DATO DEL DISPLAY DEL COMBO
///////////////////////////////////////////////////
void __fastcall TMiFormulario::AceptarDatosClick(TObject *Sender)
{
 AceptarDatos->Visible=false;
  BuscoMono();
  if (MiFormulario->Caption =="BAJA DE REGISTRO")
     {
        BorrarDatos->Visible=true;
     };
}

///////////////////////////////////////////////////
//  MOSTRAR DATO DEL DISPLAY DEL COMBO
///////////////////////////////////////////////////
void __fastcall TMiFormulario::VerDatoClick(TObject *Sender)
{
  BuscoMono();
  DesabilitoBoxDatos();
}

NAVEGANDO por la TABLA

Corresponden a los algoritmos de los típicos cuatro botones de navegación

///////////////////////////////////////////////////
//  NAVEGADORES DE LA GRILLA
///////////////////////////////////////////////////
void __fastcall TMiFormulario::PrimeroClick(TObject *Sender)
{
  MiTabla->First();
}
//---------------------------------------------------------------------------
void __fastcall TMiFormulario::AnteriorClick(TObject *Sender)
{
  MiTabla->Prior();
}
//---------------------------------------------------------------------------

void __fastcall TMiFormulario::SiguienteClick(TObject *Sender)
{
  MiTabla->Next();
}
//---------------------------------------------------------------------------

void __fastcall TMiFormulario::UltimoClick(TObject *Sender)
{
  MiTabla->Last();
}

FUNCIONES COMUNES

En todos tus programas te haran falta alguno de estos algoritmos.

///////////////////////////////////////////////////
//  FUNCIONES COMUNES DE CONTROL DEL PROGRAMA
///////////////////////////////////////////////////
void ActivoPanelABM(void)
{
  MiFormulario->Caption="PROGRAMA MODELO C++Builder:      Wilo Carpio    "+Date();
  MiFormulario->PanelABM->Visible=true ;
  MiFormulario->PanelGrilla->Visible=false ;
  MiFormulario->PanelTeoria->Visible=false ;
  MiFormulario->PanelAltas->Visible=false;
  HabilitoBoxDatos();
  MiFormulario->ComboNombre->Text="";
};
void ActivoPanelAltas(void)
{
  MiFormulario->PanelABM->Visible=false ;
  MiFormulario->PanelGrilla->Visible=false ;
  MiFormulario->PanelTeoria->Visible=false ;
  MiFormulario->PanelAltas->Visible=true;
  MiFormulario->OpcionBuscar->Visible= false;
  MiFormulario->OpcionBuscar->ItemIndex=-1;
  MiFormulario->ComboNombre->Visible= false;
  MiFormulario->VerDato->Visible= false;
  MiFormulario->ComboNombre->Text="";
  DesabilitoBoxDatos();
  LimpioLosBoxes();
  OcultarIconosABM();
  OcultoBoxDatos();
};
void DesabilitoBoxDatos(void)
{
  MiFormulario->BoxNombre->Enabled=false;
  MiFormulario->BoxEmail->Enabled=false;
};

void HabilitoBoxDatos(void)
{
  MiFormulario->BoxNombre->Enabled= true;
  MiFormulario->BoxEmail->Enabled= true;
};

void OcultoBoxDatos(void)
{
  MiFormulario->BoxNombre->Visible=false;
  MiFormulario->BoxEmail->Visible=false;
};

void MuestroBoxDatos(void)
{
  MiFormulario->BoxNombre->Visible=true;
  MiFormulario->BoxEmail->Visible= true;
};

void OcultarIconosABM(void)
{
  MiFormulario->GrabarDatos->Visible=false;
  MiFormulario->BorrarDatos->Visible=false;
  MiFormulario->AceptarDatos->Visible=false;
  MiFormulario->ComboNombre->Visible=false;
};

void LeoDatosDeBoxes(void)
{
     MiFormulario->MiTabla->FieldByName("Nombre")->AsString = MiFormulario->BoxNombre->Text;
     MiFormulario->MiTabla->FieldByName("Email")->AsString  = MiFormulario->BoxEmail->Text;
};

void LimpioLosBoxes(void)
{
     MiFormulario->BoxNombre->Text="";
     MiFormulario->BoxEmail->Text="";
};

///////////////////////////////////////////////////
//    FUNCION DE SALIDA DEL PROGRAMA
///////////////////////////////////////////////////
void __fastcall TMiFormulario::ChauMouseUp(TObject *Sender,
      TShiftState Shift, int X, int Y)
{
    if (Application->MessageBox("Deseas cerrar el programa?","ESTAS POR CERRAR ESTE SISTEMA",MB_YESNO + MB_DEFBUTTON2 + MB_ICONQUESTION ) == IDYES)
       {
         MiFormulario->Close();
      };
};

MODOS de IMPRIMIR

En los siguientes párrafos te propongo las alternativas más usuales para imprimir distintos tipos de archivos.

///////////////////////////////////////////////////
//   ACTIVANDO BOTON DEL PANEL CON TEORIA
///////////////////////////////////////////////////
void __fastcall TMiFormulario::BotonTeoriaClick(TObject *Sender)
{
     PanelTeoria->Visible=true;
     PanelABM->Visible=false;
     Autor->Visible=true;
}

///////////////////////////////////////////////////
//  CERRANDO PANEL DE TEORIA
///////////////////////////////////////////////////
void __fastcall TMiFormulario::CerrarAutorClick(TObject *Sender)
{
  PanelABM->Visible=true;
  PanelTeoria->Visible=false;
}

///////////////////////////////////////////////////
//  ACTIVANDO IMPRESION DE TEORIA
///////////////////////////////////////////////////
void __fastcall TMiFormulario::ImprimoTeoriaClick(TObject *Sender)
{
MiFormulario->Caption="ESTAS POR IMPRIMIR LA TEORIA";
 if (Application->MessageBox("¿Deseas imprimir estos datos.??","IMPRESION DE DATOS DE LA TEORIA",MB_YESNO + MB_DEFBUTTON2 + MB_ICONQUESTION ) == IDYES)
    {
       if (Application->MessageBox("¿Está activada tu impresora.??","IMPRESION DE DATOS DE LA TEORIA", MB_YESNO + MB_DEFBUTTON2 + MB_ICONQUESTION ) == IDYES)
          {
            PrintDialog->Execute();
            BoxConTeoria->Print("MyApp.exe - readme.txt");
          };
    };
 MiFormulario->Caption="ESTAS POR IMPRIMIR DATOS DE LA GRILLA";
 if (Application->MessageBox("¿Deseas imprimir estos datos.??","IMPRESION DE DATOS DE LA GRILLA",MB_YESNO + MB_DEFBUTTON2 + MB_ICONQUESTION ) == IDYES)
    {
       if (Application->MessageBox("¿Está activada tu impresora.??","IMPRESION DE DATOS DE LA GRILLA",MB_YESNO + MB_DEFBUTTON2 + MB_ICONQUESTION ) == IDYES)
          {
            PrintDialog->Execute();
            TPrinter *Prntr = Printer();
            Graphics::TBitmap *bmp = new Graphics::TBitmap();
            bmp->LoadFromFile("c:\Archivos de programa\Borland\CBuilder5\Projets\BDB2001Wilo\BebeWilo.bmp");
            Prntr->BeginDoc();
            Prntr->Canvas->Draw((Prntr->PageWidth - bmp->Width),(Prntr->PageHeight - bmp->Height),bmp);
          Prntr->EndDoc();
          delete bmp;
          };
    };
}

///////////////////////////////////////////////////
//  IMPRESION DE LA TABLA CON Quick REPORT
///////////////////////////////////////////////////
void __fastcall TMiFormulario::ImprimoGrillaClick(TObject *Sender)
{
 MiFormulario->Caption="ESTAS POR IMPRIMIR EL CONTENIDO DE LA TABLA";
 if (Application->MessageBox("¿Deseas imprimir estos datos.??","IMPRESION DE DATOS DE LA TABLA", MB_YESNO + MB_DEFBUTTON2 + MB_ICONQUESTION ) == IDYES)
    {
       if (Application->MessageBox("¿Está activada tu impresora.??","IMPRESION DE DATOS DE LA TABLA", MB_YESNO + MB_DEFBUTTON2 + MB_ICONQUESTION ) == IDYES)
          {
              MiReporte->QuickRep1->Preview();
          };
    };
}

	Vector	Matriz	Puntero	Lista	Cola	Arbol	Archivo	Editor	Agenda	Base Datos	Modelo

PILAS y COLAS en C++BUILDER
Colega virtual, aunque te parezca extraño existe toda una "Teoría de las Colas" la cual las clasifica en:

• Colas Finitas
• Colas Infinitas
• Colas Simples
• Colas Múltiples

A las colas se las conoce también como "Filas de Espera", por lo tanto ya estás imaginando el rumbo de toda esta teoría cuyo análisis matemático por suerte, corresponde a la disciplina de la "Investigación Operativa", que por cierto es muy apasionante..!!

En este link, el enfoque tanto de las colas y de las pilas es puramente algorítmico y como estructuras lineales de datos tratadas como con enlaces estáticos o mediante enlaces dinámicos.

Colega algorítmico, te ofrezco un sistema integral con las operaciones básicas y clásicas que pueden efectuarse con estas estructuras dinámicas... Ah pero ..

CONCEPTOS BASICOS: La manera clásica para idealizar una pila es pensar en la estructura que adopta la pila de platos, donde para aumentar otro plato en ella, es necesario colocarla en la parte superior y para retirar un plato, debemos levantar el que está en la cima o en la parte superior; por ello, las pilas son estructuras de datos tipo LIFO ( último en entrar, primero en salir): el último elemento que se coloca (mete o inserta) en la pila es el primero que se quita (saca o remueve) de ella.

La pila es una versión restringida de una lista enlazada, ya que los nuevos nodos solo pueden agregarse a una pila y eliminarse de una pila desde la parte superior de ésta. El miembro de enlace del último nodo de la pila está establecido a nulo (cero) para indicar el fondo de la pila.

En el mundo de los programas informáticos las pilas tienen aplicaciones como por ejemplo, cuando se realiza una llamada de función, la función llamada debe saber la manera de regresar a su invocador, y por esto la dirección de devolución se pone en una pila. También los compiladores utilizan a las pilas en el proceso de evaluación de expresiones y en la generación de código de lenguaje de maquina.

Cuando sucede una serie de llamadas de función, los valores de devolución sucesivos se ponen en la pila en un orden último en entrar, primero en salir, para que cada función pueda regresar a su invocador. Las pilas soportan las llamadas de función recursivas en la misma forma que lo hacen con las llamadas no recursivas convencionales.

Las pilas contienen el espacio que se crea para las variables automáticas en cada llamada a una función. Cuando la función regresa a su invocador, el espacio para las variables automáticas de la función se saca de la pila, y de ésta manera el programa ya no conoce dichas variables.

Como una pila es una lista, podemos plantear dos técnicas de proceso.

• Pila con apuntadores
• Pila con arreglo

METER Y SACAR...!!

Realiza altas (Meter) insertando al frente de la lista y la baja (Sacar) eliminando el elemento que está al frente de la lista. Una operación cima solo examina el elemento del frente de la lista, devolviendo su valor. A veces la operación sacar y cima se combinan en una. Podríamos usar llamadas a las rutinas sobre listas enlazadas.

Primero implantamos la pila con cabecera. Después se examina una pila vacía en la misma manera que una lista vacía.

La creación de una pila vacía requiere crear una cabecera con un apuntador siguiente a NULL. El meter se implanta como inserción al frente de la lista enlazada, donde el frente de la lista se conoce como cima de la pila. La cima se efectúa examinando el elemento de la primera posición de la lista. Por ultimo, implantaremos sacar eliminando el frente de la lista.

Todas las operaciones tardan un tiempo constante, por que en ninguna de las rutinas tiene referencia al tamaño de la pila ( excepto en la comprobación de si esta vacía ); tampoco se encuentra un ciclo que dependa del tamaño.

ARREGLOS

Es la alternativa que evita los apuntadores y probablemente es la solución mas utilizada y solo se necesita declarar el tamaño de un arreglo con anticipación. Para ello en aplicaciones típicas, aun si se tienen muy pocas operaciones con pilas, el numero de elementos en la pila no crece demasiado y siempre es fácil declarar el arreglo suficientemente grande sin desperdiciar demasiado espacio.

En el proceso con arreglos con arreglos, cada pila tiene la cima de la pila, la cual es 0 para una pila vacía. Para meter algún elemento x en la pila, se debe incrementar la cima de la pila y después se hace PILA ( cima de la pila ) = x; donde PILA es el arreglo que representa la pila real.

Para sacar, se devuelve el valor de PILA ( cima de la pila ) y después se decrementa la cima de la pila. Por supuesto, ya que puede haber varias pilas, el arreglo PILA y la cima de la pila son parte de un registro que representa una pila.

Las operaciones se realizan no solo en tiempos constantes, sino en un tiempo muy corto y en algunas maquinas, meter y sacar se pueden escribir en una sola instrucción de maquina y operar en un arreglo de direccionamiento con auto incremento y auto decremento.

Dado que la mayoría de las maquinas modernas tienen operaciones sobre pilas como parte del conjunto de instrucciones refuerza la idea de que la pila es probablemente la estructura de datos más importante en informática, después del arreglo.

Suele ocurrir que un problema del procesamiento de pilas como arreglos es la comprobación de errores; un sacar de una pila vacía o un meter en una pila llena excederá los limites del arreglo y causara una ruptura.

Si se incluyen tales comprobaciones en la implantación de arreglos podrían tomar tanto tiempo como la manipulación de la pila. Por esta razón, puede convenir omitir la comprobación de errores en las rutinas de pilas, excepto cuando el manejo de errores sea crucial, tal ocurre en los sistemas operativos.

Se puede resolver este problema declarando un tamaño de la pila suficiente para no excederlo y asegurándose de que las rutinas que usan sacar y meter nunca intenten sacar de una pila vacía.

Las filas de espera también llamadas colas, se producen cada vez que hacemos cola en la caja del comercio, cuando cargamos combustible en el automóvil, cuando abordamos un autobús, cuando pagamos en la caseta de cobro de la autopista; los estudiantes hacen cola para inscribirse en las materias que quieren y en los sistemas informáticos usamos internamente muchas colas de espera.

En estas estructuras de datos abstractos, los usuarios hacen altas o ponen cosas en ellas, una a la vez mediante una operación de encolamiento, y las retiran o dan de baja, un elemento a la vez por medio de una operación de desencolamiento.

Aunque en teoría la cola puede ser infinitamente grande, en la práctica, ella es finita y sus elementos se devuelven de la cola en orden de FIFO (Firts In Firts Out: primero en entrar, primero en salir): el primer elemento que entra en la cola es el primero en ser retirado de ella.

Del mismo modo que las pilas, también las colas son listas. Con una cola, no obstante, la inserción se hace por un extremo, mientras que la eliminación se realiza por el otro extremo.

Las operaciones básicas sobre una cola son encolar, que inserta un elemento al final de la lista, y dar de baja o desencolar, para eliminar el elemento del inicio de la lista o frente.

COLAS COMO ARREGLOS: Para las colas pueden aplicarse los procesos de los arreglos, usando la estructura de datos COLA[ ], y la posición Frente y Final, que representan los extremos de la cola, y Tamaño que es el numero de elementos de la cola.

• Para encolar un elemento x, incrementamos Tamaño y Final, y luego hacemos COLA[Final] = x.
• Para desencolar un elemento se pone en el valor a devolver COLA[Frente], se decrementa Tamaño y se incrementa Frente.

Si no tienes experiencia en el manejo de estructuras dinámicas te recomiendo iniciar con otro link más simple, o en su defecto copia textualmente los siguientes que te propongo.

//////////////////////////////////////////////////////
// ESTRUCTURA DINAMICA DE DATOS    Wilo Carpio
//    MANEJO DE PILA Y COLA
//        C++ Builder
//////////////////////////////////////////////////////

#include         //Para reconocer los tipos de datos ingresados
#pragma hdrstop
#include 
#include "PilaYCola.h"  //Archivo de cabecera pila y cola.h
#pragma package(smart_init)
#pragma resource "*.dfm"

TMiFormulario *MiFormulario;
struct Registro
{
char NombrePila[30];    // Para la pila
char EmailPila[40];     // Para la pila
char NombreCola[30];   // Para la cola
char EmailCola[30];    // Para la cola
int EstaEnPila,EstaEnCola;           // Flag de borrado
struct Registro *SiguientePila,*SiguienteCola;
}*NodoPila,*NodoCola,*NodoAuxPila,*NodoAuxCola,*AuxCola,*CabeceraPila, *CabeceraCola ,*Ultimo,*Primero;


struct Persona
{
char NombrePila[30];
char EmailPila[40];
char NombreCola[30];
char EmailCola[40];
};

Persona MonoPila,MonoCola;
int bandera, i, j;
char NombrePila[30],EmailPila[30];
char NombreCola[30],EmailCola[30];
AnsiString NombreEnPila, NombreEnCola;

////////////////////////////////////////////////////////////////
//*procedimiento de busqueda para validar los datos en la pila//
////////////////////////////////////////////////////////////////
int BuscarEnLaPila(AnsiString NombreEnPila)
{
 int EstaEnLaPila=0;
 NodoPila=CabeceraPila;
 if (NodoPila!=NULL)
 while (NodoPila != NULL)
 {
  if ((NombreEnPila)==NodoPila->NombrePila)
  {
   EstaEnLaPila=1;
   break;
  }
  NodoPila=NodoPila->SiguientePila;
 }
 return(EstaEnLaPila);
}

///////////////////////////////////////////////////////////////
//  Busqueda para validar los datos en la cola
///////////////////////////////////////////////////////////////
int BuscarEnLaCola(AnsiString NombreEnCola)
{
 int EstaEnLaCola=0;
 NodoCola=CabeceraCola;
 if (NodoCola!=NULL)
    while (NodoCola != NULL)
     {
       if ((NombreEnCola)==NodoCola->NombreCola)
          {
            EstaEnLaCola=1;
            break;
           }
       NodoCola=NodoCola->SiguienteCola;
      }
 return(EstaEnLaCola);
}
  /////////////////////////////////////////////////////////////////////
  // Liberar memoria e insertar los datos en la pila
  /////////////////////////////////////////////////////////////////////
void InsertarEnPila(char NombrePila[30], char EmailPila[40])  //
{
 NodoPila=new Registro [sizeof (Registro)];     // new asigna memoria al puntero
 strcpy(NodoPila->NombrePila,NombrePila);       // strcpy copia dos cadenas
 strcpy(NodoPila->EmailPila,EmailPila);
 NodoPila->EstaEnPila=0;                        //valor que sirve para la eliminacion
 NodoPila->SiguientePila=NULL;
 if (CabeceraPila == NULL)
    CabeceraPila = NodoPila;
   else
    {
     NodoPila->SiguientePila = CabeceraPila;
     CabeceraPila = NodoPila;
    }
 if (bandera==0)
 ShowMessage("Informacion registrada..!!");
}
 ///////////////////////////////////////////////////////////////////////
 // Liberar memoria e insertar los datos en la cola
 /////////////////////////////////////////////////////////////////////
void InsertarEnCola(char NombreCola[30], char EmailCola[30])  //*void palabra reservada que no va a apuntar a ningun tipo
{
 NodoCola=new Registro [sizeof (Registro)];
 strcpy(NodoCola->NombreCola,NombreCola);
 strcpy(NodoCola->EmailCola,EmailCola);
 NodoCola->EstaEnCola=0;                  //Sirve para la eliminacion
 NodoCola->SiguienteCola=NULL;
 if (CabeceraCola == NULL)
 {
  CabeceraCola = NodoCola;
  CabeceraCola->SiguienteCola=NULL;
  Primero= CabeceraCola;
 }
 else
 {
  Primero->SiguienteCola = NodoCola;
  NodoCola->SiguienteCola = NULL;
  Primero = NodoCola;
 }
 if (bandera==0)
 ShowMessage("Informacion Registrada");
}
//---------------------------------------------------------------------------
__fastcall TMiFormulario::TMiFormulario(TComponent* Owner)
        : TForm(Owner)
{
}

void __fastcall TMiFormulario::BRPAClick(TObject *Sender)
{
 MiFormulario->PanelAutor->Visible=false;
}
//---------------------------------------------------------------------------

void __fastcall TMiFormulario::FormCreate(TObject *Sender)
{
 MiFormulario->PanelAutor->Visible=false;
}
//---------------------------------------------------------------------------

void __fastcall TMiFormulario::Autor1Click(TObject *Sender)
{
MiFormulario->PanelAutor->Visible=true;
}

void __fastcall TMiFormulario::Altas1Click(TObject *Sender)
{
 MiFormulario->Caption=("Digita los datos de la agenda");
 bandera=0;
 PanelPila->Visible=true;
 BoxNombreP->Clear();
 BoxEmailP->Clear();
 BoxNombreP->SetFocus();
 BoxNombreP->SetFocus();
}
//---------------------------------------------------------------------------
//Grabar los datos en la agenda ingresados en la pila
void __fastcall TMiFormulario::BotonGrabarPClick(TObject *Sender)
{
 int Mensaje;
 char NombrePila[30], EmailPila[40];
 if((BoxNombreP->Text!="")||(BoxEmailP->Text!=""))
  {
   strcpy(NombrePila,BoxNombreP->Text.c_str());
   strcpy(EmailPila,BoxEmailP->Text.c_str());
   if(BuscarEnLaPila(NombrePila)==0)
     {
      InsertarEnPila(NombrePila,EmailPila);
      BoxNombreP->Clear();
      BoxEmailP->Clear();
      BoxNombreP->SetFocus();
     }
    else
     {
      Mensaje=Application->MessageBox("Desea ingresarlo nuevamente","Dato existente",MB_OKCANCEL);
      if(Mensaje==IDOK)
         {
          strcpy(NodoPila->NombrePila,BoxNombreP->Text.c_str());
          strcpy(NodoPila->EmailPila,BoxEmailP->Text.c_str());
          BoxNombreP->Clear();
          BoxEmailP->Clear();
          BoxNombreP->SetFocus();
         }
        else
         {
          BoxNombreP->Clear();
          BoxEmailP->Clear();
          BoxNombreP->SetFocus();
         }
     }
  }
}
//---------------------------------------------------------------------------
void __fastcall TMiFormulario::BotonLimpiarPClick(TObject *Sender)
//procedimiento para limpiar los box en caso de arrepentirme de haber ingresado algun dato//
{
 BoxNombreP->Clear();
 BoxEmailP->Clear();
 BoxNombreP->SetFocus();
}

void __fastcall TMiFormulario::BotonGrabarCClick(TObject *Sender)
{
 int Mensaje;
 char NombreCola[30], EmailCola[40];
 if((BoxNombreC->Text!="")||(BoxEmailC->Text!=""))
 {
  strcpy(NombreCola,BoxNombreC->Text.c_str());
  strcpy(EmailCola,BoxEmailC->Text.c_str());
  if(BuscarEnLaCola(NombreCola)==0)
  {
   InsertarEnCola(NombreCola,EmailCola);
   BoxNombreC->Clear();
   BoxEmailC->Clear();
   BoxNombreC->SetFocus();
  }
  else
  {
   Mensaje=Application->MessageBox("Desea ingresarlo nuevamente","Dato existente",MB_OKCANCEL);
   if(Mensaje==IDOK)
   {
    strcpy(NodoCola->NombreCola,BoxNombreC->Text.c_str());
    strcpy(NodoCola->EmailCola,BoxEmailC->Text.c_str());
    BoxNombreC->Clear();
    BoxEmailC->Clear();
    BoxNombreC->SetFocus();
   }
   else
   {
    BoxNombreC->Clear();
    BoxEmailC->Clear();
    BoxNombreC->SetFocus();
   }
  }
 }
}
//---------------------------------------------------------------------------

void __fastcall TMiFormulario::Altas2Click(TObject *Sender)
{  MiFormulario->Caption=("Ingresa los datos en la agenda");
 bandera=0;
 PanelCola->Visible=true;
 BoxNombreC->Clear();
 BoxEmailC->Clear();
 BoxNombreC->SetFocus();
}
//---------------------------------------------------------------------------

void __fastcall TMiFormulario::BotonLimpiarCClick(TObject *Sender)
{
   BoxNombreC->Clear();
   BoxEmailC->Clear();
   BoxNombreC->SetFocus();
}
//---------------------------------------------------------------------------

void __fastcall TMiFormulario::BotonVolverCClick(TObject *Sender)
  { MiFormulario->Caption=("Agenda con Pilas y Colas");
  PanelCola->Visible = false;
}

void __fastcall TMiFormulario::BotonVolverPClick(TObject *Sender)
//procedimiento para retornar al formulario principal//
{
 MiFormulario->Caption=("Agenda con Pilas y Colas");
 PanelPila->Visible = false;
}
//---------------------------------------------------------------------------
void __fastcall TMiFormulario::Visualizacion1Click(TObject *Sender)
//procedimiento para visualizar los datos en la grilla introducidos en el procedimiento de la pila//
{
 MiFormulario->Caption=("Los datos en la agenda son:");
 i=1;
 if(CabeceraPila==NULL)
 {
  Application->MessageBox("No hay datos en la lista","Atencion...",MB_OK);
 }
 PanelVisualizarP->Visible = true;
 if (CabeceraPila!=NULL)
 {
  GrillaPila->Cells [0][0]="Nombre";
  GrillaPila->Cells[1][0]="EmailPila";
  NodoAuxPila = CabeceraPila;
  while (NodoAuxPila->SiguientePila!= NULL)
  {
    GrillaPila->Cells[0][i]=NodoAuxPila->NombrePila;
    GrillaPila->Cells[1][i]=NodoAuxPila->EmailPila;
    i=i+1;
    while ( GrillaPila->Cells[0][i+1]!="")
     {
       GrillaPila->Cells[0][i+1]="";
       GrillaPila->Cells[1][i+1]="";
     }
   NodoAuxPila=NodoAuxPila->SiguientePila;
  }
  GrillaPila->Cells[0][i]=NodoAuxPila->NombrePila;
  GrillaPila->Cells[1][i]=NodoAuxPila->EmailPila;
 }
 else
 {
  PanelVisualizarP->Visible = false;
 }
}
//---------------------------------------------------------------------------
void __fastcall TMiFormulario::BotonRegresarPClick(TObject *Sender)
//procedimiento para retornar al formulario principal*//
{
 MiFormulario->Caption=("Agenda con Pilas y Colas");
 PanelVisualizarP->Visible = false;
}
//---------------------------------------------------------------------------
void __fastcall TMiFormulario::Consultas1Click(TObject *Sender)
//*procedimiento para consultar un dato en el combo//
{
 MiFormulario->Caption=("Elija el nombre a consultar");
 PanelBuscarPila->Visible = true;
 bandera=4;   //*si es una consulta
 Registro *Actual;
 Actual = CabeceraPila;
 ComboPila->Clear();
 while (Actual!=NULL)
 {
  ComboPila->Items->Add(Actual->NombrePila);
  Actual=Actual->SiguientePila;
 }
}
//---------------------------------------------------------------------------
void __fastcall TMiFormulario::BotonAceptarPilaClick(TObject *Sender)

{
 MiFormulario->Caption=("El nombre elegido es:");
 int encontrado;
 char bus[40];
 AnsiString var;
 encontrado=0;
 NodoAuxPila=CabeceraPila;
 var=ComboPila->Items->Strings[ComboPila->ItemIndex];
 strcpy(bus,var.c_str());
 while (NodoAuxPila !=NULL )
 {        //funcion de busqueda
  if (stricmp(NodoAuxPila->NombrePila,bus)==0)
  {
   encontrado=1;
   if (bandera==1)         //si es una modificacion
   {
    if (NodoAuxPila->EstaEnPila!=1)
    {
     BotonGrabarP->Visible=true;
     BotonLimpiarP->Visible=true;
     PanelPila->Visible=true;
     PanelBuscarPila->Visible=false;
     BoxNombreP->Text=NodoAuxPila->NombrePila;
     BoxEmailP->Text=NodoAuxPila->EmailPila;
     NodoAuxCola=NodoAuxPila;
     NodoAuxPila=NULL;
    }
   }
   else
   {
    if(bandera==4)
    {
     if (NodoAuxPila->EstaEnPila!=1)
     {
      BotonGrabarP->Visible=false;
      BotonLimpiarP->Visible=false;
      PanelPila->Visible=true;
      PanelBuscarPila->Visible=false;
      BoxNombreP->Text=NodoAuxPila->NombrePila;
      BoxEmailP->Text=NodoAuxPila->EmailPila;
      NodoAuxCola=NodoAuxPila;
      NodoAuxPila=NULL;
     }
    }
   }
  }
  else
  NodoAuxPila=NodoAuxPila->SiguientePila;
 }       //fin del while
 if (encontrado==0)
 {
  ShowMessage("La ficha que busca no ha sido ingresada");
  PanelBuscarPila->Visible=false;
 }
}

ORDENANDO:

// ORDENAR
void __fastcall TMiFormulario::Modificaciones1Click(TObject *Sender)
{
 MiFormulario->Caption=("Seleccione el nombre a modificar");
 bandera=1;
 PanelBuscarPila->Visible=true;
 Registro *Actual;
 Actual = CabeceraPila;
 ComboPila->Clear();
 while (Actual!=NULL)
 {
  ComboPila->Items->Add(Actual->NombrePila);
  Actual=Actual->SiguientePila;
 }
}

void __fastcall TMiFormulario::Modificaciones2Click(TObject *Sender)
{ MiFormulario->Caption=("Seleccione el nombre a modificar");
 bandera=1;
 PanelBuscarCola->Visible=true;
 Registro *actual;
 actual = CabeceraCola;
 ComboCola->Clear();
 while (actual!=NULL)
 {
  ComboCola->Items->Add(actual->NombreCola);
  actual=actual->SiguienteCola;
 }
}

BAJAS:

// BAJA
void __fastcall TMiFormulario::Bajas1Click(TObject *Sender)
{
 PanelBajaP->Visible=true;
}
//---------------------------------------------------------------------------
void __fastcall TMiFormulario::BotonEliminarPilaClick(TObject *Sender)
{
 NodoAuxPila=CabeceraPila;
 if (CabeceraPila==NULL)
 {
  Application->MessageBox("No hay datos en la cola","ATENCION",+MB_OK);
 }
 else
 {
  int opcion;
  opcion = Application->MessageBox("EstaEnLaPila seguro de eliminar el dato","ATENCION",+MB_OKCANCEL+MB_ICONQUESTION);
  if (opcion==IDOK)
  {
   CabeceraPila = NodoAuxPila->SiguientePila;
   delete(NodoAuxPila);
   Application->MessageBox("El dato fue eliminado con exito!!!","ATENCION",+MB_OK);
  }
 }
}
//---------------------------------------------------------------------------
void __fastcall TMiFormulario::BotonRetornarPClick(TObject *Sender)
{
 MiFormulario->Caption=("Agenda con Pilas y Colas");
 PanelBajaP->Visible = false;
}

void __fastcall TMiFormulario::Bajas2Click(TObject *Sender)
{
PanelBajasC->Visible = true;
}
//---------------------------------------------------------------------------

void __fastcall TMiFormulario::BotonEliminarColaClick(TObject *Sender)
{
 if (CabeceraCola==NULL)
 {
  Application->MessageBox("No hay datos en la cola","ATENCION",+MB_OK);
 }
 else
 {
  int opcion;
  opcion = Application->MessageBox("EstaEnLaPila seguro de eliminar el dato","ATENCION",+MB_OKCANCEL+MB_ICONQUESTION);
  if (opcion==IDOK)
  {
   NodoCola = CabeceraCola;
   CabeceraCola = NodoCola->SiguienteCola;
   delete(NodoCola);
   {
    Application->MessageBox("El dato fue eliminado con exito!!!","ATENCION",+MB_OK);
   }
  }
 }
}
//---------------------------------------------------------------------------

void __fastcall TMiFormulario::BotonRetornarCClick(TObject *Sender)
{ MiFormulario->Caption=("Agenda con Pilas y Colas");
 PanelBajasC->Visible = false;
}

CONSULTAS:

//CONSULTA
void __fastcall TMiFormulario::Visualizacion2Click(TObject *Sender)
{MiFormulario->Caption=("Los datos en la agenda son:");
 i=1;
 if(CabeceraCola==NULL)
 {
  Application->MessageBox("No hay datos en la lista","Atencion...",MB_OK);
 }
 PanelVisualizarC->Visible = true;
 if (CabeceraCola!=NULL)
 {
  GrillaC->Cells [0][0]="NOMBRE";
  GrillaC->Cells[1][0]="EmailPila";
  NodoCola = CabeceraCola;
  while (NodoCola->SiguienteCola!= NULL)
  {
   GrillaC->Cells[0][i]=NodoCola->NombreCola;
   GrillaC->Cells[1][i]=NodoCola->EmailCola;
   i=i+1;
   while ( GrillaC->Cells[0][i+1]!="")
   {
    GrillaC->Cells[0][i+1]="";
    GrillaC->Cells[1][i+1]="";
   }
   NodoCola=NodoCola->SiguienteCola;
  }
  GrillaC->Cells[0][i]=NodoCola->NombreCola;
    GrillaC->Cells[1][i]=NodoCola->EmailCola;
 }
 else
 {
  PanelVisualizarC->Visible = false;
 }
}
//---------------------------------------------------------------------------

void __fastcall TMiFormulario::BotonRegresarCClick(TObject *Sender)
{
 MiFormulario->Caption=("Agenda con Pilas y Colas");
 PanelVisualizarC->Visible = false;
}
//---------------------------------------------------------------------------

void __fastcall TMiFormulario::Consultas2Click(TObject *Sender)
{ MiFormulario->Caption=("Elija el nombre a consultar");
 PanelBuscarCola->Visible = true;
 bandera=4;
 Registro *actual;
 actual = CabeceraCola;
 ComboCola->Clear();
 while (actual!=NULL)
 {
  ComboCola->Items->Add(actual->NombreCola);
  actual=actual->SiguienteCola;
 }
}
//---------------------------------------------------------------------------

void __fastcall TMiFormulario::BotonAceptarColaClick(TObject *Sender)
{ MiFormulario->Caption=("El nombre elegido es:");
 int encontrado;
 char bus[40];
 AnsiString var;
 encontrado=0;
 NodoCola=CabeceraCola;
 var=ComboCola->Items->Strings[ComboCola->ItemIndex];
 strcpy(bus,var.c_str());
 while (NodoCola !=NULL )
 {        //funcion de busqueda
  if (stricmp(NodoCola->NombreCola,bus)==0)
  {
   encontrado=1;
   if (bandera==1)         //si es una modificacion
   {
    if (NodoCola->EstaEnCola!=1)
    {
     BotonGrabarC->Visible=true;
     BotonLimpiarC->Visible=true;
     PanelCola->Visible=true;
     PanelBuscarCola->Visible=false;
     BoxNombreC->Text=NodoCola->NombreCola;
     BoxEmailC->Text=NodoCola->EmailCola;
     AuxCola=NodoCola;
     NodoCola=NULL;
    }
   }
   else
   {
    if(bandera==4)
    {
     if (NodoCola->EstaEnCola!=1)
     {
      BotonGrabarC->Visible=false;
      BotonLimpiarC->Visible=false;
      PanelCola->Visible=true;
      PanelBuscarCola->Visible=false;
      BoxNombreC->Text=NodoCola->NombreCola;
      BoxEmailC->Text=NodoCola->EmailCola;
      AuxCola=NodoCola;
      NodoCola=NULL;
     }
    }
   }
  }
  else
  NodoCola=NodoCola->SiguienteCola;
 }       //fin del while
 if (encontrado==0)
 {
  ShowMessage("La ficha que busca no ha sido ingresada");
  PanelBuscarCola->Visible=false;
 }
}

MODIFICACIONES:

// MODIFICACION de ARCHIVO
void __fastcall TMiFormulario::FormActivate(TObject *Sender)
{
  FILE *Archivo,*Archivo1;     //declaracion de un puntero a un archivo
 Archivo = fopen("Pila.dat", "rb");
 Archivo1 = fopen("Cola.dat", "rb");  //abre el archivo
 bandera=3; //para decir que es la carga desde el archivo
 while (!feof(Archivo))
 {
  fread(&MonoPila, sizeof(MonoPila),1,Archivo);
  if(!feof(Archivo))
  InsertarEnPila(MonoPila.NombrePila,MonoPila.EmailPila);
 }
 while (!feof(Archivo1))
 {
  fread(&MonoCola, sizeof(MonoCola),1,Archivo1);
  if(!feof(Archivo1))
  InsertarEnCola(MonoCola.NombreCola,MonoCola.EmailCola);
 }
 fclose(Archivo);
 fclose(Archivo1);
}
//---------------------------------------------------------------------------
void __fastcall TMiFormulario::Salir1Click(TObject *Sender)
{
 if (Application->MessageBox("Cierras la agenda?","ATENCION...!!",MB_OKCANCEL+MB_ICONQUESTION)== IDOK);
    {
     FILE *ArchPila,*ArchCola;
     Registro *NodoPilaActual,*NodoColaActual;
     ArchPila = fopen("Pila.dat","wb");
     ArchCola = fopen("Cola.dat","wb");
     NodoPilaActual=NodoPila;
     NodoColaActual=NodoCola;
     while (NodoPilaActual != NULL)
        {
          if (NodoPilaActual->EstaEnPila != 1)
             {
               strcpy(MonoPila.NombrePila,NodoPilaActual->NombrePila);
               strcpy(MonoPila.EmailPila,NodoPilaActual->EmailPila);
               fwrite(&MonoPila , sizeof(MonoPila),1,ArchPila);
              }
          NodoPilaActual=NodoPilaActual->SiguientePila;
        }
     while (NodoColaActual != NULL)
        {
         if (NodoColaActual->EstaEnCola != 1)
            {
             strcpy(MonoCola.NombreCola,NodoColaActual->NombreCola);
             strcpy(MonoCola.EmailCola,NodoColaActual->EmailCola);
             fwrite(&MonoCola , sizeof(MonoCola),1,ArchCola);
            }
          NodoColaActual=NodoColaActual->SiguienteCola;
        }
     fclose(ArchPila);
     fclose(ArchCola);
     Close();
 }
}

void __fastcall TMiFormulario::BotonCerrarClick(TObject *Sender)
{
 if (Application->MessageBox("Cierras la agenda?","ATENCION...!!",MB_OKCANCEL+MB_ICONQUESTION)== IDOK);
    {
     FILE *ArchPila,*ArchCola;
     Registro *NodoPilaActual,*NodoColaActual;
     ArchPila = fopen("Pila.dat","wb");
     ArchCola = fopen("Cola.dat","wb");
     NodoPilaActual=NodoPila;
     NodoColaActual=NodoCola;
     while (NodoPilaActual != NULL)
        {
          if (NodoPilaActual->EstaEnPila != 1)
             {
               strcpy(MonoPila.NombrePila,NodoPilaActual->NombrePila);
               strcpy(MonoPila.EmailPila,NodoPilaActual->EmailPila);
               fwrite(&MonoPila , sizeof(MonoPila),1,ArchPila);
              }
          NodoPilaActual=NodoPilaActual->SiguientePila;
        }
     while (NodoColaActual != NULL)
        {
         if (NodoColaActual->EstaEnCola != 1)
            {
             strcpy(MonoCola.NombreCola,NodoColaActual->NombreCola);
             strcpy(MonoCola.EmailCola,NodoColaActual->EmailCola);
             fwrite(&MonoCola , sizeof(MonoCola),1,ArchCola);
            }
          NodoColaActual=NodoColaActual->SiguienteCola;
        }
     fclose(ArchPila);
     fclose(ArchCola);
     Close();
 }
}

IMPRIMIR:

// IMPRIMIR
void __fastcall TMiFormulario::PrintDialogClick(TObject *Sender)
{
int respuesta;
{
    respuesta=Application->MessageBox("Tu impresora Está prendida?","Atencion",MB_OKCANCEL);
    if (respuesta==IDOK)
       PrintDialog1->Execute();
}
}

MODELOS de PROGRAMAS en C++ BUILDER

Colega virtual, si eres del mundo algoritmico en estos links encontrarás toda la información necesaria para manejar con solvencia los conceptos de:

• Estructuras de datos dinámicas
• Gestión integral de Archivos en C++
• Programación Orientada a Objetos
• Visualización de datos mediante grillas windows
• Procedimientos de búsqueda por combo box
• Manejo de imágenes dinámicas de video.

Todos los algoritmos que te propongo funcionan correctamente, pues ya los probé en mi PC y en el Laboratorio de la facultad, por lo tanto, solo te resta mejorarlos de acuerdo a tus propias necesidades.

Luego de editar la siguiente sintaxis, al compilar lograrás un sistema modelo, cuya pantallas tienen el aspecto de las imágenenes de esta page.

Buena suerte y que les saque utilidad a mi propuesta..!!

///////////////////////////////////////////////////
//   C++ BUILDER                 Wilo Carpio
//   Fuente.cpp
//   Variables Dinámicas y Archivos
///////////////////////////////////////////////////

  #include 
  #include 
  #include
  #include
  #pragma hdrstop
  #include "Fuente.h"
  #pragma package(smart_init)
  #pragma resource "*.dfm"

////////////////////////////////////////////
//  DECLARACION DEL FORMULARIO PRINCIPAL
////////////////////////////////////////////

TMiFormulario *MiFormulario;

Como ya estas deduciendo, en esta propuesta continuo con el trillado ejemplo de la agenda.

La idea es solo enseñarte la sintaxis y la semántica de la estructura algorítmica que utiliza C++ Builder, la cual, con pequeñas variantes puedes migrarla a Visual C++ de Microsoft.

Para simplificarte la comprensión te he llenado la codificación con ayudas no compilables, los cuales, si eres un colega experimentado, te ruego me perdones..!!

/////////////////////////////////////////////////
//    DECLARACIONES DE VARIABLES
/////////////////////////////////////////////////

struct registro
{
 char nombre[30],edad[10],domicilio[30];
 bool elimina;
};
struct registro MiRegistro;


__fastcall TMiFormulario::TMiFormulario(TComponent* Owner): TForm(Owner)
{
 archivo.open("MisDatos.DAT",ios::in|ios::out|ios::binary|ios::ate);

 if (!archivo)
 {
   ShowMessage("No hay archivo che..!!");
   throw;
 }
 DatosPorMonitor();
}

void __fastcall TMiFormulario::BotonAltasClick(TObject *Sender)
{
 if(BotonAltas->Caption=="&Altas")
 {
  MiFormulario->Caption="Digita los datos, luego graba";
  BotonAltas->Caption="&Cerrar";
  MiGrilla->Visible=false;
  MisFolios->Visible=false;
  datos->Visible=true;
  Eliminar->Visible=false;
  nom->SetFocus();
  nom->Text = "";
  dom->Text = "";
  ed->Text = "";
  guardar->Visible=true;
 }
 else
 {
  MiFormulario->Caption="Agenda de Wilo";
  datos->Visible=false;
  BotonAltas->Caption="&Altas";
 }
}

void __fastcall TMiFormulario::guardarClick(TObject *Sender)
{
 strcpy(MiRegistro.nombre,nom->Text.c_str());
 strcpy(MiRegistro.domicilio,dom->Text.c_str());
 strcpy(MiRegistro.edad,ed->Text.c_str());
 MiRegistro.elimina=false;
 archivo.write((char *)&MiRegistro, sizeof(MiRegistro));

 if (!archivo)
 ShowMessage("No existe el archivo..!!");
  DatosPorMonitor();
  nom->SetFocus();
}

void __fastcall TMiFormulario::nomChange(TObject *Sender)
{
 if (nom->Text=="")
 {
  guardar->Enabled=false;
 }
 else
 {
  guardar->Enabled=true;
 }
}

La apariencia de los datos presentados en una grilla de entorno Windows, a mi criterio es inmejorable, por ello, en este link te ofrezco mi propuesta.

Te aconsejo que pongas atención en la rotulación de la grilla..!!

void __fastcall TMiFormulario::consultaClick(TObject *Sender)
{
 MiFormulario->Caption="Registros del Archivo";
 PortaBoton->Visible=false;
 MiGrilla->Visible=true;
 int j=1;
 archivo.seekg(0, ios::beg);
 archivo.read((char *)&MiRegistro, sizeof(MiRegistro));
 MiGrilla->Cells[0][0] = "Nro";
 MiGrilla->Cells[1][0] = "Nombre";
 MiGrilla->Cells[2][0] = "Edad";
 MiGrilla->Cells[3][0] = "Domicilio";
 int i=1,k;
 for (i=1;i<=TotalRegistrosGrabados();i++)
 for (k=0;k<=3;k++)
 {
  MiGrilla->Cells[k][i]="";
 }
 i=1;
 while (j<=TotalRegistrosGrabados())
 {
   if (MiRegistro.elimina==false)
     {
      MiGrilla->Cells[0][i]= i;
      MiGrilla->Cells[1][i]=MiRegistro.nombre;
      MiGrilla->Cells[2][i]=MiRegistro.edad;
      MiGrilla->Cells[3][i]=MiRegistro.domicilio;
      i++;
     }
  j++;
  archivo.read((char *)&MiRegistro, sizeof(MiRegistro));
 }
}

void TMiFormulario::DatosPorMonitor()
{
 if (NumeroRegistro()<=TotalRegistrosGrabados())
 {
  archivo.read((char *)&MiRegistro, sizeof(MiRegistro));
  NumeroRegistro(NumeroRegistro()-1);
  nom->Text = MiRegistro.nombre;
  dom->Text = MiRegistro.domicilio;
  ed->Text = MiRegistro.edad;
 }
 else
 {
  nom->Text = "";
  dom->Text = "";
  ed->Text = "";
 }
}

void __fastcall TMiFormulario::BotonAceptarClick(TObject *Sender)
{
 int FichaActual=1;
 char bus[40];
 AnsiString var;
 MiFormulario->MiCombo->Visible=false;
 MiFormulario->BotonAceptar->Visible=false;
 AnsiString DatoBuscado;
 bool SiEsta = false;
 archivo.seekg(0,ios::beg);
 archivo.read((char *)&MiRegistro, sizeof(MiRegistro));
 var=MiCombo->Items->Strings[MiCombo->ItemIndex];
 strcpy(bus,var.c_str());
 while(FichaActual<=TotalRegistrosGrabados())
 {
  if((strcmp(MiRegistro.nombre,bus)==0)&&(MiRegistro.elimina==false))
  {
   SiEsta = true;
   nom->Text = MiRegistro.nombre;
   dom->Text = MiRegistro.domicilio;
   ed->Text = MiRegistro.edad;
   datos->Visible=true;
   guardar->Visible=false;
   Eliminar->Visible=false;
   BotonBuscar->Caption="&Cerrar";
   datos->Caption="FICHA BUSCADA: Nº "+IntToStr(FichaActual);
   break;
  }
  FichaActual=FichaActual+1;
  archivo.read((char *)&MiRegistro, sizeof(MiRegistro));
 }
 if(SiEsta==false)
 {
  Application->MessageBox("NO EXISTE","EL REGISTRO BUSCADO",MB_OK);
  MiFormulario->Caption="Agenda de Wilo";
 }
}

En este link te ofrezco los algoritmos de carga de la grilla de datos a visualizar, con el contenido de los registros que almacenaste en tu archivo.

Como ya habrás detectado, en este ejemplo los datos se operan usando la estructura dinámica de una lista enlazada simple..!!

void __fastcall TMiFormulario::SpeedButton1Click(TObject *Sender)
{
 if(BotonVerGrilla->Caption=="&VerGrilla")
 {
  BotonVerGrilla->Caption="&Cerrar";
  MiFormulario->Caption="Fichas del Archivo";
  MiGrilla->Visible=true;
  int j=1;
  archivo.seekg(0, ios::beg);
  archivo.read((char *)&MiRegistro, sizeof(MiRegistro));
  MiGrilla->Cells [0][0]= "Ficha";
  MiGrilla->Cells [1][0]= "Nombre";
  MiGrilla->Cells [2][0]= "Edad";
  MiGrilla->Cells [3][0]= "Domicilio";
  int i=1,k;
  for (i=1;i<=TotalRegistrosGrabados();i++)
  for (k=0;k<=3;k++)
  {
   MiGrilla->Cells[k][i]="";
  }
  i=1;
  while (j<=TotalRegistrosGrabados())
  {
   if (MiRegistro.elimina==false)
   {
    MiGrilla->Cells[0][i]= i;
    MiGrilla->Cells[1][i]=MiRegistro.nombre;
    MiGrilla->Cells[2][i]=MiRegistro.edad;
    MiGrilla->Cells[3][i]=MiRegistro.domicilio;
    i++;
   }
   j++;
   archivo.read((char *)&MiRegistro, sizeof(MiRegistro));
  }
 }
 else
 {
  MiFormulario->Caption="Agenda de Wilo";
  BotonVerGrilla->Caption="&VerGrilla";
  MiGrilla->Visible=false;
 }
}

En este procedimiento, para identificar el archivo a eliminar, utilizo para la busqueda un combo box, de acuerdo a la siguiente secuencia.

• Elección de la ficha mediante combo box
• Visualización de la ficha elegida para ser dada de baja.
• Confirmación o cancelación de la eliminación
• Baja lógica del Registro

void __fastcall TMiFormulario::BotonBajasClick(TObject *Sender)
{
 int FichaActual=1;
 MiGrilla->Visible=false;
 MisFolios->Visible=false;
 MiFormulario->MiCombo->Visible=true;
 MiFormulario->BotonAceptar2->Visible=true;
 datos->Caption="Ficha Buscada";
 if(BotonBajas->Caption=="&Eliminar")
 {
  MiFormulario->BotonBajas->Caption="&Cerrar";
  MiCombo->Clear();
  archivo.seekg(0,ios::beg);
  archivo.read((char *)&MiRegistro, sizeof(MiRegistro));
  while(FichaActual<=TotalRegistrosGrabados())
  {
   MiCombo->Items->Add(MiRegistro.nombre);
   FichaActual=FichaActual+1;
   archivo.read((char *)&MiRegistro, sizeof(MiRegistro));
  }
 }
 else
 {
  MiFormulario->MiCombo->Visible=false;
  MiFormulario->BotonAceptar2->Visible=false;
  datos->Visible=false;
  MiFormulario->Caption="Agenda de Wilo";
  BotonBajas->Caption="&Eliminar";
 }
}

void __fastcall TMiFormulario::EliminarClick(TObject *Sender)
{
 int opcion;
 long a;
 char bus[40];
 AnsiString var;
 int FichaActual=1;
 MiFormulario->Caption="BAJA de una FICHA";
 BotonBajas->Caption="&Cerrar";
 archivo.seekg(0,ios::beg);
 archivo.read((char *)&MiRegistro, sizeof(MiRegistro));
 var=MiCombo->Items->Strings[MiCombo->ItemIndex];
 strcpy(bus,var.c_str());
 opcion=Application->MessageBox("Esta seguro","ELIMINAR",MB_OKCANCEL+MB_ICONQUESTION);
 if(opcion==IDOK)
 {
   while(FichaActual<=TotalRegistrosGrabados())
   {
    if((strcmp(MiRegistro.nombre,bus)==0))
    {
     if (MiRegistro.elimina==false)
     {
      MiRegistro.elimina=true;
      a=archivo.tellg();
      archivo.seekg(a-sizeof(MiRegistro));
      archivo.write((char *)&MiRegistro, sizeof(MiRegistro));
     }
    }
    FichaActual=FichaActual+1;
    archivo.read((char *)&MiRegistro, sizeof(MiRegistro));
   }
   datos->Visible=false;
  }
  else
  {
   datos->Visible=false;
  }
  MiFormulario->Caption="Agenda de Wilo";
  BotonBajas->Caption="&Eliminar";
}

void __fastcall TMiFormulario::BotonAceptar2Click(TObject *Sender)
{
 int FichaActual=1;
 char bus[40];
 AnsiString var;
 MiFormulario->MiCombo->Visible=false;
 MiFormulario->BotonAceptar2->Visible=false;
 AnsiString DatoBuscado;
 bool SiEsta = false;
 archivo.seekg(0,ios::beg);
 archivo.read((char *)&MiRegistro, sizeof(MiRegistro));
 var=MiCombo->Items->Strings[MiCombo->ItemIndex];
 strcpy(bus,var.c_str());
 while(FichaActual<=TotalRegistrosGrabados())
 {
  if((strcmp(MiRegistro.nombre,bus)==0)&&(MiRegistro.elimina==false))
  {
   SiEsta = true;
   nom->Text = MiRegistro.nombre;
   dom->Text = MiRegistro.domicilio;
   ed->Text = MiRegistro.edad;
   datos->Visible=true;
   guardar->Visible=false;
   Eliminar->Visible=true;
   BotonBajas->Caption="&Cerrar";
   datos->Caption="FICHA BUSCADA: Nº "+IntToStr(FichaActual);
   break;
  }
  FichaActual=FichaActual+1;
  archivo.read((char *)&MiRegistro, sizeof(MiRegistro));
 }
 if(SiEsta==false)
 {
  Application->MessageBox("NO EXISTE","EL REGISTRO BUSCADO",MB_OK);
  MiFormulario->Caption="Agenda de Wilo";
 }
}

Sin estas funciones, todo lo anterior no funciona, por lo tanto debes codificarlos cuidadosamente, en primera instancia no te conviene cambiar ninguna estructura.

Buena suerte..!!

  
void __fastcall TMiFormulario::BotonSalirClick(TObject *Sender)
{
 int Opcion;
 Opcion= Application->MessageBox("Deseas cerrar este Programa", "FINALIZACION DEL SISTEMA", MB_OKCANCEL+MB_DEFBUTTON1|MB_ICONQUESTION);
 if (Opcion== IDOK)
 {
  Close();
 }
}
int TMiFormulario::NumeroRegistro()
{
 return archivo.tellg()/sizeof(MiRegistro)+1;
}
void TMiFormulario::NumeroRegistro(int NuevoNumero)
{
 archivo.seekg((NuevoNumero-1)*sizeof(MiRegistro));
}
int TMiFormulario::TotalRegistrosGrabados()
{
 int PosicionActual = archivo.tellg();
 archivo.seekg(0, ios::end);
 int N = NumeroRegistro()-1;
 archivo.seekg(PosicionActual);
 return N;
}

void __fastcall TMiFormulario::BotonHelpClick(TObject *Sender)
{
  if(BotonHelp->Caption=="&Help")
    {
     MiFormulario->Caption="Ayuda del Sistema";
     MisFolios->Visible=true;
     MisFolios->Enabled=true;
     BotonHelp->Caption="&Cerrar";
    }
   else
    {
     MiFormulario->Caption="Agenda de Wilo";
     MisFolios->Visible=false;
     BotonHelp->Caption="&Help";
    }
}


void __fastcall TMiFormulario::HojaSistemaShow(TObject *Sender)
{
  VideoPlayer1->Play();
}

// BUSCAR
void __fastcall TMiFormulario::BotonBuscarClick(TObject *Sender)
{
 int FichaActual=1;
 MiGrilla->Visible=false;
 MisFolios->Visible=false;
 MiFormulario->MiCombo->Visible=true;
 MiFormulario->BotonAceptar->Visible=true;
 MiFormulario->Caption="BUSQUEDA de una FICHA";
 if(BotonBuscar->Caption=="&Buscar")
 {
  MiFormulario->BotonBuscar->Caption="&Cerrar";
  MiCombo->Clear();
  archivo.seekg(0,ios::beg);
  archivo.read((char *)&MiRegistro, sizeof(MiRegistro));
  while(FichaActual<=TotalRegistrosGrabados())
  {
   MiCombo->Items->Add(MiRegistro.nombre);
   FichaActual=FichaActual+1;
   archivo.read((char *)&MiRegistro, sizeof(MiRegistro));
   }
 }
 else
 {
  MiFormulario->MiCombo->Visible=false;
  MiFormulario->BotonAceptar->Visible=false;
  MiFormulario->Caption="Agenda de Wilo";
  BotonBuscar->Caption="&Buscar";
  datos->Visible=false;
 }
}

// ADJUNTO  
///////////////////////////////////////////////////
//   C++ BUILDER                 Wilo Carpio
//   Fuente.h
//   Variables Dinámicas y Archivos
///////////////////////////////////////////////////
#ifndef FuenteH
#define FuenteH
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
class TMiFormulario : public TForm
{
__published:	// IDE-managed Components
        TGroupBox *datos;
        TLabel *Label1;
        TLabel *Label2;
        TLabel *Label3;
        TEdit *nom;
        TEdit *dom;
        TEdit *ed;
        TBitBtn *guardar;
        TPanel *PortaBoton;
        TBitBtn *BotonAltas;
        TBitBtn *BotonBuscar;
        TBitBtn *BotonBajas;
        TBitBtn *BotonHelp;
        TStringGrid *MiGrilla;
        TSpeedButton *BotonSalir;
        TPageControl *MisFolios;
        TTabSheet *HojaSistema;
        TTabSheet *HojaAutor;
        TTabSheet *HojaAyuda;
        TLabel *LabelSistema;
        TSpeedButton *BotonVerGrilla;
        TImage *MiFoto;
        TLabel *RotuloAutor;
        TMemo *MiMemo;
        TComboBox *MiCombo;
        TBitBtn *BotonAceptar;
        TBitBtn *Eliminar;
        TBitBtn *BotonAceptar2;
        TMediaPlayer *VideoPlayer1;
        TAnimate *Animate1;
        void __fastcall BotonAltasClick(TObject *Sender);
        void __fastcall consultaClick(TObject *Sender);
        void __fastcall BotonBuscarClick(TObject *Sender);
        void __fastcall BotonBajasClick(TObject *Sender);
        void __fastcall BotonSalirClick(TObject *Sender);
        void __fastcall guardarClick(TObject *Sender);
        void __fastcall nomChange(TObject *Sender);
        void __fastcall BotonHelpClick(TObject *Sender);
        void __fastcall SpeedButton1Click(TObject *Sender);
        void __fastcall BotonAceptarClick(TObject *Sender);
        void __fastcall EliminarClick(TObject *Sender);
        void __fastcall BotonAceptar2Click(TObject *Sender);
        void __fastcall HojaSistemaShow(TObject *Sender);
private:	// User declarations
fstream archivo;
void TMiFormulario::DatosPorMonitor();
int TMiFormulario::TotalRegistrosGrabados();
int TMiFormulario::NumeroRegistro();
void TMiFormulario::NumeroRegistro(int NuevoNumero);

public:		// User declarations
        __fastcall TMiFormulario(TComponent* Owner);
};
extern PACKAGE TMiFormulario *MiFormulario;
#endif

  
// ADJUNTO
///////////////////////////////////////////////////
//   C++ BUILDER                 Wilo Carpio
//   Modelo.cpp
//   Variables Dinámicas y Archivos
///////////////////////////////////////////////////
#include 
#pragma hdrstop
USERES("Modelo.res");
USEFORM("Fuente.cpp", MiFormulario);
WINAPI WinMain(HINSTANCE, HINSTANCE, LPSTR, int)
{
        try
        {
                 Application->Initialize();
                 Application->CreateForm(__classid(TMiFormulario), &MiFormulario);
                 Application->Run();
        }
        catch (Exception &exception)
        {
                 Application->ShowException(&exception);
        }
        return 0;
}

BIBLIOGRAFIA BASICA

  LIBRO                   AUTOR                      EDITORIAL      AÑO

  Programación C++      - Luis Joyanes              - Mc Graw Hill    1999
  C++  Cómo programar   - Deitel y Deitel           - Prentice Hall   1999
  Visual C++ 6          - Kate gregory              - Prentice Hall   2000
  Visual C++ 6          - Cris H. Pappas            - Mc Graw Hill    2000
  Visual C++6 Manual    - Beck Zaratian             - Mc Graw Hill    1999
  Visual C++6           - Holzner                   - Mc Graw Hill    1999
  Manual C / C++        - Wiliam H. Murray          - Mc Graw Hill    1997
  Visual C++6           - María Cascon Sánchez       - Prentice Hall   1999
  Visual C++            - Ori y Nathan Gurenwich    - SAMS Publishing 1998
  C++ Builder 5         - Fransisco Charte          - Anaya           2000

PARADIGMA
La ignorancia niega o agrede o critica
La ciencia duda..!!
Wilucha

	PARADIGMAS IMPRESOS:
	Lenguajes	Gramáticas	Autómatas	Series
	Laplace	Ecuación	Operador	Compilador

PARADIGMA
Cultivo una rosa blanca
..en julio, como en enero
para el amigo sincero
que me da su mano franca..!!

Y para el cruel que me arranca
el corazón con que vivo,
cardo ni ortiga cultivo;
..cultivo una rosa blanca..!
José Martí

	Mis Paradigmas

Te espero en: wilucha@gmail.com

Esta page está en: www.wilocarpio.com.ar

11/09/2002