El lenguaje C

1
El lenguaje C

• A partir del lenguaje C
• Entorno de programación
• Visual C

2
El entorno de programación

• Solución
• Proyecto
• Hola mundo
• Compilar
• Build
• Link
• Debug

3
Nuevas palabras reservadas

• asm
• inline
• public
• virtual
• catch
• new
• template
• class

• operator
• this
• delete
• private
• throw
• friend
• protected
• try

4
Nueva forma para E/S

• Cualquier compilador de C, acepta C.
• La biblioteca iostream incluye los operadores cin
  y cout (include ltiostreamgt).
• Ejemplo
• char nombre
• int num2
• std cout ltlt "Introduzca el nombre del archivo
  " ltlt num ltlt " "
• std cin gtgt nombre

5
Declaración de variables

• En cualquier lugar del bloque
• for (double suma 0.0, int i 0 iltn i)
• suma ai
• Variables const para tamaño de vectores
• int main()
• const int SIZE 5
• char csSIZE

6
Punteros const

• Apuntan siempre a la misma dirección.
• El valor de la variable apuntada se puede
  modificar.
• Se declaran así
• char const nombre2 "Ramón"
• Un puntero a variable const no puede modificar el
  valor de esa variable.

7
Punteros a variables const

• Se declaran así
• const char nombre1 "Ramón"
• El código include ltstdio.hgt
• int main()
• const int i 2
• int p
• p i
• p 3
• printf("i d", i)

En ANSI C produce i 3, pero en C no compila.
8
Conversiones explícitas de tipo

• Ejemplo de cast (C y C)
• return (int) (x/y)
• C dispone de otra conversión
• y double(25)
• return int(x/y)

9
Sobrecarga de funciones

• Funciones distintas con mismo nombre.
• Distinto tipo y/o número de argumentos.
• No pueden diferir sólo en el tipo de retorno.
• Tampoco en que un argumento se pase por valor en
  una función y por referencia en la otra.

10
Parámetros con valores por defecto

• En C se pueden definir valores por defecto para
  todos o algunos argumentos formales.
• En la llamada, si no están los argumentos
  correspondientes, se toma el valor asignado.
• Los argumentos con valores por defecto deben
  estar al final de la lista.

11
Parámetros con valores por defecto

• Si se omite un argumento en la llamada, se deben
  omitir los siguientes en la lista.
• Ejemplo
• double modulo(double x, int n3)
• En C se puede invocar así
• v modulo(x, n)
• v modulo(x)

12
Variables de tipo referencia

• Se declaran con el operador ''.
• Deben ser inicializadas.
• Nombre alternativo para un objeto.
• Utilidades más importantes
• especificación de argumentos.
• especificación de tipos de retorno.
• sobrecarga de operadores.

13
Variables de tipo referencia

• int i 1
• int r i // r e i ahora se refieren al //
  mismo int
• int x r // x 1
• r 2 // i 2
• r // i se incrementa a 3
• Ningún operador opera sobre una referencia.
• El valor de una referencia no se puede modificar
  (siempre se referirá al mismo objeto).
• r es un apuntador al objeto denotado.

14
Los operadores new y delete

• Hasta ahora variables estáticas o automáticas.
• Con new y delete se crean y destruyen variables
  según la necesidad del programador.
• Una variable puede traspasar su bloque.
• Se puede crear cualquier tipo de variable con new
  y éste retorna un puntero de ese tipo.
• No se necesita conversión de tipo.

15
Clases, objetos y métodos

• Las clases se pueden ver como una generalización
  de las estructuras.
• Son verdaderos tipos de datos definidos por el
  usuario.
• Los objetos son las variables de una determinada
  clase.
• Los métodos pueden ser funciones u operadores.

16
Estructura de un programa

• En los archivos de cabecera (.h), por lo general,
  se declara la clase, con los prototipos de las
  funciones.
• En un archivo NombreClase.cpp de implementan los
  constructores, funciones y operadores.
• En un archivo main.cpp se define la función main.

17
Ejemplo complejo.h

• Se declaran los campos miembro privados
• class Complejo
• private
• double real
• double imag
• Los usuarios de la clase no podrán acceder con
  los operadores '.' y '-gt'.
• Las funciones miembro sí tienen acceso.

18
Ejemplo complejo.h

• Se declaran un conjunto de funciones y operadores
  miembro en la sección pública.
