Universidad tecnológica de honduras
Español el progreso, presencial Ing. Fabián Zaldívar
:
Elvin rolando pineda cruz 02/06/2014
201310040197
Contenido Introducción ........................................................................................................................................ 1 Objetivos: ............................................................................................................................................ 2 Objetivo general: ............................................................................................................................. 2 Objetivo específico: ......................................................................................................................... 2 Estructura Básica de un Programa ...................................................................................................... 3 Comentarios Descriptivos ................................................................................................................... 4 Directivas del Preprocesador .......................................................................................................... 4 Espacios de Nombre ........................................................................................................................ 5 Función main() ................................................................................................................................ 5 Declaración de Variables ..................................................................................................................... 6 Declaración de Constantes Simbólicas............................................................................................ 7 Enunciados .......................................................................................................................................... 8 Enunciados de Output ..................................................................................................................... 8 Enunciados de Input ........................................................................................................................ 9 Enunciados de Asignación ............................................................................................................. 10 Operadores Aritméticos .................................................................................................................... 10 Bibliografía ........................................................................................................................................ 11 Anexos ........................................................................................................................................... 12
Introducción nuestra primera experiencia con estructuras comienza desde el momento mismo en que usamos en nuestros programas variables de tipos primitivos (char, short, int, float, etc). A la memoria del ordenador se le puede considerar como un gran bloque compuesto por una serie de BYTES dispuestos secuencialmente uno detrás de otro.
La idea de ver la memoria como un serie de bytes es buena, sin embargo no es suficiente ya que en la misma podemos guardar números, cadenas de caracteres, funciones, objetos, etc. de tal manera que surge la necesidad de establecer los mecanismos adecuados para dar cuenta de la forma, tamaño y objetivo de los datos almacenados. Según el tipo de microprocesador, estos tienen la capacidad para manipular o direccionar estructuras compuestas por uno, dos, cuatro, etc, bytes; de donde se derivan los tipos que comunmente se conocen como: BYTE, WORD, DWORD, QWORD y TWORD.
La estructura mínima de información manipulable en un sistema de memoria de ordenadores es el BIT el cual se agrupa normalmente en bloques de 8 para formar un BYTE. Cabe mencionar que los BITS no son direccionables directamente, sino a travez de compuertas AND, OR, NOT, XOR, mismas que en C,C++ se escriben como &, |, ~ y ^ conocidos como "Bitwise operators".
En C,C++ existe una serie de estructuras básicas o tipos primitivos, los cuales pueden ser usados por el programador para declarar variables, y también son el fundamento sobre el cual se crean estructuras complejas. El tamaño de los tipos primitivos no es estándar ya que los mismos dependen de factores tales como: Tipo del microprocesador El compilador
1
Objetivos:
Objetivo general: Organizar datos complicados, particularmente en programas grandes, ya que permiten tratar como una unidad a un conjunto de variables relacionadas, en lugar de tratarlas como entidades independientes.
Objetivo específico: Una estructura debe ir acompañada por la definición de un conjunto de funciones que se encargan de realizar la manipulación directa de la nueva entidad creada.
2
Estructura Básica de un Programa // Comentarios descriptivos
#include using namespace std;
int main() { Declaración de constantes/variables locales
Enunciados return 0;
3
Comentarios Descriptivos Son anotaciones que el programador coloca para describir el programa o una porción del mismo. Formato: // Esto es un comentario de una sola línea
/* Esto es un comentario que se extiende por varias líneas */
Directivas del Preprocesador El preprocesador lee el código fuente del programa antes de que sea compilado y ejecuta aquellas líneas que comienzan con el símbolo # La directiva #include causa que el preprocesador incluya el contenido de otro archivo en el programa El archivo iostream contiene el código que le permite a un programa en C++ mostrar datos en la pantalla y obtener datos del teclado El archivo iostream es un tipo de archivo de cabecera (header file) ya que se incluye al inicio del programa
4
Espacios de Nombre Los espacios de nombre (namespaces) sirven para organizar conjuntos de declaraciones de rutinas, variables y constantes relacionadas La instrucción using namespace std; indica que los nombres declarados en iostream son parte de un espacio llamado std (abreviatura de standard library namespace) El standard library contiene un conjunto de header files que, a su vez, contienen rutinas prehechas. Estos header files están presente en toda instalación de un compilador de C++
Función main() A las rutinas en C++ se les llama funciones. Una función contiene las instrucciones que llevan a cabo una tarea. Un programa se puede componer de varias funciones pero debe contener una función llamada main() que es la primera que se ejecuta El encabezado int main() indica que esta función le devuelve un número entero al sistema operativo El cuerpo de main() está rodeado por los símbolos { y } La instrucción return 0; en el cuerpo de main() indica que el programa debe devolver el número 0 al sistema operativo (el programa ejecutó satisfactoriamente
5
Declaración de Variables Las variables representan localizaciones de memoria que contienen valores que pueden cambiar Formato: tipoDeDatos nombreVariable(s); Ejemplos: int age; double radius, areaCircle;
Los siguientes son tipos de datos comunes en C++: short e int para números enteros float y double para números reales char para caracteres y strings bool para valores booleanos (true, false) En el caso de los strings, C++ provee un tipo de datos llamado string Es posible inicializar una variable al momento de declararla asignándole un valor (llamado un literal) Ejemplos: int counter = 1; double sumPrices = 0.0; char answer = 'Y'; char code[4] = "ZZZ";
// comillas sencillas // comillas dobles
bool found = true; Los literales que corresponden a strings se colocan entre comillas. La siguiente figura muestra cómo se almacena el string “Universidad” en la memoria: universidad
6
El caracter „\0‟ se le conoce como el caracter núlo y C++ lo coloca automáticamente al final de todo litera que corresponda a un string aunque no se vea Internamente, los caracteres se almacenan como números de acuerdo al código ASCII
Declaración de Constantes Simbólicas Los literales pueden ser asociados con nombres llamados constantes simbólicas. Formato: const tipoDatos nombreConstante = valor; Algunos ejemplos: const double PI = 3.14159; const int NAME_SIZE = 26;
7
Enunciados
A las instrucciones se les llama enunciados En general los enunciados pueden clasificarse como: Enunciados de output – sirven para mostrar valores Enunciados de input – sirven para obtener valores Enunciados de asignación – sirven para asignar valores a variables Estructuras de control – sirven para controlar el orden en que se ejecutan los enunciados
Enunciados de Output Para mostrar datos en la pantalla se usa la variable cout y el operador << La variable cout (console output) simboliza la pantalla y está declarada en iostream El operador << (operador de inserción) permite enviarle valores a cout Ejemplo: cout << "Hello, world!"; La otra forma de provocar que el ejemplo anterior se muestre en dos líneas es usar el caracter „\n‟: cout << "Hello!\nGood-bye!";
Por lo tanto, los siguientes enunciados producen lo mismo: cout << "I love to program!\n"; cout << "I love to program!" << endl; Al caracter „\n‟ se le llama una secuencia de escape. No es la única en C++ pero sí es la que más se ve
8
Enunciados de Input Para obtener datos entrados por el teclado se la variable cin y el operador >> La variable cin (console input) simboliza el teclado y está declarada en iostream El operador >> (operador de extracción) permite obtener valores de cin Ejemplo: cout << "Enter your age: "; cin >> age; cout << "You are " << age << " years old!" << endl;
Pantalla: Enter your age: 21
age
21
You are 21 years old!
Si se entran múltiples datos del teclado de una sola vez, el operador >> asume que el separador de los datos será el espacio: cout << "Enter the base and height: "; cin >> base >> height; cout << "The base is " << base << endl; cout << "The height is " << height << endl;
9
Enunciados de Asignación Para asignar el resultado de una expresión a una variable se utiliza el siguiente formato: nombreVariable = expresión; Una expresión es un valor o se compone de operadores que se usan para procesar valores (operandos) y obtener un resultado Ejemplos: n = 7; a = -3.9; b = a * 5.987;
Operadores Aritméticos Los operadores aritméticos son los siguientes: +
Suma
-
Resta
*
Multiplicación
/
División
%
Módulo (Residuo)
En los operadores +, -,* y /, la regla es la siguiente: si ambos operandos son números enteros, el resultado será entero. Si por lo menor un operando es un número real, el resultado será un número real En operador % requiere que ambos operandos sean números enteros y el resultado también será un número entero
Cómo en las Matemáticas, existe una jerarquía de los operadores aritméticos: *, /, % +, -
de izquierda a derecha de izquierda a derecha
La jerarquía se altera agrupando expresiones con paréntesis 10
Bibliografía (ib.cnea.gov.ar) (alcione65) alcione65. (s.f.). Obtenido de http://alcione65.blogspot.com/2012/06/estructura-basica-de-un-
programa-c.html ib.cnea.gov.ar . (s.f.). Obtenido de http://www.ib.cnea.gov.ar/~servos/CursoC/estructuras.htm
11
Anexos
12
13
