Conceptos básicos

1.1.- Estructura de un programa en C++.1.2.- Archivos de cabecera. 1.3.- Comentarios.1.4.- Directivas del preprocesador. 1.5.- La función main() . 1.6.- Identificadores.1.7.- Entrada/Salida.

Estructura de un programa en C++

El formato general de un programa en C++ es el siguiente:

/ | Definición de constantes y macros, ENCABEZADO < Declaración de variables globales, | Inclusión de archivos. \

void main(void) <---linea de cabecera de la función principal. {<-------------Inicio de bloque.......... ......... ......... <---Cuerpo de la función principal..........} <-------------Fin de bloque.

El listado 1.1 muestra un programa que despliega en la pantalla del monitor el mensaje: El Lenguaje C++ es poderoso

// PRIMER.CPP // // Despliega un mensaje en la pantalla.

#include <stdio.h> // Para utilizar la función printf()

void main(void) { printf("El lenguaje C++ es poderoso\n"); }

Listado 1.1.- PRIMER PROGRAMA EN C++

1.2.- Archivos de cabecera

El listado 1.1 contiene la línea:

#include <stdio.h>

En ella, stdio.h es el nombre de un ARCHIVO DE CABECERA en el cual se encuentran declarados los prototipos de las funciones y macros que se utilizan para la entrada/salida estándar.

Existe un extenso grupo de archivos de cabecera, y cada uno de ellos sirve para manejar un grupo de funciones relacionadas. La extensión h de estos archivos es la inicial de la palabra header.

Generalmente estos archivos son incluidos en las primeras líneas de los archivos que contienen el código fuente en C++.

El compilador de C++ desplegará un mensaje de error cuando se trate de utilizar una función sin antes haber incluido el archivo de cabecera que contiene el prototipo de ella.

Los archivos de cabecera son incluidos con el instructivo INCLUDE cuando se ejecuta el del compilador.

1.3.- Comentarios

En el C++ existen dos formas de manejar los comentarios:

La primera sirve para escribir comentarios que abarcan varias líneas, y utiliza los caracteres /* para marcar el inicio de un comentario, y los caracteres */ para marcar el final, como se ve en los siguientes ejemplos:

/* Este es un pequeño comentario */

/* Este es otro comentario, pero a diferencia del anterior, utiliza varias líneas.

Observe que también puede incluir líneas en blanco (como la anterior y la siguiente).

*/

La segunda forma solo sirve para comentarios que abarcan una línea o parte de ella, y utiliza los caracteres // al principio del comentario. El fin del comentario queda marcado por el fin de la línea, como se muestra a continuación:

// Este es un comentario de una línea, // y este es otro.

void main(void) // Este comentario ocupa parte de la línea.

Los comentarios de una sola línea pueden anidarse dentro de los comentarios de varias líneas, como por ejemplo:

/* El principio del comentario de varias líneas.

// Primer comentario de una sola línea.

// Segundo comentario de una sola línea. */ Fin del comentario de varias líneas.

1.4.- Directivas del preprocesador

El preprocesador es un programa que viene incluido en los compiladores de C++, y se encarga de ejecutar ciertas órdenes llamadas DIRECTIVAS DEL PREPROCESADOR. Estas directivas empiezan con el carácter # (Numeral).

Al inicio de la compilación, el compilador invoca al preprocesador, quien actúa de acuerdo a la directiva correspondiente.

Las directivas del preprocesador pueden clasificarse en tres grupos principales:

1.4.1.- Inclusión de Archivos.

1.4.2.- Reemplazamiento de Cadenas y Procesamiento de Macros.

1.4.3.- Compilación Condicional.

1.4.1.- Inclusión de archivos

Pueden incluirse los contenidos de otros archivos de texto en el archivo que contiene código en C++. Esto se logra por medio de la directiva #include en cualquiera de las tres formas siguientes:

#include <nombre_archivo> /* nombre_archivo será buscado únicamente en el directorio INCLUDE */

