PROGRAMACIÓN VISUAL

REPORTE DE PRÁCTICA #5

Alumno: Marcus André Menegatti da Costa

Número de Control: 21130040
Carrera: Ing. Electrónica
Profesor: Alejandro Enrique Dzul Lopez

Torreón, Coahuila, 21/10/2022

Semestre: 04.2022
Índice
1. INTRODUCCIÓN ..................................................................................................................... 2
2. ANÁLISIS ................................................................................................................................ 2
 Función main(): ................................................................................................................. 3
 Función menu(): ................................................................................................................ 5
 Constructor CVector(): ...................................................................................................... 5
 Método set_v1(): ............................................................................................................... 5
 Método get_v1(): .............................................................................................................. 6
 Método show_v1(): ........................................................................................................... 6
 Constructor CMatriz(): ...................................................................................................... 6
 Método set_m1(): ............................................................................................................. 6
 Método get_m1(): ............................................................................................................. 7
 Método det_m1(): ............................................................................................................. 7
 Método cof_m1(): ............................................................................................................. 7
 Método adj_m1(): ............................................................................................................. 8
 Método tras_m1(): ............................................................................................................ 8
 Método inv_m1(): ............................................................................................................. 8
 Método show_m1():.......................................................................................................... 9
 Constructor CSSE(): ........................................................................................................... 9
 Método result(): ................................................................................................................ 9
 Método get_result(): ....................................................................................................... 10
3. CÓDIGO EM C++ .................................................................................................................. 10
4. CONCLUSIÓN ....................................................................................................................... 19

Tabla de Ilustraciones
Ilustración 1. Menu ....................................................................................................................... 3
Ilustración 2. Opción Inválida ........................................................................................................ 4
Ilustración 3. Llenar matriz o vector! ............................................................................................ 4
Ilustración 4. Llenado del vector “b” ............................................................................................. 5
Ilustración 5. Impresión del vector "b" ......................................................................................... 6
Ilustración 6. Llenar matriz A ........................................................................................................ 7
Ilustración 7. Impresion de la matriz "A" ...................................................................................... 9
Ilustración 8.Resultado del sistema de ecuaciones .................................................................... 10
Ilustración 9.Resultado del sistema de ecuaciones sin solución ................................................. 10
 1. INTRODUCCIÓN

El objetivo de la actual práctica es desarrollar un programa en lenguaje C/C++,

en modo consola, con un menú repetitivo, que sea capaz de utilizar clases para
hacer operaciones matriciales. El programa debe regresar un vector resultante
en la ecuación: Ax+b=0.

El programa deberá de tener dos clases (CVector y CMatriz) y una clase derivada
(CSSE), que hereda los constructores, datos miembros y métodos de las dos
clases.

El constructor de la clase CVector tendrá la función de inicializar el vector “b” en

cero.

De la misma manera, el constructor de la clase CMatriz inicializará los elementos

de la matriz “A” en cero.

El vector será de tres renglones y la matriz será de tres renglones y tres

columnas.

Para la resolución de este problema, fue utilizado el lenguaje C++, en el

programa Borland C++ Builder 6.

La metodología empleada para la resolución del programa fue el uso de clases.

2. ANÁLISIS

Para el análisis del código, se tomará función por función para una mejor
organización y comprensión.

Antes de analizar las funciones, es importante mencionar que serán utilizadas

dos clases principales (CVector y CMatriz) y una clase derivada (CSSE) que
hereda informaciones de las dos clases principales.

La función utilizada en el programa es: menu(). Ademas, fue usada la función

principal: main().

2
Para la clase CVector, fueron utilizados los siguientes métodos: set_v1(),
get_v1(), show_v1().

Para la clase CMatriz, fueron utilizados los siguientes métodos: set_m1(),

get_vm1(), det_m1(), cof_m1(), adj_m1(), tras_m1(), inv_m1, show_v1().

Para la clase CSSE, fueron utilizados los siguientes métodos: result(),

get_result().

Además de los métodos, los constructores de cada clase llevan el mismo nombre
que estas.

 Función main():

La función principal main() es donde corre el programa.

Antes de trabajar con los métodos de la clase CSSE, se hace la llamada a

esta clase y se utiliza el nombre c. También son declarados cuatro números
enteros: uno para la opción del menú y los demás para que sean “banderas”,
que permiten el acceso a determinadas opciones del menú.

También fueron declarados dos arreglos de una dimensión (para vectores)

del tipo double y dos arreglos de dos dimensiones (para matrices) del mismo
tipo.

