Implementación de una Clase Matriz Dinámica en C++: CMatFloat

Implementación de la Clase CMatFloat en C++

A continuación se presenta la definición y la implementación de la clase CMatFloat, diseñada para la gestión y manipulación de matrices bidimensionales de números en punto flotante (float) mediante reserva dinámica de memoria.

Archivo de Cabecera: CMatFloat.h

Este archivo contiene la declaración de la clase, sus atributos privados y los prototipos de sus métodos públicos.

#if !defined(_CMATFLOAT_H_)
#define _CMATFLOAT_H_

#include <iostream>
#include <cstdlib> // Librería estándar
#include <cstdio>
#include <climits>
#include "Utils.h"
#include "MemoryManager.h"

class CMatFloat
{
    // Datos privados de la clase
private:
    float** m_ppDatosF; // Apunta a los datos de la matriz
    int m_nFilas;       // Número de filas
    int m_nColumnas;    // Número de columnas

    // Métodos (funciones miembro) de la clase
public:
    void Iniciar();  
    void CrearMatriz2D(int nFilas, int nColumnas); 
    void CrearMatriz1D(int nElementos) {   
        CrearMatriz2D(1, nElementos);   
    }
    void Introducir();
    void Mostrar();
    void Destruir();
    bool Existe();
};

#endif // _CMATFLOAT_H_

Archivo de Implementación: CMatFloat.cpp

Contiene el desarrollo y la lógica de cada función miembro de la clase.

#include <iostream>
#include "Utils.h"
#include "CMatFloat.h"
#include "MemoryManager.h"

void CMatFloat::Iniciar() {
    m_ppDatosF = NULL;
    m_nFilas = 0;
    m_nColumnas = 0;
}

void CMatFloat::CrearMatriz2D(int nFilas, int nColumnas) {
    int i, j;
    m_ppDatosF = new float* [nFilas]; // Reservando memoria para las filas
    if (m_ppDatosF == NULL) {
        std::cout << "\n Error!!";
    }

    for (i = 0; i < nFilas; i++) {
        m_ppDatosF[i] = new float[nColumnas]; // Reservando memoria para las columnas
        if (m_ppDatosF[i] == NULL) {
            std::cout << "\n Error!!!";
        }
    }

    // Inicializar la matriz a cero
    for (i = 0; i < nFilas; i++) {
        for (j = 0; j < nColumnas; j++) {
            m_ppDatosF[i][j] = 0.0f;
        }
    }

    m_nFilas = nFilas;
    m_nColumnas = nColumnas;
}

void CMatFloat::Introducir() {
    int i, j;
    float dato;
    // Recorrer la matriz para introducir valores
    for (i = 0; i < m_nFilas; i++) {
        for (j = 0; j < m_nColumnas; j++) {
            std::cout << "\nIntroducir dato de la matriz, Fila " << i + 1 << " Columna " << j + 1 << ": ";
            dato = LeerFloat();
            m_ppDatosF[i][j] = dato;
        }
    }
}

void CMatFloat::Mostrar() {
    int i, j;
    std::cout << "\n";
    // Recorre la matriz para mostrarla por pantalla
    for (i = 0; i < m_nFilas; i++) {
        for (j = 0; j < m_nColumnas; j++) {
            std::cout << m_ppDatosF[i][j] << " ";
        }
        std::cout << "\n";
    }
}

void CMatFloat::Destruir() {
    int i;
    for (i = 0; i < m_nFilas; i++) {
        delete[] m_ppDatosF[i]; // Borra la memoria reservada de columnas
    }
    delete[] m_ppDatosF; // Borra la memoria reservada para las filas
    std::cout << "Matriz destruida\n";
    Iniciar();
}

bool CMatFloat::Existe() {
    if (m_ppDatosF != NULL) {
        return true;
    } else {
        return false;
    }
}