PARADIGMAS

VECTORES PARADIGMA
El amor es lo único que crece..
... cuando se reparte ..!!
Saint Exupéry
| Volver | | Arbol | | Archivo | | Base de dato | Basico | | Cola y Pila |
| Editor | | Editor2 | | Fibonacci | | Hanoi | | Listas | | Matriz |
| Modelo 1 | | Modelo | | Polimorfismo | Punteros | | Sobrecarga | | Agenda |
PARADIGMA
Lo que no me mata.. me fortalece..!!
Nietzsche
EL ARRAY

Colega algorítmico, si eres del mundo paradigmático en estos links encontrarás toda la información necesaria para iniciar el manejo de los conceptos del Vector.. o Array.. o Arreglo..!!
Para no aburrirte con la teoría matemática vectorial solo te pido que distribuyas tus objetos de acuerdo al esquema de esta imagen y luego que recuerdes cada uno de los siguientes conceptos básicos.

Un vector es una forma de dato estructurado que se caracteriza por tener un subíndice que indica su localización dentro del conjunto homogeneo de datos que registra.
Todos los elementos del vector son del mismo tamaño y del mismo tipo de dato.
Cada vector posee un nombre o identificador que es constante y representa la dirección de su primer elemento
Gracias a tal subídice, el manejo algorítmico de los vectores, como podrás comprobar en este link, es una cosa muy sencilla, especialmente si tienes alguna solvencia en la aplicación de los iteradores definidos.
Tal subíndice puedes operarlo matemáticamente como una expresión cualquiera de variable entera.
El subíndice es una variable entera que comienza en cero.
La cantidad de elementos del vector prácticamente es ilimitado, pero es necesario que definas de antemano su límite.
Los datos que puedes guardar en el vector siempre será del mismo tipo y al igual que cualquier otra variable es necesario que previamente lo definas.

Todos los algoritmos que te propongo funcionan correctamente, 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 que te permitirá ver en acción a los objetos del grafico precedente.
Como podrás apreciar el siguiente ejemplo solo te permite efectuar altas de datos y luego la visualización de los mismos. Solo requieres armar los objetos de acuerdo a la imagen de los objetos de la parte superior de este link y asignarle los nombres que te indico en el siguiente programa.
A modo de introducción también te propongo algunos mecanismos de seguridad y amigabilidad en el procesamiento de un vector cuyo elemento posee dos campos tipo cadena.
Ah..!! Este primer ejemplo, con el fín de simplificar no posee archivo, por lo tanto los registros de datos son volátiles al cerrar el programa.
VECTOR Programa Fuente


/////////////////////////////////////////////////////
// C++Builder 5                     Wilo Carpio
//
//  MANEJO BASICO DE UN VECTOR DE DOS CAMPOS
//                 SIN ARCHIVO
//
////////////////////////////////////////////////////

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

#include 
#pragma hdrstop

#include "Fuente.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
 ///////////////////////////////////////
 //
 //  Declaracion de la Estructura
 //////////////////////////////////////
 typedef struct registro
{
  char Nombre[30], Email[30];
  int Borrado;
} MiRegistro;
//////////////////////////////
//
//   Declaracion del Vector
//////////////////////////////
MiRegistro MiVector[50];
////////////////////////////////////////////
//
// Declaracion de las variables del Vector
////////////////////////////////////////////
int i=0;
int n=0;
int Total,l;

TMiFormulario *MiFormulario;
//---------------------------------------------------------------------------
__fastcall TMiFormulario::TMiFormulario(TComponent* Owner)
        : TForm(Owner)
{
}
//---------------------------------------------------------------------------
void __fastcall TMiFormulario::BotonSalirClick(TObject *Sender)
{
 if (Application->MessageBox("Quieres cerrar el programa.?","Ojito.. QUE NO TENES ARCHIVO..!!",MB_DEFBUTTON1 + MB_OKCANCEL + MB_ICONQUESTION)==1)
      {
        Close();
       }
}
//---------------------------------------------------------------------------
void __fastcall TMiFormulario::BotonAltasClick(TObject *Sender)
{
 if(BotonAltas->Caption=="&Altas")
 {
  BotonAltas->Caption = "&Cerrar";
  BoxNombre->Visible=true;
  BoxNombre->SetFocus();
  BoxEmail->Visible=true;
  MiFormulario->Caption="DIGITA LOS NUEVOS DATOS";
  Autor->Visible=false;
 }
 else
 {
  BotonAltas->Caption = "&Altas";
  BoxNombre->Visible=false;
  BoxEmail->Visible=false;
  MiFormulario->Caption="VECTORES: Agenda sin archivo  Wilo Carpio";
  Autor->Visible=true;
 }
}
//---------------------------------------------------------------------------
void __fastcall TMiFormulario::BoxNombreChange(TObject *Sender)
{
 if(!(BoxNombre->Text==""))
 {
  GrabarAlta->Visible=true;
 }
 else
 {
  GrabarAlta->Visible=false;
 }
}
//---------------------------------------------------------------------------
void __fastcall TMiFormulario::GrabarAltaClick(TObject *Sender)
{
 i++;
 Total = i;
 strcpy(MiVector[i].Nombre,BoxNombre->Text.c_str());
 strcpy(MiVector[i].Email,BoxEmail->Text.c_str());
 MiFormulario->Caption="CARGADO: V("+IntToStr(i)+") = "+AnsiString(MiVector[i].Nombre);
 BoxNombre->Clear();
 BoxEmail->Clear();
 BoxNombre->SetFocus();
 BotonVer->Visible=true;
}