La función principal está formada por el ciclo do…while para correr, al menos
una vez, la función menú(). Al recibir el valor de la opción del menú, se utilizó
la estructura selectiva switch para evaluar cada opción del número uno al
cuatro. Caso el número digitado esté fuera de este rango, el mensaje “Opción
inválida!” aparece en pantalla.

Ilustración 1. Menu

3
 Ilustración 2. Opción Inválida

Para control del menú se utilizó dos variables de control, b1 y b2. Estas
variables son banderas que permiten que el programa siga funcionando
correctamente. Por ejemplo, si no se llena el vector “b”, no se puede obtener
el vector resultante de la ecuación. Por esto, la variable b1 recibió un valor
falso (el cero). Al llenar el vector “b”, el valor de b1 cambia a verdadero (1) y
permite generar la opción 3.

La misma función tiene b2. Sin embargo, esta variable está ligada a la opción
“llenar la matriz A”. Si se llena la matriz, la variable de control pasará de un
cero a uno (valor verdadero) y se podrá generar el vector resultante de la
ecuación.

La opción 3 tiene que tener, obligatoriamente, los dos valores (de b1 y b2)
verdaderos.

Caso no se llene ni el vector “b”, ni la matriz “A”, el programa regresará el

mensaje: “Llenar matriz o vector!”.

Ilustración 3. Llenar matriz o vector!

4
Al final del código de la función principal, se utiliza la función getch(), para
esperar a que el usuario teclee algún carácter, y la función clrscr(), para
limpiar la pantalla, por cuestiones de limpieza y estética.

 Función menu():

La función menú() es del tipo entera (int) y regresa el valor de la opción

seleccionada. Está conformada del texto que el usuario lee en pantalla.

Para la clase CVector:

 Constructor CVector():

El constructor utiliza un ciclo for para inicializar los datos del vector v1 a cero.

 Método set_v1():

El método set_v1() tiene como objetivo justamente llenar el vector “b”. Es

formado por un ciclo for. El argumento de la función es void, porque no
regresa ni recibe valores. El vector es almacenado en el objeto v1, declarado
en la clase. El objeto está declarado como protected porque será usado por
la clase CSSE.

Se usó un polimorfismo para este método: set_v1(double []). Esto para que
el programador pueda definir un vector en la función principal, sin necesidad
de que el usuario introduzca los datos.

Ilustración 4. Llenado del vector “b”

5
 Método get_v1():

El método get_v1() recibe un arreglo y este arreglo recibe el valor contenido

en v1. Es un método de asignación de valor. Es formado por un ciclo for.

Al momento del usuario ingresar los valores al vector “b”, el método get_v1()
es llamado y es asignado, en la función principal, los valores de v1 a un
arreglo de una dimensión llamado vector.

 Método show_v1():

El método show_v1() es del tipo void y exhibe en pantalla el vector que se

requiera.

Está formado por un ciclo for que recorre todo el vector e imprime los valores
en pantalla, uno debajo del otro.

Ilustración 5. Impresión del vector "b"

Para la clase CMatriz:

 Constructor CMatriz():

El constructor inicializa todos los elementos de la matriz en cero. Para esto,

se utiliza dos ciclos for para recorrer todas las posiciones.

 Método set_m1():

6
Para el método set_m1() se utilizó el tipo void y que no recibe nada. Lo que
hace la función es llenar la matriz “A”. El método es compuesto por dos ciclos
for.

Ilustración 6. Llenar matriz A

 Método get_m1():

El método get_m1() asigna los valores contenidos en m1 (arreglo

bidimensional del tipo double) a otro arreglo del mismo tipo y dimensión. El
objeto m1 fue declarado en protected para que la clase CSSE tenga acceso
a él.

 Método det_m1():

El método det_m1() trabaja con polimorfismo. Fueron definidos dos métodos

de mismo nombre, pero con argumentos distintos. En uno, el argumento es
un arreglo bidimensional de tres renglones y tres columnas y en el otro, el
argumento es un arreglo bidimensional de dos renglones y dos columnas. Se
escogió trabajar de esta forma, porque, para encontrar la matriz de
cofactores, se usa matriz de orden inferior (es decir, de orden dos). De esta
manera, se puede calcular el determinante de una matriz de orden tres y dos
a través de las fórmulas de Sarrus. En ambos casos, los métodos son del
tiplo double.

 Método cof_m1():

El método cof_m1() es del tipo double y recibe tres datos: la matriz a ser
calculada el cofactor, un entero para la fila y otro entero para la columna a

7
ser eliminadas. Lo que hace el método es recorrer la matriz principal,
introducida por el usuario, y calcular una matriz menor (de orden inferior, es
decir, dos). Al llenar la matriz, el método regresa el valor del determinante de
esta matriz menor para luego asignar el valor a la matriz de cofactores. El
método es formado por dos ciclos for y dos estructuras selectivas if para
controlar el llenado de la matriz menor.

 Método adj_m1():