#include "nombre_archivo" /* nombre_archivo será buscado en el directorio de trabajo actual */

#include "d:\trayectoria\nombre_archivo" /* En este caso, nombre_archivo será buscado en el directorio especificado en la trayectoria */

Ejemplo:

#include "C:\DATOSCPP\PANTALLA.C"

1.4.2.- Reemplazamiento de cadenas y procesamiento de macros

El reemplazamiento de cadenas consiste en sustituir (antes de efectuar la compilación) cada una de las ocurrencias de cierta cadena (llamada constante simbólica) por otra cadena equivalente. Esto de logra por medio de la directiva #define, como se muestra en los siguientes ejemplos:

#include <stdio.h> #define CADENA "El Lenguaje C++ es poderoso\n" void main(void) { printf(CADENA); }

En este caso, el preprocesador sustituirá CADENA por El Lenguaje C++ es poderoso, de tal manera que el compilador se encontrará con la instrucción: printf("El Lenguaje C++ es poderoso\n");

#define VALMAX 1000

Aquí, se está definiendo la constante simbólica VALMAX, cuyo valor será el entero 1000.

La directiva #define también sirve para declarar macros, las cuales incluyen una ó más instrucciones del Lenguaje C++, como:

#define CUBO(N) ((N)*(N)*(N))

Esta macro puede utilizarse en una instrucción de la siguiente forma:

r = CUBO(5);

El preprocesador sustituye lo anterior por: r = ((5)*(5)*(5));

Los macros pueden tomar formas complejas y ocupar varias líneas de código, como se muestra en el siguiente ejemplo:

#define REDOND(x) ((x)>=0?((x)+1/VALOR1)*(1-1/VALOR1): \ ((x)-1/VALOR1)*(1+1/VALOR1))

Obsérvese que al final de la primera línea se escribió una diagonal invertida (\), la cual sirve como enlace.

1.4.3.- Compilación condicional

Existe un grupo de directivas del preprocesador que permiten controlar cuales partes del código fuente se van a compilar al cumplirse ciertas condiciones. A continuación se muestra una lista de tales directivas; dejándose la ejemplificación de su uso para unidades más avanzadas de este trabajo.

#if#ifdef #if defined(algo)#ifndef#else#elif#endif

Además de las directivas vistas hasta aquí, existen las siguientes:

#error#pragma inline#pragma warn#pragma saveregs

1.5.- La Función main()

Todo programa de C++ debe contener una función llamada main() (principal), la cual sirve de enlace con el sistema operativo que se esté utilizando. Cuando se intente obtener un programa ejecutable (.EXE ) a partir de un archivo que no contenga una función main(), el compilador desplegará un mensaje de error.

Al invocar a un programa escrito en C++, desde el indicador de presencia del sistema operativo, se le pueden pasar ciertos valores que se llaman argumentos, los cuales van a ser recibidos por la función principal. Esta, a su vez, va a regresar un valor de retorno al sistema operativo que la invocó. La devolución del valor de retorno se hace por medio de la instrucción return, por ejemplo:

return 0 ;

La explicación acerca de la utilización de argumentos en la función main() requiere del conocimiento de apuntadores, por lo que se tratará en la unidad 6.

1.6.- Identificadores

Los nombres que son utilizados para referenciar variables, funciones, etiquetas y demás objetos que se manejan con el Lenguaje C++, son referidos en forma genérica como identificadores.

1.6.1.- Identificadores Creados por el Usuario.

1.6.2.- Palabras Reservadas.

1.6.1.- Identificadores creados por el usuario

El usuario debe cuidar que los identificadores creados por él cumplan las siguientes:

Reglas generales para los identificadores:

1.- Pueden estar formados por:

a.- Letras mayúsculas y/o minúsculas. b.- El carácter de subrayado. c.- Los dígitos del 0 al 9.

2.- El primer carácter debe ser una letra o el carácter de subrayado.

3.- Pueden contener un número arbitrario de caracteres; pero Borland C++ considera como significativos los primeros 32 o los n primeros que decida el programador, donde:

1 <= n <="32"

4.- Se toma en cuenta la diferencia entre letras mayúsculas y minúsculas, por lo que: SUMA, Suma y suma son identificadores diferentes.

5.- No puede utilizarse el mismo identificador para dos objetos que se encuentren dentro del mismo ámbito.

1.6.2.- Palabras reservadas

Las palabras reservadas, como su nombre lo indica, son identificadores que tienen asignado un uso específico y no podrán ser utilizadas como identificadores creados por el usuario.

La tabla 1.1 muestra las palabras reservadas de Borland C++

_asm @ _ds int @ _seg + asm else _interrupt short auto enum @ interrupt signed break @ _es @ _loadds sizeof case @ _export long @ _ss @ _cdecl extern @ _near static @ cdecl @ _far @ near struct char @ far + new switch + class @ _fastcall + operator + template const float @ _pascal + this continue for @ pascal typedef @ _cs + friend + private union default goto + protected unsigned + delete _huge + public + virtual do @ huge register void double if return volatile + inline @ _saveregs while

Tabla 1.1.- Palabras reservadas de Borland C++.

Las palabras marcadas con + en la tabla 1.1 son las palabras reservadas específicas de C++, las marcadas con @ son las palabras añadidas por Borland al C, y las palabras sin marca son las palabras reservadas del C estándar.

1.7.- Entrada/Salida

En el Lenguaje C++, la entrada/salida se maneja de dos formas.

La primera consiste en la utilización de las funciones cuyos prototipos vienen declarados en el archivo stdio.h, y es la forma que tradicionalmente ha utilizado el Lenguaje C.

La segunda es propia del C++ y consiste en el manejo de objetos y operadores cuyas definiciones se encuentran en el archivo iostream.h.

A continuación explicaremos cada una de estas dos formas.

1.7.1.- Funciones Declaradas en stdio.h

1.7.2.- Funciones Declaradas en conio.h

1.7.3.- Objetos Declarados en iostream.h

1.7.1.- Funciones declaradas en stdio.h

En esta forma, se requiere la inclusión de la siguiente línea al principio del programa fuente:

#include <stdio.h>

En el archivo stdio.h se encuentran definidos, entre otros, los prototipos de las funciones printf(), scanf(), gets() y puts() además de las macros getc(x) y putc(). A continuación analizaremos cada una de estas funciones y macros:

1.7.1.1.- La Función printf()

1.7.1.2.- La Función scanf()

1.7.1.3.- Las Funciones gets() y puts()

1.7.1.4.- Las Macros getc() y putc()

1.7.1.1.- La función printf()

Esta función es la mas utilizada en C para desplegar información en la pantalla, más no en el lenguaje C++ como veremos más adelante.

El formato general para la función printf() es:

printf(<cadena_formato> , <elem> , <elem> , ... );

Donde:

cadena_formato es una cadena de caracteres encerrada entre comillas dobles. Esta cadena es enviada a la pantalla (la salida estándar ) después de haber sustituidos los elementos listados después de la cadena.

La sustitución de los elementos se hace de acuerdo a los comandos de formato incluidos en cadena_formato, los cuales empiezan con un símbolo de porciento (%).

En la tabla 1.2 se muestran los comandos de formato más usuales:

Comando Sirve para:

%d entero

%u entero sin signo

%ld entero largo

%p valor de apuntador

%f número de punto flotante

%e número de punto flotante en valor exponencial

%c carácter

%s cadena de caracteres

%x entero en formato hexadecimal

%o entero en formato octal

Tabla 1.2.- Comandos de formato.

A fin de poder mostrar algunos ejemplos de aplicación de la función printf(), se presenta aquí la tabla 1.3 que contiene los tipos de datos disponibles en el compilador de Borland C++ 3.1.

Tipo Tamaño (bits) Precisión Rango de valores:

char 8 . -128 a 127

unsigned char 8 . 0 a 255

