capturar una matriz y mostrarla con librería matcam.h
Visual C++ .NET
Publicado el 11 de Septiembre del 2016 por Jesus Armando (2 códigos)
3.230 visualizaciones desde el 11 de Septiembre del 2016
este código capturo y muestra una matriz completamente real o con números complejos, utilizando la librería matcam.h ejemplo en dev c++
Declare una matriz:
tecleamos la matriz con el formato descrito en la parte superior del código
resultado:
Declare una matriz:
tecleamos la matriz con el formato descrito en la parte superior del código
resultado:
Comentarios sobre la versión: 1 (1)
#include<conio.h>
#include"matcam.h"
/////////////////////////////objeto matriz//////////////////////////////////
/*
class matriz
{
public:
double **real;//////////////////////////////puntero donde se almacenan los parte real
double **imaj;//////////////////////////////puntero donde se almacenan la parte imaginria
bool im;///////////////////////////////////identifica si la matriz es real o compleja. im=true es compleja im=false es real////////////
bool mostrable;
string nombre;/////////////////////////////nombre de la matriz
string mensaje_error;//////////////////////Nombre e identificador de errores
int m,n;////////////////////////////////////dimension de la matriz, m===>numero de renglones n===>numero de columnas
unsigned short int error;///////////////////indica si tiene error de captura o de operación
short int id;///////////////////////////////numero identificador de la matriz
bool capturar_matriz(const char *cadena);///(;)-->indica renglón y (espacio)--> columna. Captura una matriz [numero1 numero2 etc...;numero1 numero2 etc...]
void ceros_imag();//////////////////////////rellena de ceros toda la parte imaginaria de la matriz
matriz *siguiente;
};*/
////////////////////////////////////////////////////////////////////////////
matriz leer_matriz(string cadena);/////////////////////////leemos un string conteniendo
/////////////////////el formato de declaracion de una matriz/////////////////////////////////////////
/*
datos:
,==>indica que es un separador en columnas
;==>indica deparador de renglones
formato:
nombreMatriz=num11,num12,nu1n;num21 num22 num2n
ejemplo:
tenemos la matriz A
1 2 3
7 8 5
9 8 6
formato de captura seria
A=1,2,3;7,8,5;9,8,6
*/
///////////////////////////////////////////////////////////////////////////
string capturar_caracteres();/////////////////////////////////captura los caracteres del teclado devolviendo un string de caracteres
int split(string *&elementos,string cad,char c);///////////////////divide un string apartir de un caracter 'c'
void mostrar_matriz(matriz A);///////////////////muestra la matriz///
double StrTof(string A);///////////convierte de caracter a flotante o double
//////////////////////////////////////////////////////////////////////////
int main()
{
string *el,cadena,col;
matriz A;
int i,j;
printf("Declare una matriz:\n");
cadena=capturar_caracteres();
A=leer_matriz(cadena);
mostrar_matriz(A);
main();
}
//////////////////////////////////////////////////////////////////////////////////////////
matriz leer_matriz(string cadena)
{
string formato,*elementos,*columnas,*complejo,*complejoP,nom;
//char c;////////////////////variable char donde guardaremos el caracter para ser comparado
matriz ret;//////matriz que contiene los valores capturados que retorna la funcion,
bool bandera=false;////////bandera que indica que hay un signo "=" igual e indicar segundo miembro
int l,n,comas=0,ren,col;/////////////////////////variavle donde se guarda la longitud de cadena
ret.m=1;///////////////inicializo la variable de m renglones
ret.im=false;///////////inicializo con false indicando que la matriz es completamente real
l=cadena.length();//////////////obtenemos la longitud de la cadena
for(int x=0;x<l;x++)
{
if(cadena[x]==';')ret.m++;/////////////////contamos los punto y comas que indica que son renglones
else if(cadena[x]==',')comas++;////////////contamos las comas en el formato
if(cadena[x]=='=')bandera=true;//////si encuentra el caracter "=" bandera será verdadero
if(!bandera)nom.operator+=(cadena[x]);//mintras no encuentre el caracter "=" almacena cada caracter del nombre
else formato.operator+=(cadena[x]);//////de lo contrario almacena el caracter en la cadena del formato de llenado de matriz
if(bandera&&(cadena[x]=='j'||cadena[x]=='i'))ret.im=true;////////si encuentra el caracter 'i' o 'j' indica que la matriz tiene parte imaginaria
}
ret.n=comas/ret.m+1;//////////////obtenemos el numero de columnas en relacion del numero de comas sobre el numero de renglones para obtener numero de columnas
ret=ceros(ret.m,ret.n,ret.im);/////////reservamos memoria para alojar su valores reales e imaginarios(en caso que tenga componente imaginaria)
ret.nombre=nom;
////////////////////////////////////////////////////////////////////////////////////////////////////////
ren=split(elementos,formato.c_str(),';');///////////////dividimos todos los renglones///////////////////////////////
for(int i=0;i<ret.m&&ret.m==ren;i++)
{
col= split(columnas,elementos[i].c_str(),',');////////separamos los elementos de cada renglón
for(int j=0;j<ret.n&&ret.n==col;j++)
{
if(ret.im)////si es imaginaria
{
l=split(complejoP,columnas[j].c_str(),'+');
if(l==1)
{
n=split(complejo,columnas[j].c_str(),'-');
if(n==2)///////si es negativa la parte imaginaria
{
ret.real[i][j]=StrTof(complejo[0].c_str());//////////se convierte un string de la parte real a flotante
ret.imaj[i][j]=-StrTof(complejo[1].c_str());//////////se convierte un string de la parte imaginaria a flotante
}
else if(n==1)/////////////si nomas tiene puro reales
{
if(!complejo[0].find('i')&&!complejo[0].find('j'))
{
ret.real[i][j]=StrTof(complejo[0].c_str());//////////se convierte un string de la parte real a flotante
ret.imaj[i][j]=0.0;//////////se convierte un string de la parte imaginaria a flotante
}
else if(complejo[0].find('i')||complejo[0].find('j'))
{
ret.real[i][j]=0.0;//////////se convierte un string de la parte imaginaria a flotante
ret.imaj[i][j]=StrTof(complejo[0].c_str());//////////se convierte un string de la parte real a flotante
}
}
else if(n==1&&(complejo[0].find('i')||complejo[0].find('j')))
{
ret.real[i][j]=0.0;//////////se convierte un string de la parte imaginaria a flotante
ret.imaj[i][j]=StrTof(complejo[0].c_str());//////////se convierte un string de la parte real a flotante
}
}
else if(l==2)//si es positiva la parte imaginaria
{
ret.real[i][j]=StrTof(complejoP[0].c_str());//////////se convierte un string de la parte real a flotante
ret.imaj[i][j]=StrTof(complejoP[1].c_str());//////////se convierte un string de la parte imaginaria a flotante
}
}
else
{
if(!columnas[j].empty())ret.real[i][j]=StrTof(columnas[j].c_str());
columnas[j].clear();
// printf("\n%s",columnas[j].c_str());
}
}
if(ret.n!=col)
ret.error=1;
}
if(ret.m!=ren)
ret.error=1;
return ret;
}
////////////////////////////////////////////////////////////////////////////////
string capturar_caracteres()
{
char c;////////variable donde se alojara el caracterdel teclado
string caracteres;////////////////////variable string dode se almacenara la cadena ingresada
do
{
c=getche();///////capturamos caracter entrante del teclado
if(c!=13)//////////siempre que "c" sea diferente de el retorno de carro CRLF
caracteres.operator+=(c);/////se almacena el caracter a la cadena
}while(c!=13);
return caracteres;
}
///////////////////////////////////////////////////////////////////////////////////////////////////////
int split(string *&elementos,string cad,char c)
{
const char *cadena;
cadena=cad.c_str();
int l,e=0,cont=1;
l=cad.length();////////obtenemos el numero de caracteres de la caderna
for(int x=0;x<l;x++)if(cadena[x]==c&&x!=0)cont++;///////////cuenta el numero de caracteres separadores
elementos=new string[cont];///////////////////////////reserva espacio de memoria de acuerdo al numero de separciones
for(int x=0;x<l;x++)
{
if(cadena[x]!=c||(cadena[x]==c&&x==0))///si se presenta el caracter de divicion en la primer posicion, este sera ignorado
elementos[e].operator+=(cadena[x]);
else e++;
}
return cont;
}
//////////////////////////////////////////////////////////////////
void mostrar_matriz(matriz A)
{
if(A.error==0)
{
printf("\n%s=:\n",A.nombre.c_str());
for(int i=0;i<A.m;i++)
{
for(int j=0;j<A.n;j++)
{
if(A.im)
{
if(A.imaj[i][j]>=0)printf("%f+%fi ",A.real[i][j],A.imaj[i][j]);/////////si es positivo el imaginario
else printf("%f%fi ",A.real[i][j],A.imaj[i][j]);/////////si es negativo el imaginario
}
else printf("%f ",A.real[i][j]);
}
printf("\n");
}
}
else puts("\nMatriz erronea");
}
///////////////////////////////////////////////////////////////////////////////
double StrTof(string a)
{
float ent=0.0,dec=0,aux=0;
short int bandera=0,sig=1,f=0,lon;
float d=10.0,num=0.0,den=1.0;
const char *c;
c=a.c_str();
lon=a.length();
for(int x=0;x<lon;x++)
{
if(bandera&&c[x]>='0'&&c[x]<='9')
dec=dec+(c[x]-48)/d,d*=10;
else if(c[x]>='0'&&c[x]<='9'&&!bandera)
ent=ent*10+c[x]-48;
if(c[x]=='.')
bandera=1;
if(c[x]=='-')
sig=-1;
if(c[x]=='/')
bandera=0,num=(ent+dec),f=1,ent=0,dec=0,d=10.0;
}
if(!f)num=(ent+dec)*sig;
if(f)den=(ent+dec)*sig;
aux=num/den;
return aux;
}