El método adj_m1() es del tipo void y recibe un arreglo del tipo double y
regresa otro arreglo del mismo tipo. El método asigna los valores calculados
de los determinantes de las matrices menores a una matriz de cofactores
llamada cof. Esta matriz fue definida en protected al inicio de la clase.
Después se usa el método de la matriz traspuesta para transformar la matriz
“A” en adjunta. La matriz adjunta, por definición, es la traspuesta de la matriz
de cofactores.

 Método tras_m1():

El método tras_m1() cambia columnas por filas, usando dos ciclos for. El
método es del tipo void y recibe un arreglo del tipo double y regresa otro
arreglo del mismo tipo.

 Método inv_m1():

El método inv_m1() calcula el determinante de la matriz “A”, mediante el

método det_m1() y genera la matriz adjunta de la misma matriz. Fue definida
una bandera ban para controlar el método, caso el determinante sea igual a
cero (en este caso, no hay matriz inversa). Si el determinante es diferente a
cero, los elementos de la matriz adjunta generada son divididos por el
determinante de la matriz “A”. Este es el concepto de la matriz inversa: el la

8
matriz adjunta dividida por el determinante. En este caso, la bandera ban
cambia de cero a uno.

El método es del tipo int, recibe un arreglo del tipo double y regresa otro
arreglo del mismo tipo. El método regresa el valor entero contenido en ban.

 Método show_m1():

El método show_m1() es del tipo void y exhibe en pantalla la matriz que se

requiera.

Está formado por dos ciclos for que recorren toda la matriz e imprime los
valores en pantalla.

Ilustración 7. Impresion de la matriz "A"

Para la clase CSSE:

 Constructor CSSE():

El constructor inicializa todos los elementos del vector en cero. Para esto, se
utiliza un ciclo for para recorrer todas las posiciones. También inicializa los
constructores de las clases heredadas.

 Método result():

El método result() hace el cálculo de la multiplicación entre una matriz y un

vector. Para esto, utiliza dos ciclos for.

9
  Método get_result():

El método get_result() asigna el valor calculado a un vector respuesta, para

que se imprima en pantalla posteriormente.

Ilustración 8.Resultado del sistema de ecuaciones

Ilustración 9.Resultado del sistema de ecuaciones sin solución

3. CÓDIGO EM C++

A continuación se mostrará el código de la solución presentada.

#include <iostream.h>
#include <conio.h>
#include <math.h>

class CVector
{
protected:
double v1[3];
public:
CVector(void);
void set_v1(void);

10
 void set_v1(double []);
void get_v1(double []);
void show_v1(double []);
};

CVector::CVector(void)
{
for (int i=0;i<3;i++)
{
v1[i]=0;
}
}

void CVector::set_v1(void)
{
for (int i=0;i<3;i++)
{
cout<<"V1["<<i+1<<"] = ";
cin>>v1[i];
}
}

void CVector::set_v1(double a[])

{
for (int i=0;i<3;i++)
{
v1[i]=a[i];
}
}

void CVector::get_v1(double a[])

{
for (int i=0;i<3;i++)
{
a[i]=v1[i];
}

11
}

void CVector::show_v1(double a[])

{

cout<<endl<<"===================================="<<endl<<"\t\tVECTOR"
<<endl<<"===================================="<<endl<<endl;
for (int i=0;i<3;i++)
{
cout<<a[i]<<endl;
}
}

class CMatriz
{
protected:
double m1[3][3], m_menor[2][2], cof[3][3];
double d;
public:
CMatriz(void);
void set_m1(void);
void get_m1(double [][3]);
double det_m1(double [][3]);
double det_m1(double [][2]);
double cof_m1(double [][3], int, int);
void adj_m1(double [][3], double[][3]);
void tras_m1(double [][3], double[][3]);
int inv_m1(double [][3], double [][3]);
void show_m1(double [][3]);
};

CMatriz::CMatriz(void)
{
for (int i=0;i<3;i++)
{
for (int j=0;j<3;j++)
{

12
 m1[i][j]=0;
}
}
}

void CMatriz::set_m1(void)
{
cout<<"Escribir Matriz: "<<endl;
for (int i=0;i<3;i++)
{
for (int j=0;j<3;j++)
{
cout<<"M["<<i+1<<"]["<<j+1<<"] = ";
cin>>m1[i][j];
}
}
}

void CMatriz::get_m1(double a[][3])

{
for (int i=0;i<3;i++)
{
for (int j=0;j<3;j++)
{
a[i][j]=m1[i][j];
}

}
}