• Las tres primeras son los constructores
• public
• // Constructores
• Complejo()
• Complejo(double, double im0.0)
• Complejo(const Complejo)

19
Ejemplo complejo.h

• El siguiente grupo de funciones permite dar valor
  a los campos
• void setData()
• void setReal(double)
• O acceder a ellos
• double getReal()return real
• double getImag()return imag

20
Ejemplo complejo.h

• A continuación se declara la sobrecarga de los
  operadores aritméticos, comparación y asignación
  (operadores miembro).
• Complejo operator (const Complejo)
• Y luego la sobrecarga del operador de inserción
  en el flujo de salida (operador amigo)
• friend ostream operatorltlt (ostream const
  Complejo)

21
Sobrecarga de operadores

• // operador miembro sobrecargado
• Complejo Complejooperator (const Complejo
  a)
• Complejo suma
• suma.real real a.real
• suma.imag imag a.imag
• return suma

22
Sobrecarga de operadores

• Los operadores y funciones miembro se indican con
  el operador de resolución de alcance '' (no así
  los amigos).
• En una sentencia x y // x, y complejos
• se utiliza el operador sobrecargado.
• x es el argumento implícito.
• y se pasa explícitamente (como argumento formal
  a) .

23
Puntero this

• La sobrecarga de '' retorna (this) que
  representa al argumento implícito.
• Es una variable predefinida para todas las
  funciones (u operadores) miembro.
• Contiene la dirección del objeto correspondiente.
• Forma de referirse al objeto como tal (argumento
  implícito).

24
Constructores

• Se debe dar valor inicial a las variables
  miembro. Esto se hace a través de constructores.
• Se invocan automáticamente al crear un objeto de
  una clase.
• Permiten la encapsulación.
• Tienen el mismo nombre que la clase.
• No tienen valor de retorno (ni siquiera void).

25
Inicializadores

• Los constructores inicializan variables.
• C permite inicializar variables fuera del
  cuerpo de una función.
• C_CuentaC_Cuenta(double unSaldo, double
  unInteres)
• Saldo(unSaldo), Interes(unInteres) //
  inicializadores
• // En este caso el cuerpo del constructor
  está vacío
• Permiten definir variables miembro const.

26
Constructor por defecto

• Es un constructor que no necesita que se le pasen
  argumentos para inicializar las variables. Hay
  dos opciones
• No tiene argumentos.
• Tiene argumentos, pero todos ellos tienen
  asignado un valor por defecto en la declaración.
• Es necesario para declaraciones de la forma
• Complejo z y Complejo datos100

27
Constructor de oficio

• Lo crea el compilador de C si el programador no
  define ningún constructor.
• No tiene argumentos, es un constructor por
  defecto (no siempre un constructor por defecto es
  un constructor de oficio).
• Suelen ser cómodos, correctos y suficientes.

28
Constructor de copia

• Se utiliza cuando se debe crear un objeto a
  partir otro objeto de la misma clase.
• Tiene un único argumento que es una referencia
  constante a un objeto de la clase.
• El compilador también define un constructor de
  copia de oficio si el programador no lo hace (no
  funciona correctamente con punteros).

29
Constructores y operador de asignación ().

• z2 z1
• Se supone que c1 y c2 existían previamente.
• Se utiliza el operador de asignación que funciona
  como un constructor de copia.
• Se debe sobrecargar ''.

• Complejo z2 z1
• Se invoca al constructor de copia.
• El constructor de copia por defecto es una copia
  bit a bit.
• Se debe sobrecargar.

30
Destructores

• Es llamado cuando el objeto va a dejar de
  existir.
• Para un objeto local o automático definido en un
  bloque, el destructor es invocado cuando el
  programa llega al final del bloque.
• Los objetos creados con new deben ser
  explícitamente destruidos.

31
Clases y funciones friend

• Las funciones miembro (que acceden a las
  variables miembro) sólo pueden ser miembro de una
  única clase.
• Una función friend de una clase es una función
  que no pertenece a la clase, pero que tiene
  permiso para acceder a sus funciones y variables
  miembro.
• Una clase friend de otra tiene todas sus
  funciones amigas de esa segunda clase.

32
Herencia

• class ClaseDerivada public o private ClaseBase
• Un nombre redefinido oculta el nombre heredado.
• Hay algunos elementos de la clase base que no
  pueden ser heredados
• Constructores
• Destructores
• Funciones friend
• Funciones y datos estáticos de la clase
• Operador de asignación () sobrecargado