enum 16 . -32,768 a 32,767

int 16 . -32,768 a 32,767

short int 16 . -32,768 a 32,767

unsigned int 16 . 0 a 65,535

long 32 . -2,147'483,648 a 2,147'483,647

unsigned long 32 . 0 a 4,294'967,295

float 32 7 dígitos 3.4E-38 a 3.4E+38

double 64 15 digitos 1.7E-308 a 1.7E+308

long double 80 19 digitos 3.4E-4932 a 3.4E+3932

void . . .

near pointer 16 . Direcciones de memoria

far pointer 16 . Direcciones de memoria

Tabla 1.3.- Tipos de datos, tamaños y rangos en Borland C++ 3.1

Los listados 1.2 a 1.8 muestran ejemplos de utilización de formatos por medio de la función

// IMPRIME ENTEROS EN "DECIMAL" #include <stdio.h> int main() { int y=12345; printf("%13d\n",y);

return 0; }

Listado 1.2

// IMPRIME ENTEROS EN OCTAL #include <stdio.h> int main() { int y=12345; printf("y = %13d EN DECIMAL\n",y); printf("y = %13o EN OCTAL\n",y); return 0; }

Listado 1.3

// IMPRIME ENTEROS EN HEXADECIMAL #include <stdio.h> int main() { int y=12345; printf("y = %13d EN DECIMAL\n",y); printf("y = %13x EN HEXADECIMAL\n",y); return 0; }

Listado 1.4

// IMPRIME ENTEROS SIN SIGNO #include <stdio.h> int main() { int y= -12345; printf("y = %13d ENTERO CON SIGNO\n",y); printf("y = %13u ENTERO SIN SIGNO\n",y); return 0; }

Listado 1.5

// IMPRIME NUMEROS CON PUNTO FLOTANTE #include <stdio.h> int main() { float x=123.45; double y=678.90; printf("x = %12.2f\ny = %12.1f\n",x,y); return 0; }

Listado 1.6

// IMPRIME CARACTERES #include <stdio.h> int main() { char a='X', b='Y', c='Z' ; printf("%c%c%c\n",a,b,c); return 0; }

Listado 1.7

// IMPRIME CADENAS DE CARACTERES #include <stdio.h> int main() { /* Formato: %[-a.b]s donde: - JUSTIFICA A LA IZQUIERDA a NUMERO DE ESPACIOS DISPONIBLES PARA DESPLEGAR b NUMERO MAXIMO DE CARACTERES QUE PUEDEN DESPLEGARSE */ printf("\n%10s","DESPLEGADO DE CADENAS EN LENGUAJE C++"); printf("\n%-10s","DESPLEGADO DE CADENAS EN LENGUAJE C++"); printf("\n%25.10s","DESPLEGADO DE CADENAS EN LENGUAJE C++") printf("\n%-25.10s","DESPLEGADO DE CADENAS EN LENGUAJE C++"; printf("\n%.10s","DESPLEGADO DE CADENAS EN LENGUAJE C++"); return 0; }

Listado 1.8

Para desplegar el símbolo de porciento puede escribirse en cadena_formato : % . Por ejemplo:

..........

..........int utilidad;utilidad = 30;printf("La utilidad es del %2d %\n", utilidad);..........

desplegará :

La utilidad es del 30 %

1.7.1.2.- La función scanf()

Esta función toma la entrada, normalmente del teclado, y la almacena en variables previamente declaradas. El formato para la función scanf() es :

scanf( <cadena_formato> , <elem> , <elem> , ... ) ;

Los significados de <cadena_formato> y <elem> son los mismos que en el caso de la función printf(). La función scanf() utiliza la mayoría de los comandos mostrados en la tabla 1.2 La función scanf() debe utilizarse con cautela cuando se van a introducir valores numéricos y de cadenas de caracteres en una sola instrucción.

1.7.1.3.- Las funciones gets() y puts()