double CMatriz::det_m1(double a[][3])

{
return (a[0][0]*a[1][1]*a[2][2] + a[0][1]*a[1][2]*a[2][0] +
a[0][2]*a[1][0]*a[2][1])-(a[0][2]*a[1][1]*a[2][0] +
a[0][1]*a[1][0]*a[2][2] + a[0][0]*a[1][2]*a[2][1]);
}

13
double CMatriz::det_m1(double a[][2])
{
return (a[0][0]*a[1][1]-a[0][1]*a[1][0]);
}

double CMatriz::cof_m1(double a[][3], int b, int c)

{
int x, y;
x=0;
y=0;

for(int i=0;i<3;i++)
{
for(int j=0;j<3;j++)
{
if(i!=b && j!=c)
{
m_menor[x][y]=a[i][j];
y++;
if(y>=2)
{
x++;
y=0;
}
}
}
}
return pow((-1),b+c)*det_m1(m_menor);
}

void CMatriz::adj_m1(double a[][3], double b[][3])

{
for(int i=0;i<3;i++)
{
for(int j=0;j<3;j++)
{

14
 cof[i][j]=cof_m1(a,i,j);
}
}
tras_m1(cof, b);
}

void CMatriz::tras_m1(double a[][3], double b[][3])

{
for (int i=0;i<3;i++)
{
for(int j=0;j<3;j++)
{
b[j][i]=a[i][j];
}
}
}
int CMatriz::inv_m1(double a[][3], double b[][3])
{
d=det_m1(a);
adj_m1(a,b);
int ban=0;

if(d!=0)
{
for (int i=0;i<3;i++)
{
for (int j=0;j<3;j++)
{
b[i][j]=b[i][j]/d;
}
}
ban=1;
}
else
{
cout<<"La matriz no tiene inversa!"<<endl;

15
 }
return ban;
}

void CMatriz::show_m1(double a[][3])

{

cout<<endl<<"===================================="<<endl<<"\t\tMATRIZ"
<<endl<<"===================================="<<endl<<endl;
for(int i=0;i<3;i++)
{
cout<<"| ";
for(int j=0;j<3;j++)
{
cout<<" "<<a[i][j];
}
cout<<" |"<<endl;
}
}

class CSSE: public CVector, public CMatriz

{
private:
double v2[3];
public:
CSSE(void);
void result(double [][3], double []);
void get_result(double []);
};

CSSE::CSSE(void)
:CVector(), CMatriz()
{
for(int i=0;i<3;i++)
{
v2[i]=0;
}

16
}

void CSSE::result(double a[][3], double b[])

{
for (int i=0;i<3;i++)
{
v2[i]=0;
for(int j=0;j<3;j++)
{
v2[i]=v2[i]+a[i][j]*b[j];
}
v2[i]=-v2[i];
}
}

void CSSE::get_result(double a[])

{
for (int i=0;i<3;i++)
{
a[i]=v2[i];
}
}

int menu(void);

void main(void)
{
CSSE c;
double vector[3], x[3];
double matriz[3][3], inversa[3][3];

int o, b1=0, b2=0, b3;

do
{
o=menu();
switch (o)

17
 {
case 1:
c.set_v1();
c.get_v1(vector);
c.show_v1(vector);
b1=1;
break;

case 2:
c.set_m1();
c.get_m1(matriz);
c.show_m1(matriz);
b2=1;
break;

case 3:
if(b1 && b2)
{
b3=c.inv_m1(matriz, inversa);
c.result(inversa,vector);
c.get_result(x);
if(b3)
{
c.show_v1(x);
}
else
{
cout<<"Ecuacion sin
solucion!!";
}

}
else
{
cout<<"Llenar matriz o vector!";
}
break;

18
 case 4:
break;

default:
cout<<"Opcion invalida!";
break;

}
getch();
clrscr();

}while(o!=4);
}

int menu(void)
{
int o;

cout<<"===================================="<<endl<<"\t\tMENU"<<endl<<
"===================================="<<endl;
cout<<"1. Llenar el vector b;\n2. Llenar la matriz A;\n3. Obtener
el vector resultante x, del sistema Ax+b=0;\n4. Salir;\nOpcion: ";
cin>>o;
return o;
}

4. CONCLUSIÓN

El programa utilizó el concepto de clases para la resolución de un programa

sencillo que resuelve un sistema de ecuaciones mediante matrices y vectores.
El uso de clases facilita el programador caso quiera agregar más funcionalidades
al programa.

El uso de clases es muy conveniente para cualesquiera tipos de programa,

puesto que permite una mejor organización para el programador.

19