Scribd Logo
Cargar

¡Te damos la bienvenida a Scribd!

  • 1K vistas

    Introduccion A POO en C++

    Cargado por

    skilltik
    El documento describe los conceptos fundamentales de la programación orientada a objetos con C++. Explica las diferencias entre el paradigma de programación estructurada y el paradigma orientado a objetos, las características clave de este último como la abstracción, encapsulamiento, jerarquía y polimorfismo. También cubre temas como la identificación de clases, la declaración y uso de clases en C++, constructores, destructores y el concepto de encapsulamiento.

    Copyright:

    Attribution Non-Commercial (BY-NC)
    Descargue como PPT, PDF, TXT o lea en línea desde Scribd

    Introduccion A POO en C++

    Cargado por

    skilltik
    1K vistas37 páginas
    El documento describe los conceptos fundamentales de la programación orientada a objetos con C++. Explica las diferencias entre el paradigma de programación estructurada y el paradigma orientado a objetos, las características clave de este último como la abstracción, encapsulamiento, jerarquía y polimorfismo. También cubre temas como la identificación de clases, la declaración y uso de clases en C++, constructores, destructores y el concepto de encapsulamiento.

    Descripción original:

    Diapositivas de introduccion a la programacion orientada a objetos en c++

    Título original

    Introduccion a POO en c++

    Derechos de autor

    © Attribution Non-Commercial (BY-NC)

    Formatos disponibles

    PPT, PDF, TXT o lea en línea desde Scribd

    ¿Le pareció útil este documento?

    ¿Este contenido es inapropiado?

    El documento describe los conceptos fundamentales de la programación orientada a objetos con C++. Explica las diferencias entre el paradigma de programación estructurada y el paradigma orientado a objetos, las características clave de este último como la abstracción, encapsulamiento, jerarquía y polimorfismo. También cubre temas como la identificación de clases, la declaración y uso de clases en C++, constructores, destructores y el concepto de encapsulamiento.

    Copyright:

    Attribution Non-Commercial (BY-NC)
    Descargue como PPT, PDF, TXT o lea en línea desde Scribd
    Descargar como ppt, pdf o txt
    1K vistas37 páginas

    Introduccion A POO en C++

    Cargado por

    skilltik
    El documento describe los conceptos fundamentales de la programación orientada a objetos con C++. Explica las diferencias entre el paradigma de programación estructurada y el paradigma orientado a objetos, las características clave de este último como la abstracción, encapsulamiento, jerarquía y polimorfismo. También cubre temas como la identificación de clases, la declaración y uso de clases en C++, constructores, destructores y el concepto de encapsulamiento.

    Copyright:

    Attribution Non-Commercial (BY-NC)
    Descargue como PPT, PDF, TXT o lea en línea desde Scribd
    Descargar como ppt, pdf o txt
    Está en la página 1de 37

    Programación Orientada a Objetos con C++

    El modelo de Objetos
    Comparación entre el paradigmas

    Paradigma de la Programación Modular y Estructurada (PME)


    Programación Modular
    y Estructurada (PME)

    Estructuras de datos + Algoritmos = Programas

    Paradigma de Objetos (POO)


    Programación
    Orientada a Objetos (POO)

    Objetos = Datos+ Funcionalidades


    Por qué el modelo de objetos?
    Por qué el modelo de la POO?

    • El software es complejo en forma innata y excede con frecuencia la


    capacidad intelectual humana.

    • Los desarrolladores de software


    intentan crear ilusión de sencillez.

    • La complejidad
    se puede expresar
    con jerarquías.

    • Los sistemas complejos


    a menudo evolucionan
    de formas
    intermedias estables.
    Por qué el modelo de objetos?

    Por qué el modelo de la POO?

    • La cognición humana tiene limitaciones.

    • Es mejor ver a al complejidad de un sistema como una interacción de


    entidades u objetos.

    • El diseño orientado a objetos define un notación y un proceso para


    construir sistemas de software complejos.

    • Para un experto en el dominio de un problema pero lego en Ingeniería


    de Software o Sistemas, es más comprensible el modelo de objetos.
    Características del modelo de objetos

    • Abstracción

    • Encapsulamiento

    • Modularidad

    • Jerarquía

    • Polimorfismo
    Características del modelo de objetos

    • Abstracción

    • Encapsulamiento

    • Modularidad

    • Jerarquía

    • Polimorfismo
    Características del modelo de objetos

    • Abstracción

    • Encapsulamiento

    • Modularidad

    • Jerarquía

    • Polimorfismo
    Características del modelo de objetos

    • Abstracción

    • Encapsulamiento

    • Modularidad

    • Jerarquía

    • Polimorfismo
    Programación Orientada a Objetos (POO)

    La POO es un método de implementación en el cual el

    programa se organiza como colecciones cooperativas de

    objetos.

    Cada objeto representa una instancia de alguna clase. Estas

    clases son a su vez miembros de una jerarquía.

    (Grady Booch. Análisis y Diseño Orientado a Objetos. Adison Weslwey )


    Clases

    • ¿Qué son las clases?

    • ¿Cómo identificarlas en un problema?

    • Cómo se aplican en C++ los fundamentos


    del Modelo de Objetos?
    Clases
    El concepto de clase
    Identificar clases en
    un problema de programación.

    Análisis preliminar del problema

    • Defina claramente el problema.

    • Efectúe un análisis de la información disponible (datos)


    y de los requerimientos (resultados).

    • Investigue y plantee las relaciones entre datos y


    resultados sumergiéndose en el dominio del problema.
    Identificar clases en
    un problema de programación.

    Técnica de identificación de clases

    • Buscar entidades o sustantivos en la definición el


    problema

    • Descarte las entidades obviamente inservibles

    • Seleccione aquellas entidades que incluyen claramente la

    información disponible y los resultados esperados.

    • Haga un refinamiento final y observe si las clases


    propuestas resumen una abstracción del dominio del
    problema a resolver.

    • No modele al usuario
    Asignar responsabilidades

    Para definir las responsabilidades de una clase,


    el programador debe establecer:
    • Qué información debe conocer (datos o atributos)
    • Qué debe saber hacer (funciones o métodos)

    miClase
    Dato 1
    Dato 2
    Dato 3
    ...
    Método 1
    Método 2
    ...
    Asignar responsabilidades

    Atributos
    • Identifique los datos y resultados relacionados con la clase propuesta
    • Agregue los elementos necesarios para los cálculos o para acceder a los
    datos.

    Funcionalidades
    • Inicializar los datos.
    • Algoritmos de cálculo para determinar los resultados.
    • Devolver o informar estos resultados.
    • Ajuste el conjunto de atributos y funcionalidades para evitar redundancia
    de información.
    Estructura de una clase en C++
    // Declaración de una clase
    class nueva_clase
    { etiqueta_de_permisos 1: Declarar un clase es
    miembro1; definir un nuevo tipo de
    miembro2; datos
    etiqueta_de_permisos 2:
    miembro3;
    miembro4;
    miembro5;
    . . .
    };
    // Instanciación de un objeto de una clase
    int main()
    { . . . Instanciar un objeto de una clase
    nueva_clase c; implica declarar una variable
    . . . usando esa clase como tipo
    }
    Declaración de clases. Ejemplo.
    class CRectangulo Nombre de la clase
    { private:
    float x, y, area; Atributos
    public:
    void fijar_valores (float,float);
    void calcular_area( );
    Métodos
    float ver_area( ) {return area;};
    } ;

    void CRectangulo::fijar_valores (float a,float b)


    { x=a; y=b; };
    Implementación
    de métodos
    void CRectangulo::calcular_area ( )
    { area= x*y; } ;
    Declaración, instanciación de clases
    y acceso a los miembros

    …
    Se crea la variable objeto
    int main()
    o instancia rect
    {
    CRectangulo rect; Se envía un mensaje al objeto
    rect.fijar_valores(4,5); invocando a un método
    rect.calcular_area();
    cout<<“Rectangulo de 4x5”<<endl;
    cout<<“Area=“<<rect.ver_area()<<endl;
    return 0;
    }
    Declaración, instanciación de clases
    y acceso a los métodos

    // el mismo ejemplo, pero más general


    . . .

    int main()
    { float a,b;
    CRectangulo rect;
    cout<<“Rectangulo de dimensiones axb”<<endl;;
    cout<<“Ingrese altura a=“; cin>>a;
    cout<<“Ingrese base b=“; cin>>b;
    rect.fijar_valores(a,b);
    rect.calcular_area( );
    cout<<“Rectangulo de “<<a”<<“x”<<“b\n”;
    cout<<“Area=“<<rect.ver_area()<<endl;
    return 0;
    }
    Clases en C++.
    Varias instancias de la misma clase

    int main()
    {
    CRectangulo rect1, rect2;
    rect1.fijar_valores(4,5);
    rect1.calcular_area( );
    cout<<“Area=“<<rect1.ver_area()<<endl;
    rect2.fijar_valores(10,12);
    rect2.calcular_area( );
    cout<<“Area=“<<rect2.ver_area()<<endl;
    }
    Objetos, clases e instancias

    Objetos, clases e instancias


    CRectangulo // clase o tipo de objeto
    CRectangulo rect; // instancia u objeto de la clase CRectangulo
    CRrectangulo r1, r2, r3; // tres instancias de la clase CRectangulo

    Envío de mensajes a un objeto


    rect1.fijar_valores(dato1,dato2);
    rect1.calcular_area();
    cout<<"Area del rectángulo="<<rect1.ver_area();
    Encapsulamiento
    class CRectangulo
    { private:
    float x, y, area;
    public:
    void calcular_area( );
    } ;
    . . .
    int main()
    { CRectangulo rect1;
    rect1.x=4; rect.y=10 // error
    cout<<“Area=“<<rect1.area<<endl; //error:
    // los miembros privados son inaccesibles
    // fuera de la clase
    . . .
    }
    Encapsulamiento

    class CRectangulo
    { private:
    float x, y, area;
    public:
    void fijar_valores (float,float);
    void calcular_area( );
    float ver_area( ) {return area;};
    } ;

    Por qué encapsular (proteger) las propiedades o


    atributos de los objetos?
    • Independencia de la clase
    • Modularidad y reutilización
    • Depuración de errores
    Una forma de romper el encapsulamiento:
    funciones amigas
    class CRectangulo
    { private:
    float x, y, area;
    public:
    CRectangulo(float px,float py) {x=px,y=py;};

    void calcular_area( );
    float ver_area( ) {return area;};
    friend void cambio_h(CRectangulo &r, float h)
    } ;

    void cambio_h(CRectangulo &r, float h)


    { r.y= h;};

    void CRectangulo::calcular_area( )
    { area=x*y;};
    Ejemplos

    Proponer abstracciones mediante clases para cada uno de los


    problemas de programación siguientes usando al sintaxis de C++

    •Escriba un programa C++ que modele una lata de gaseosa para


    calcular su volumen. El radio se ingresa como dato.
    •Escriba un programa C++ que calcule las raíces o soluciones de una
    ecuación cuadrática del tipo ax2+ bx + c=0, siendo que el usuario del
    programa ingresa como datos los coeficientes a, b y c.
    e)Diseñe un programa C++ que genere y muestre en modo consola
    50 datos numéricos generados al azar entre 1 y 5000. Debe
    obtener como salida los siguientes parámetros estadísticos: a)
    desviación estándar de la lista; b) la media; c) los 2 mayores y d) el
    menor de la lista.
    Constructores
    class CRectangulo
    { private:
    int x, y, area;
    public:
    CRectangulo (int, int);
    void calcular_area( ) {area = x*y;};
    int ver_area ( ) {return area;};
    };

    CRectangulo::CRectangulo (int a,int b)


    { x=a; y=b;
    };
    Sobrecarga de Constructores
    Constructor de copia

    class CRectangulo
    { private:
    int x, y, area;
    public:
    CRectangulo (int, int);
    CRectangulo (const Crectangulo &r);
    void calcular_area( ) {area = x*y;};
    int ver_area ( ) {return area;};
    };

    void CRectangulo::CRectangulo (int a,int b)


    { x=a; y=b;
    };

    int CRectangulo::CRectangulo(const CRectangulo &r)


    { x=r.x; y= r.y;
    } ;
    Sobrecarga de Constructores
    Constructor de copia

    …
    int main()
    {
    CRectangulo r1(10,4), r2(10,8), r3(r1)
    Crectangulo r4; /*error, si se definen
    constructores, el constructor implícito no
    puede emplearse*/

    ...

    }
    Destructores

    class CRectangulo
    { private:
    int x, y, area;
    public:
    CRectangulo (int, int);
    CRectangulo (const rectangulo& r);
    ~CRrectangulo(){cout<<”se destruye el objeto”;};
    void calcular_area( ) {area = x*y;};
    int ver_area ( ) {return area;};
    };
    Destructores

    class CRectangulo
    { private:
    int *x, *y;
    public:
    CRectangulo (int, int);
    ~CRrectangulo( );
    void calcular_area( ) {area = (*x)*(*y);};
    int ver_area ( ) {return area;};
    };
    Destructores
    CRectangulo::CRectangulo (int a, int b)
    { x= new int; y= new int;
    *x= a; *y= b;
    };

    CRectangulo:: ~CRrectangulo( )
    { delete x;
    delete y;
    };
    …
    int main()
    { CRectangulo r(10,4);
    r.calcular_area();
    cout<<“Area=“<<r.ver_area();
    return 0;
    }
    Punteros a objetos
    class CRectangulo
    { private:
    int x, y, area;
    public:
    CRectangulo (int, int);

    void calcular_area( ) {area = x*y;};


    int ver_area ( ) {return area;};
    };

    void CRectangulo::CRectangulo (int a,int b)


    { x=a; y=b;
    };
    Punteros a objetos

    …
    int main()
    { CRectangulo r1(10,8);
    CRectangulo *pr;
    pr= &r1;
    pr->calcular_area();
    cout<<“Area=“<< pr->ver_area() <<endl;
    return 0;
    }
    El puntero this

    C++ dispone en toda clase de un puntero llamado


    this que contiene la dirección de memoria del
    objeto que se ha instanciado.
    class CRectangulo
    { private:
    int x, y, area;
    public:
    CRectangulo (int a,int b){x=a; y=b;};
    void calcular_area( ) {area = x*y;};
    int ver_area ( ) {return this->area;};
    CRectangulo &duplicar( );
    };

    Crectangulo &CRectangulo::duplicar( )
    { x=2*x; y=2*y; area=2*area;
    return *this;};
    El puntero this

    C++ dispone en toda clase de un puntero llamado


    this que contiene la dirección de memoria del
    objeto que se ha instanciado.

    . . .
    int main(int argc, char *argv[])
    { CRectangulo r(10,4);
    r.calcular_area();
    r.duplicar();
    cout<<“Area=“<<r.ver_area();
    return 0;
    }
    Area=80
    El puntero this

    //Ejemplo para el operador +

    T& T::funcion(parámetros)
    { // acciones
    . . .
    return *this;
    }
    Ejemplos

    a) Escriba un programa C++ que calcule el área y circunferencia de un


    círculo cuyo radio se ingresa como dato.

    b) Escriba un programa C++ que calcule las raíces o soluciones de


    una ecuación cuadrática del tipo ax2+ bx + c=0, siendo que el
    usuario del programa ingresa como datos los coeficientes a, b y c.
    Suponga que los datos corresponden a ecuaciones de raíces
    reales.

    f) Exhibir en pantalla 50 datos numéricos generados al azar entre


    1 y 5000. Obtener como salida los siguientes parámetros
    estadísticos: a) desviación standard de la lista; b) la media;
    c) los 2 mayores y d) el menor de la lista.

    También podría gustarte