Utilizamos cookies propias y de terceros para mejorar la experiencia de navegación, y ofrecer contenidos y publicidad de interés. Al continuar con la navegación entendemos que se acepta nuestra política de cookies.
Publicado el 11 de Septiembre del 2016 por Jesus Armando
1.968 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
#include<stdio.h>
#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++;
}
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;
}