TDA

Los Tipos de Datos Abstractos (TDA) son una estructura de datos que define un conjunto de datos y operaciones que pueden realizarse en esos datos, pero sin especificar cómo se implementan dichas operaciones. Es decir, se definen los comportamientos y las propiedades de los datos, pero no su implementación concreta.

Los TDAs son una herramienta importante en la programación orientada a objetos ya que permiten la encapsulación de datos y la separación entre la interfaz y la implementación. Esto facilita la modularidad del código y la reutilización de componentes.

Los TDAs se definen a través de una clase abstracta que define los métodos que los objetos deben implementar. Estos métodos se llaman operaciones y pueden ser públicos o privados, dependiendo de si se deben acceder desde fuera de la clase o solo desde dentro. Los objetos creados a partir de la clase abstracta se llaman instancias del TDA.

Por ejemplo, un TDA puede ser una lista enlazada que tenga operaciones para insertar, eliminar y buscar elementos. La clase abstracta definiría estos métodos y las instancias del TDA tendrían que implementarlos para poder usarse correctamente.

A continuación se muestra un ejemplo de un TDA que representa una fracción:

c++Copy codeclass Fraction {
public:
    virtual Fraction add(Fraction other) = 0;
    virtual Fraction subtract(Fraction other) = 0;
    virtual Fraction multiply(Fraction other) = 0;
    virtual Fraction divide(Fraction other) = 0;
    virtual void print() = 0;
};

En este ejemplo, la clase abstracta Fraction define las operaciones que se pueden realizar con una fracción: adición, sustracción, multiplicación, división y la impresión de la fracción en pantalla. Sin embargo, no se especifica cómo se deben implementar estas operaciones en una fracción concreta. Eso queda para las clases que hereden de Fraction y que implementen estas operaciones de manera específica.

Por ejemplo, si quisiéramos crear una fracción en C++ usando este TDA, podríamos crear una clase llamada SimpleFraction que herede de Fraction y que implemente las operaciones de manera específica para fracciones simples:

c++Copy codeclass SimpleFraction : public Fraction {
private:
    int numerator;
    int denominator;

public:
    SimpleFraction(int num, int den) {
        numerator = num;
        denominator = den;
    }

    Fraction add(Fraction other) {
        SimpleFraction sf = dynamic_cast<SimpleFraction&>(other);
        int num = numerator * sf.denominator + sf.numerator * denominator;
        int den = denominator * sf.denominator;
        return SimpleFraction(num, den);
    }

    Fraction subtract(Fraction other) {
        SimpleFraction sf = dynamic_cast<SimpleFraction&>(other);
        int num = numerator * sf.denominator - sf.numerator * denominator;
        int den = denominator * sf.denominator;
        return SimpleFraction(num, den);
    }

    Fraction multiply(Fraction other) {
        SimpleFraction sf = dynamic_cast<SimpleFraction&>(other);
        int num = numerator * sf.numerator;
        int den = denominator * sf.denominator;
        return SimpleFraction(num, den);
    }

    Fraction divide(Fraction other) {
        SimpleFraction sf = dynamic_cast<SimpleFraction&>(other);
        int num = numerator * sf.denominator;
        int den = denominator * sf.numerator;
        return SimpleFraction(num, den);
    }

    void print() {