Las funciones scanf() y printf() sirven para varios formatos, por lo cual son muy voluminosas. Es por esto que se han desarrollado las funciones gets() y puts(), específicas para la entrada/salida de cadenas de caracteres.

La función gets() toma una cadena de caracteres desde el teclado y la almacena en la variable cuyo identificador aparece como argumento en la invocación a gets(), como en:

gets(nombre);

La función puts() despliega en la pantalla una cadena de caracteres que se encuentra almacenada en la variable cuyo identificador aparece como argumento en la invocación a la función puts().

1.7.1.4.- Las macros getc() y putc()

La macro getc(c) toma un caracter desde el teclado y lo almacena en la variable c.

Por su parte, putc() despliega un caracter en la pantalla.

Estas macros están definidas en el archivo stdio.h .

1.7.2.- Funciones declaradas en conio.h.

La consola es un concepto heredado de los ambientes multiusuario, y está formada por el teclado y el monitor.

En las implementaciones de Borland C++ existe una serie de funciones que manejan la entrada/salida por la consola, entre otras:

clrscr(), que limpia la pantalla y posiciona el cursor en la esquina superior izquierda de la ventana actual.

gotoxy(a,b), posiciona el cursor en la posición establecida por la columna a y el renglón b.

window(a,b,x,y), establece la ventana actual. Los valores a,b pertenecen a la columna y el renglón de la esquina superior izquierda; los valores x,y corresponden a la columna y el renglón de la esquina inferior derecha de la nueva ventana.

getch(), toma un carácter desde el teclado y no lo despliega en la pantalla.

getche(), toma un carácter desde el teclado y lo despliega en la pantalla.

Para poder utilizar las funciones relacionadas con la consola, es necesario incluir la línea:

#include <conio.h>

Donde conio.h es el archivo de cabecera donde se encuentran declarados los prototipos de las funciones que manejan la entrada/salida estándar por la consola.

1.7.3.- Objetos declarados en iostream.h

C++ provee una nueva forma para manejar la entrada/salida, proporcionando una sintaxis más sencilla, elegante e intuitiva que la de stdio.h , además de un mecanismo más eficiente y flexible. La palabra iostream tiene su origen en las palabras: input output stream , por lo que puede traducirse como flujo de entrada/salida.

El flujo de entrada/salida es utilizado para enviar datos desde una fuente (productor) a un destino (consumidor). En esta forma se tiene una vasta jerarquía de clases para el manejo de entrada/salida para archivos y dispositivos. En el archivo iostream.h se encuentran definidos los objetos cin y cout.

El objeto cin utiliza al operador sobrecargado >> para tomar datos desde la entrada estándar (habitualmente el teclado). El objeto cout utiliza al operador sobrecargado << para enviar datos hacia la salida estándar (normalmente la pantalla).

Veamos cómo se utilizan estos elementos en un pequeño ejemplo:

#include <iostream.h> int main() { char nombre[30]; cout << "CUAL ES TU NOMBRE ? " ; cin>> nombre ; cout << "\n" ; cout << "!! HOLA , " << nombre << " !!" ; return 0 ; }

Listado 1.9.- Ejemplo de utilización de cin y cout

También es posible especificar el ancho de un campo por medio del manipulador setw() , que se encuentra declarado en iomanip.h ; así como los manipuladores window(), clrscr() y gotoxy() declarados en constrea.h, como se muestra en el listado 1.10.

#include <iostream.h> #include <iomanip.h> #include <constrea.h> int main() { char nombre[10] ; int numero = 150 ; float sueldo ; constream ventana0, ventana1, ventana2 ; ventana0.window(1,1,80,25); ventana1.window(10,05,20,05); ventana2.window(10,07,40,07); ventana0.clrscr(); ventana1.clrscr(); cout << "NUMERO: " << setw(3) << numero; cout << " NOMBRE : " ; cin.getline(nombre,10); ventana2.clrscr(); cout << "\nSUELDO : $ " ; cin>> sueldo ; return 0; }

Listado 1.10.- Uso de manipuladores.