33
Constructores de clases derivadas

• Debe llamar al constructor de la clase base.
• Se debe especificar un inicializador base.
• Se puede omitir si la clase base cuenta con un
  constructor por defecto.
• C_CuentaJoven(const char unNombre, int laEdad,
  double unSaldo0.0, double unInteres0.0)
  C_Cuenta(unNombre, unSaldo, unInteres)

34
Herencia múltiple

• Una clase puede heredar de una (herencia simple)
  o más clases base (herencia múltiple).
• class CuentaEmpresarial
• public Cuenta, public Empresa

35
PolimorfismoFunciones Virtuales

• Son funciones distintas con el mismo nombre,
  declaradas virtual en la clase base (ligadura
  dinámica).
• Funciones convencionales se invocan de acuerdo al
  tipo del objeto (en tiempo de compilación).
• Con funciones virtuales se resuelve en tiempo de
  ejecución el problema de la asignación.

36
Funciones virtuales

• class A
• public
• virtual void mostrar()
• class B public A
• public
• void mostrar()

A objA B objB A ptrA1 A ptrA2 ptrA1
objA ptrA2 objB ptrA2-gtmostrar()
37
Funciones virtuales puras

• La función virtual de la clase base debe
  declararse a pesar de no ser utilizada.
• En este caso no es necesario definirla.
• Se declara como función virtual pura
• virtual funcion1() const 0
• No se pueden definir objetos de esa clase.
• Se pueden definir punteros a esa clase.

38
Clases abstractas

• Contienen una o más funciones virtuales puras.
• Si una clase derivada no define una función
  virtual pura, la hereda como pura y por lo tanto
  también es abstracta.
• Una clase que define todas las funciones
  virtuales es una clase concreta.

39
Entrada/Salida

• Stream o flujo dispositivo que produce o consume
  información.
• Flujos estándares
• cin entrada estándar (teclado).
• cout salida estándar (pantalla).
• cerr salida de mensajes de error (pantalla).
• Las clases istream, ostream e iostream son clases
  que heredan de ios.

40
Manipuladores

• Variables y/o métodos miembro que controlan el
  formato.
• Pueden tener argumentos (iomanip) o no
  (iostream).
• Sólo afectan al flujo al que se aplican.
• No guardan la configuración anterior (como sí lo
  hacen los indicadores).

41
Manipuladores

• Ejemplos
• endl se imprime un \n y se vacía el buffer de
  salida.
• flush se vacía el buffer de salida.
• setw(int w) establece la anchura mínima de
  campo.
• cout ltlt hex ltlt 100
• cout ltlt setw(10) ltlt matij ltlt endl
• El efecto permanece hasta que se cambia por otro
  manipulador.

42
E/S de archivos

• En la biblioteca fstream se definen las clases
  ifstream, ofstream y fstream, que derivan de
  istream y ostream y a su vez de la clase ios.
• Ejemplos
• fstream archivo
• archivo.open("datos.dat", iosin)
• ifstream archivo("datos.dat")

43
Excepciones

• Parte del código puede no ejecutarse por algún
  error inesperado.
• Si ocurre una excepción se interrumpe la normal
  ejecución del código.
• Se pueden manejar realizando una acción adecuada
  para dejar al sistema en un estado estable.

44
Excepciones en C

• Se separa el código para el caso en que ocurre
  una situación excepcional y el que no
• try identifica un bloque de código en el cual
  puede surgir una excepción.
• throw causa que se origine una excepción.
• catch identifica el bloque de código en el cual
  la excepción se maneja.

45
Excepciones en C

• int main(void)
• int counts 34, 54, 0, 27, 0, 10, 0
• int time 60 // One hour in minutes
• for(int i 0 i lt sizeof counts /sizeof
  counts0 i)
• try
• cout ltlt endl ltlt "Hour " ltlt i1
• if(countsi 0)
• throw "Zero count - calculation not
  possible."
• cout ltlt " minutes per item "
• ltlt static_castltdoublegt(time)/countsi
• catch(const char aMessage)
• cout ltlt endl ltlt aMessage ltlt endl
• return 0

46
Excepciones en C

• Cuando la excepción es lanzada (throw) la
  secuencia de ejecución continúa con el bloque
  catch.
• Después de ejecutarse el código del bloque catch
  la ejecución continúa con la siguiente iteración
  del for.
• El compilador considera los bloques try y catch
  como una única unidad.