Programación en c++
Upcoming SlideShare
Loading in...5
×
 

Programación en c++

on

  • 2,097 views

Introducción a la programación en c++. ...

Introducción a la programación en c++.

Contenido:
-Tipos de datos
-Entrada y salida por consola
-String
-Preprocesador
-Operadores y sentencias de control
-Punteros
-Arrays
-Cadenas de caracteres
-Memoria dinámica
-Introducción a la POO en c++
-Referencias

Statistics

Views

Total Views
2,097
Views on SlideShare
2,097
Embed Views
0

Actions

Likes
0
Downloads
139
Comments
0

0 Embeds 0

No embeds

Accessibility

Categories

Upload Details

Uploaded via as Microsoft PowerPoint

Usage Rights

CC Attribution-NonCommercial LicenseCC Attribution-NonCommercial License

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

Programación en c++ Programación en c++ Presentation Transcript

  • Programación en c++
    Ander Mijangos
    Universidad de Deusto
    Octubre de 2010
  • Aspectos generales de c++
    Es una ampliación de c para dar soporte a la POO
    El tercer lenguaje de programación más usado (octubre de 2010)1
    Se usa para SO, SGBD, sistemas de Tiempo Real…
    Case sensitive
    Las variables sólo existen en su ámbito {…}
    Los programas se organizan en dos ficheros:
    .h: archivos de cabecera
    .cpp: archivos de código fuente (que incluyen el .h)
    1http://www.tiobe.com/index.php/content/paperinfo/tpci/index.html
  • ¡Hola Mundo!
    #include <iostream>
    usingnamespacestd;
    voidmain()
    {
    cout << "¡Hola mundo!" << endl;
    }
  • Tipos de datos básicos
    Enteros
    (signed/unsigned) (long/short) int
    Char (carácter y mucho más)
    (unsigned) char //1 byte
    Coma flotante
    float
    double //64 bits
    Booleano
    bool
  • Más tipos de datos (I)
    Definidos por el programador
    struct
    class
    enum
    union
    Arrays y punteros
    []
    *
  • Más tipos de datos (II)
    sizeof
    sizeof(TIPO);
    typedef
    typedef TIPO_ANTIGUO TIPO_NUEVO;
    Constantes
    1, true, 0x01 (hexadecimal), 0.1, ‘a’…
    Declaración e inicialización
    unsignedint contador;
    int a = 5, b = 5, c;
  • Entrada y salida por consola
    Hay que incluir la STL y especificar el namespace
    #include <iostream>
    usingnamespacestd;
    Sentencias:
    cout << "Introduzca el precio: ";
    cin >> precio;
  • String
    Es una clase definida en la STL
    #include <string>
    Declaración e inicialización:
    stringnombreUsuario = “Ander”;
    Realmente se trata de una cadena de caracteres que finaliza en ‘’
    Algunas funciones miembro:
    size();
  • Preprocesador
    Include
    #include <FICHERO>
    Define
    #define SIMBOLO [VALOR]
    Ifdef
    #if(n)def SIMBOLO

    #else

    #endif
    Los archivos de cabecera se suelen asegurar ante inclusiones múltiples:
    #ifndef NOMBRE_DE_FICHERO_H
    #define NOMBRE_DE_FICHERO_H

    #endif
  • Comentarios
    De bloque:
    /* … */
    De línea:
    // …
  • Typecast
    Convierte un tipo de datos en otro
    int i = 1000;
    char c = (char)i;
  • Operadores (I)
    Aritméticos
    Binarios
    +
    -
    *
    /
    % (módulo)
    Unarios
    -
    ++
    --
    Aritméticos y de asignación
    +=
    -=
    *=
    /=
    %=
    Nota: con pre, primero se ejecuta el operador; con post, primero se evalúa la expresión y al final se ejecuta el operador.
  • Operadores (II)
    Operadores relacionales
    ==
    !=
    <
    >
    <=
    >=
    Operadores booleanos
    && (AND)
    || (OR)
    ! (NOT)
    Nota: valor != 0 -> true
    valor == 0 -> false
  • Precedencia de operadores
    (De arriba a bajo y de izquierda a derecha)
  • Control (I)
    if
    if (EXPRESION)
    {
    SENTENCIA(S);
    }
    else
    {
    SENTENCIA(S);
    }
    switch
    switch (EXPRESION)
    {
    case VALOR1:
    SENTENCIAS;
    break;
    case VALOR2:
    SENTENCIAS;
    break;
    case VALOR3:
    case VALOR4:
    SENTENCIAS;
    break;
    default:
    SENTENCIAS;
    }
  • Control (II)
    Operador condicional ?
    EXPRESION ? EXPRESION_TRUE : EXPRESION_FALSE
    while
    while(EXPRESION)
    {
    SENTENCIA(S);
    }
    do while
    do
    {
    SENTENCIA(S);
    }
    while(EXPRESION);
    for
    for(EXPRESION(ES)_INICIAL(ES); EXPRESION; EXPRESION(ES)_ITERATIVA(S))
    {
    SENTENCIA(S);
    }
    Break: acaba la sentencia condicional o repetitiva actual
    Continue: salta hasta la terminación de la iteración actual
  • Funciones
    Formato
    TIPO_RETORNO IDENTIFICADOR( [PARAMETRO(S)] )
    {
    [return VALOR;]
    }
    Se puede declarar la función antes de implementarla
    Al llegar a un return la función finaliza
  • Punteros (I)
    Es un tipo de datos
    Generalmente tiene 32 bits
    Interpretación: representa una dirección de memoria
    Formato:
    int*punteroEntero;
    Indirección (acceso al contenido referenciado):
    *punteroEntero= 1000;
    Nunca se asigna directamente un valor a un puntero
    Obtener la dirección de una variable:
    &miVariable
  • Punteros (II)
    El SO reserva memoria:
    Al declarar una variable (memoria estática):
    int i;
    A petición del programador (memoria dinámica)
    (explicado posteriormente)
    Utilidad de los punteros:
    Modificar una variable en una función
  • Arrays
    Conjuntos de datos consecutivos
    Declaración (obligatorio que sea un valor constante, si no, ver memoria dinámica):
    intarrayEnteros[20];
    Inicialización:
    intarrayEnteros[2] = {5, 9};
    intarrayEnteros[] = {5, 9};
    Acceder a los datos del array:
    arrayEnteros[0] = 0;
    arrayEnteros[1] = 0;
    Conocer el tamaño de un array:
    sizeof(arrayEnteros) / sizeof(int);
    Arrays multidimensionales:
    intarrayEntero2D[2][3] = {{1, 2, 3}, {1, 2, 3}};
    Nota: un array de N elementos tiene los elementos de 0 a N-1
  • Arrays y punteros
    El identificador de un array es un puntero constante que apunta a la dirección de memoria del primer elemento del array.
    Un puntero puede usarse con [], sumando sobre la dirección inicial bytes según el tipo del puntero.
    Pasar un array como parámetro:
    funcion (array, 2);
    void funcion1(intarray[], inttamanio) {…}
    void funcion2(int* puntero, inttamanio) {…}
    Sizeof funciona con el array entero, con un puntero devuelve el tamaño del puntero (32 bits)
  • Cadenas de caracteres
    Son arrays de tipo char
    constchar* cadena = “Hola mundo”;
    En <string.h> hay muchas funciones
    El tipo de datos string encapsula todo esto
  • Memoria dinámica
    Reservar y liberar memoria:
    int* punteroEntero = new int();
    deletepunteroEntero;
    En el caso de arrays:
    int* puntero = new int[10];
    delete [] puntero;
    Un new obliga a usar un delete en algún momento.
    Utilidad: evitar perder la información cuando la variable muere
    Función dinámica: función que devuelve una dirección de memoria
  • Estructuras
    Especificación:
    struct TIPO
    {
    TIPO_0 dato0;
    TIPO_1 dato1;

    TIPO_NdatoN;
    };
    Uso (.):
    ESTRUCTURA e;
    e.TIPO_0;
    Uso con un puntero a la estructura (->):
    ESTRUCTURA* pE;
    pE->TIPO_0;
  • POO: Clases
    Declaración:
    class Fecha
    {
    unsignedintanyo;
    unsignedint mes;
    unsignedintdia;
    };
    Una clase tiene:
    Datos miembro = atributos
    Funciones miembro = métodos
    Clases y objetos
    Clase: declaración del tipo de datos
    Objeto: variable de dicho tipo de datos (instanciación)
  • POO: Encapsulación
    Programación Orientada a Objetos
    Consta de:
    Clases
    Encapsulación
    Encapsulación: determina si se puede acceder a los atributos y métodos desde fuera de la clase (programa principal).
    public: son accesibles desde fuera
    private: sólo son accesibles desde la clase (o algún método público que lo manipule -> más control)
    Generalmente: atributos privados y métodos públicos
    Se usan getters y setters para manipular los atributos
  • POO: Constructores y destructores
    Constructor: método especial que se ejecuta al instanciar un objeto.
    No devuelve nada
    Se llama igual que la clase, con () por ser método
    Se usa para inicializar los atributos
    Hay un constructor por defecto
    Destructor: método especial que se ejecuta al eliminar un objeto de memoria.
    No devuelve nada
    Se llama igual que la clase, precedido de ~ y con () por ser método
    Se usa para liberar memoria dinámica, cerrar ficheros…
    Hay un destructor por defecto
    Pueden encapsularse como privados, pero en general serán públicos
  • POO: Sobrecarga
    Dos métodos pueden llamarse igual si cambian:
    El número de parámetros
    El tipo de los parámetros
    Se puede sobrecargar el constructor
    No tiene sentido sobrecargar el destructor
    Un constructor con parámetros hace que el constructor por defecto se pierda (obliga a pasar parámetros en la instanciación)
  • Constructor de copia y operador de asignación
    Constructor de copia
    Se llama en cuatro casos:
    Al crear un objeto como copia de otro
    ArrayInt ai2 = ai;
    ArrayInt ai2(ai1);
    Al llamar a una función pasándole por valor un objeto
    Al hacer return de un objeto
    Cadena (const Cadena& c)
    Operador de asignación
    Se llama al hacer una asignación
    Cadena& operator= (const cadena& c) return *this
  • POO: Operador ::
    Generalmente, la clase se declara en un fichero .h y los métodos se implementan en un .cpp.
    Operador de resolución de ámbito:
    Fecha::Fecha()
    Llamada a un método:
    objeto.metodo(parámetros);
  • POO: Puntero this
    En los métodos no se pasa el objeto como parámetro
    El compilador añade automáticamente:
    boolesBisiesto(Fecha* constthis)
    ‘This’ es un puntero al objeto desde el que se llama a la función.
    Su uso no es obligatorio salvo:
    Para distinguir el atributo de otro parámetro llamado igual (this->atributo)
    Para referenciar al objeto en sí
    Para que el objeto referenciado también sea constante, al final de la cabecera del método se escribe ‘const’
  • POO: Miembros estáticos
    Atributo estático: cada objeto no tiene su propio valor para el atributo sino que es compartido.
    Para acceder desde el programa principal:
    Fecha::Meses
    Se inicializa en el .cpp donde se implementan los métodos de la clase.
    Método estático: no recibe el objeto por parámetro (no tiene this).
    Para acceder desde el programa principal:
    Fecha::esBisiesto(2006)
  • Punteros a funciones
    Declaración del puntero:
    int (*punteroAIntFuncionIntInt) (int, int);
    Función que se va a referenciar:
    intfuncion(int, int)
    {
    }
    Asignación de la dirección:
    punteroAIntFuncionIntInt = &funcion; //& opcional
    Llamada a la función desde el puntero:
    funcion(1,3)
    punteroAIntFuncionIntInt(1,3); // Hacen lo mismo
  • Referencias
    Permiten modificar una variable en una función sin tratar con punteros
    CON PUNTEROS:
    voidfuncion(int* pi)
    {
    *pi= 2;
    }
    voidmain()
    {
    int i = 1;
    funcion(&i);
    }
    CON REFERENCIAS:
    voidfuncion(int& ri)
    {
    ri = 2;
    }
    voidmain()
    {
    int i = 1;
    funcion(i);
    }
    NORMAL (el valor no
    se modifica):
    voidfuncion(int i)
    {
    i= 2;
    }
    voidmain()
    {
    int i = 1;
    funcion(i);
    }
  • Esta presentación está basada en los apuntes tomados en la asignatura de Laboratorio de Informática I impartida por Jesús Sanz e IkerJamardo, en la facultad de Ingeniería de la Universidad de Deusto.
    Esta presentación está publicada bajo la licencia CreativeCommons Reconocimiento – No Comercial 3.0 España
    http://creativecommons.org/licenses/by-nc/3.0/es/
    AnderMijangos
    Universidad de Deusto
    andermijan (arroba) gmail (punto) com
    http://www.slideshare.net/andermijan