///////////////////////////////////////////////////////////////
// VISUALIZACION DE DATOS POR BOX MEMO Y POR GRILLA
//////////////////////////////////////////////////////////////
void __fastcall TMiFormulario::BotonVerClick(TObject *Sender)
{
 if(BotonVer->Caption=="&VerFichas")
 {
   //////////////////////////////////////////////
   //  Carga del vector en el BOX MEMO
   //////////////////////////////////////////////
   MiFormulario->Caption="FICHAS CARGADAS: V( "+IntToStr(Total)+" ) ";
   BotonVer->Caption = "&Cerrar";
   BoxMemo->Clear();
   BoxMemo->Lines->Add("\t CONTENIDO");
   BoxMemo->Lines->Add("\t ==========");
   BoxMemo->Visible=true;
   for(n=1;n<=Total;n++)
   BoxMemo->Lines->Add("V("+IntToStr(n)+") = "+AnsiString(MiVector[n].Nombre));
   //////////////////////////////////////////////
   //  Carga de datos a la GRILLA
   //////////////////////////////////////////////
   i=1;
   l=1;
   MiGrilla->Cells[0][0]="Nombre";
   MiGrilla->Cells[1][0]="Email";
   while (i<=Total)
      {
        MiGrilla->Cells[0][l]=MiVector[i].Nombre;
        MiGrilla->Cells[1][l]=MiVector[i].Email;
        i=i+1;
        l=l+1;
      }
   MiGrilla->Visible=true;
 }
 else
 {
  BotonVer->Caption = "&VerFichas";
  BoxMemo->Visible=false;
  MiGrilla->Visible=false;
  MiFormulario->Caption="VECTORES: Agenda sin archivo  Wilo Carpio";
 }

}
//---------------------------------------------------------------------------

void __fastcall TMiFormulario::MiGrillaClick(TObject *Sender)
{
   MiFormulario->Caption="CONTENIDO DEL VECTOR";
   i=1;
   l=1;
   MiGrilla->Cells[0][0]="Nombre";
   MiGrilla->Cells[1][0]="Email";
   while (i<=Total)
      {
        MiGrilla->Cells[0][l]=MiVector[i].Nombre;
        MiGrilla->Cells[1][l]=MiVector[i].Email;
        i=i+1;
        l=l+1;
      }
   MiGrilla->Visible=true;

}

Si quieres una mano que te ayude, la encontrarás al final de tu brazo...!!

Del anális de esto ejemplo ya estas en condición de deducir que:

Los vectores y las matrices en C, son manejados como estructuras de datos tipo ARREGLOS, que son grupos consecutivos de localidades de memoria a los cuales les asignamos un mismo nombre y un mismo tipo de dato.

Las magnitudes vectoriales y matriciales, forman parte de los datos estructurados que se caracterizan por ser variables del tipo subindicadas, pues en su estructura integran un valor indice que indica la ubicación de cada uno de sus elementos dentro del conjunto.

Estos datos requieren:

DECLARACION: Previo a usarlas, debes declararlas como variables globales o como locales: Ejemplo: Para declarar que operararás con una matríz de 20 filas por 20 columnas, la sintaxis es:
int MiMatriz[30][30];
int TuMatriz[50][30];
int MiMatriz[30][30], TuMatriz[50][30] Esta equivale a las dos anteriores.
INICIALIZACION: Si requieres asignar un valor inicial a uno de los elementos de la matríz, por ejemplo 0 al primer elemento, la sintaxis es:
MiMatriz[1][1] = 0;
int TuVector[4]= {69, 22, 14, 55}; ( Este ejemplo abarca declaración e inicialización )
ASIGNACION: Con los datos en formato matricial puedes operar tal como lo haces con una variable común, solo debes poner atención al índice del elemento que asignas. Ejemplos:
MiMatriz[i][j] = TuMatriz[i][j] + EsaMatriz[x][y]
MiMatriz[i][j] = TuMatriz[i][j] - UnValor
MiMatriz[i][j] = TuMatriz[i][j] * 5

Tanto en C, como en C++, en Visual C++ y C++Builder, siempre el elemento inicial tiene como subíndice cero, por ello, el primer elemento si se trata de:

VECTORES: MiVector[0]
MATRICES: MiMatriz[0][0]

Fácilmente puedes deducir que el elemento enésimo será

VECTORES: MiVector[n-1]
MATRICES: MiMatriz[n-1][n-1]

Es necesario que los subíndices sean:

VALORES ENTEROS: MiVector[12]
EXPRESIONES ENTERAS: MiMatriz[n-m][n-q+1], donde m, n y q son variables enteras.

Si eres novel en el diseño algorítmico, para continuar, te recomiendo verificar tus conocimientos sobre..

MATRICES