Curso de Programación Estructurada Maestría en Robótica y Manufactura Avanzada Curso de Programación Estructurada Dra. L. Abril Torres Méndez Saltillo Lenguaje C++ Periodo: Sept-Dic, 2010.

Introducción C++ soporta los paradigmas de programación estructurada y la programación orientada a objetos (POO). Programación estructurada en C++ Programa principal o main. Módulos: contienen tipos de datos y funciones encapsulados en diferentes archivos, que pueden ser usados en el main y en otros módulos. Implementación mediante el uso de variables, asignaciones y estructuras de control, además llamadas a otras funciones. Programación Orientada a Objetos en C++

Estructura de un programa en C++

Funciones de cabeceras Definiciones de tipos o clases Prototipos de funciones

Variables y constantes Una variable u objeto es una entidad que representa a una celda de memoria, que tiene un tipo y cuyos valores pueden cambiar. La constante también representa a una celda de memoria pero el valor que se almacena inicialmente no puede ser modificado. Ambas se usan para representar la información que se necesita en el programa. Las variables u objetos y las constantes se deben declarar antes de su uso. Un tipo de datos determina el conjunto de valores que puede tomar una variable, objeto o constante de ese tipo y las operaciones que se pueden realizar con ellas.

Concepto de ámbito El ámbito de una variable está formado por el conjunto de instrucciones en que dicha variable se puede usar. Igual para constantes y objetos. En C++ existen, principalmente, tres tipos de ámbitos: Global (o de programa). Se declaran antes del programa principal Local (o de función). No se pueden usar fuera de la función. Cuando la función termina se eliminan de la memoria. De bloque. Sólo se pueden usar en el bloque delimitado por { }. Para variables con asignación de memoria estática, el ámbito se extiende desde la declaración hasta el final del bloque.

Ámbito global

Ámbito local

Ámbito de bloque

Inicialización Constantes. En el momento de su declaración const int x=2; Variables. En su declaración o después. int y=2; int z; .... z=4; Objetos. Cuando se declaran y de forma implícita. clase objeto; //se inicia por default clase objeto(1,2); //se inicia con estos valores

Tipos de datos predefinidos Enteros (int), ej. 2, 3, -7 Coma flotante (float y double), ej. 3.2, 6.0, -2.3 Rango float: 4 bytes, min: 1.175494351 E – 38, max: 3.402823466 E+38. Rango double: 8 bytes, 2.2250738585072014 E–308 a 1.7976931348623158 E + 308. Carácter (char), ej. ‘a’, ‘b’ Booleano (bool), true, false Cadena (string), “carro”, “escuela” Tipo indefinido (void), void no tiene valores, se usa para indicar que una función no devuelve valores y para punteros a tipos indefinidos

Arreglos Conjunto de datos del mismo tipo Declaración: Una dimensión: tipo id[num] Dos dimensiones: tipo id [num][num] Declaración: int enteros[3]; // contiene tres elementos enteros Elementos del arreglo: enteros[0], enteros[1], enteros[2]

Inicialización de arreglos Inicialización individual: entero[0]=2; entero[1]=4; entero[2]=6; Declaración/inicialización mediante lista: int entero[3]={2,4,6}; Inicialización individual con un for: For(int i=0;i<2;i++) entero[i]=2; //se inician los tres elementos con el mismo valor

Manejo de variables (compilador y enlazador) Para manejar las variables definidas en un programa, el compilador y el enlazador asignan un bloque específico de la memoria dentro de la computadora para guardar el valor de la variable. Ej., el tamaño de la variable de tipo entero (int) es de 4 bytes en PC’s modernas. En C/C++, el tamaño de un tipo de variable no tiene porqué ser el mismo en todas las PCs. En C/C++ se manejan diferentes tipos de variables enteras, están los enteros largos (long int) y los enteros cortos (short int).

Tamaño de variables tipo entero #include <stdio.h> int main() { printf("El tamaño de short (entero corto), es: %d\n", sizeof(short)); printf("El tamaño de int (entero), es: %d\n", sizeof(int)); printf("El tamaño de long (entero largo), es: %d\n", sizeof(long)); }

Declaración de variable Al declarar una variable le informamos al compilador 2 cosas: el nombre y el tipo de la variable. Ejemplo: int k; El compilador al encontrar la palabra “int” reserva 4 bytes de memoria para almacenar el valor entero. También construye una tabla de símbolos en la que agrega el símbolo k y la correspondiente dirección de la memoria en donde esos 4 bytes se reservaron.

Asignación de valor a una variable Cuando escribimos: k=2; al momento de ejecución del programa se encontrará un 2 colocado en el área de memoria reservada para guardar el valor de k. Tiene entonces sentido decir que hay dos valores asociados con la variable k, uno es el valor del entero alojado ahí (2 en el ejemplo) y el otro el valor de la localidad de memoria donde se ha guardado, osea la dirección de k.

Asignación de valores entre variables int j, k; k = 2; j = 7; <-- línea 1 k = j; <-- línea 2 En la línea 1, el compilador interpreta la j como una dirección de la variable j y copia el valor 7 a esa dirección. En la línea 2, j es interpretada como una dirección de memoria y se hace referencia al valor alojado en ella (7 en este caso) y es copiado a la dirección de k.

Asignación de direcciones de variables Si por alguna razón queremos almacener en una variable una dirección, el tipo de variable es conocida como VARIABLE APUNTADOR. A la variable apuntador se le da un tipo, el cual, hace referencia al tipo de dato que se encuentra guardado en la dirección que alojaremos en nuestro apuntador.

Punteros int* puntero; puntero es el nombre de la variable (como k en el ejemplo anterior) El * le dice al compilador que lo que queremos es una variable apuntador, es decir, que se reserven los bytes necesarios para alojar una dirección de memoria. int significa que queremos usar nuestra variable apuntador para almacenar la dirección de un entero.

Punteros Apuntan a bloques de memoria que se asignan en tiempo de ejecución y que no dependen del ámbito A variables anónimas: Apuntan a un objeto del tipo especificado int* puntero_entero= new int; // asigna un bloque de tipo entero *puntero=3; // asigna el valor 3 al bloque delete puntero; //borra el bloque asignado al puntero A arreglos: Apuntan a n objetos del tipo especificado tipo * id = new tipo [n] int* puntero_arreglo_entero=new int[10]; // asigna 10 bloques //de variables enteras. //Se maneja como un arreglo. puntero_arreglo_entero[2]=4; delete[] puntero_arreglo_entero; // borra n bloques tipo * id

Características especiales de punteros En ocasiones los punteros pueden apuntar a una variable ya declarada No se usa new ni se puede usar delete int x=2; int* puntero=&x; *puntero=3; //modifica el valor de x

Punteros constantes int* pe=new int; int* pe1; int* pe2=pe; //apunta al bloque de pe int* const pc=pe1; //es constante, siempre //apuntará a pe1 pe2=pe1; //pe2 no es constante, ahora apunta al bloque de pe1