Programación en c++

Programación C y C++ 1
Programación
Lenguaje C y C++
M. C. Gastón Dehesa Valencia

Programación C y C++2
Derechos Reservados © 2002 por Gastón Dehesa Valencia
Todos los Derechos Reservados. Se autoriza para que este material pueda ser leida
y reproducida por los estudiantes que la requieran.
En este libro se han incluido programas y descripciones gráficas por su valor
educacional. Han sido debidamente probados pero no se garantizan para ningún
propósito en particular. El editor no proporciona ninguna garantía o representación,
ni acepta ninguna responsabilidad con respecto a los programas y descripciones
gráficas.
Muchos de los nombres utilizados por los fabricantes o vendedores de software para
distinguir sus productos son marcas registradas. El editor tiene toda la intención de
proporcionar la información de la marca registrada acerca de los fabricantes y los
productos mencionados en este libro. Una lista de las designaciones de marcas
registradas se muestra más adelante en esta página.
Marcas Registradas
C++ Builder es una marca registrada por Inprise Corporation.
Turbo C++ es una marca registrada por Borland International, Inc.
MS-Windows™ es una marca registrada por Microsoft Corporation
MS-DOS es una marca registrada por Microsoft Corporation
Visual C++ es una marca registrada por Microsoft Corporation
Dedico esta obra a mi familia
Por que representan una fuente de
Energía inagotable, que me impulsa
a emprender nuevos proyectos.

Contenido
1.- Introducción al Lenguaje C
Historia del lenguaje
Estructura de un programa
Compilación y Ligado
Tipos de Datos y Modificadores
Operadores
Entrada y Salida de Datos
Especificadores de clase de almacenamiento
Ejercicios
2.- Sentencias de control de programa
Sentencias de Selección
Sentencias de Iteración
Sentencias de Salto
Ejercicios
3.- Arreglos y Apuntadores
Que son los arreglos
Arreglos Unidimensionales
Cadenas
Arreglos Bidimensionales
Apuntadores
Punteros y Arreglos
Inicialización de Apuntadores
Funciones de Asignación Dinámica
Ejercicios
4.- Funciones y Estructuras
Funciones
Pase de parámetros
Estructuras
Arreglos de Estructuras
Ejercicios
5.- Programación Orientada a Objetos
Que es la POO
Definición de una clase
Tipos de Accesos a una clase
Tipos de Usuarios
Relación entre Usuarios y Tipos de Accesos
Clases Amigas
Datos Estáticos
Constructores y Destructores

Ejercicios
6.- Herencia y Polimorfismo
Clases Derivadas
Herencia Simple y Múltiples
Problema y solución de la Herencia Múltiples
Constructores y Destructores en clases Derivadas
Polimorfismo
Sobrecarga de funciones
Funciones virtuales
Clases Abstractas
Ejercicios

Prologo
Este libro puede ser utilizado como guía para el examen de admisión de la
Maestría en Informática que el Instituto en Computación y Electrónica
Dehesa ofrece en lo que se refiere a Programación.
Este libro esta organizado de la siguiente forma: En los cuatro primeros
capítulos se aborda la programación estándar y en los capítulos 5 y 6 los
conceptos básicos de la programación orientada a objetos.
Cada tema expuesto viene acompañado de uno o más ejercicios, el nombre del
archivo aparece como comentario al inicio de cada listado de programa. Los
programas que contiene el libro fueron probados usando compiladores de
Borland.
En archivo empaquetado que acompaña al libro encontrará un directorio por
cada unidad con los ejercicios desarrollados.
Espero que al terminar de leer este libro se cubran las expectativas planteadas,
cualquier comentario o sugerencia acerca del contenido del material lo puede
hacer a la siguiente dirección de correo electrónico: gastondv@hotmail.com

Capitulo 1
Introducción al Lenguaje C
• Historia del lenguaje
• Estructura de un programa
• Compilación y Ligado
• Tipos de Datos y Modificadores
• Operadores
• Entrada y Salida de Datos
• Especificadores de clase de almacenamiento
• Ejercicios

HISTORIA DEL LENGUAJE
El Lenguaje C nació en los Laboratorios Bell de AT&T y ha sido
estrechamente asociado con el sistema operativo UNIX, ya que su desarrollo
se realizo en este sistema y debido a que tanto UNIX como el propio
compilador de C y la casi totalidad de los programas y herramientas de
UNIX, fueron escritos en C. Su eficiencia y claridad han hecho que el
lenguaje ensamblador apenas haya sido utilizado en UNIX.
Este leguaje está inspirado en el lenguaje B escrito por Ken
Thompson en 1970 con intención de recodificar el UNIX, que en la fase de
arranque estaba escrito en ensamblador, en vista a su transportabilidad a otras
maquinas. B era un lenguaje evolucionado e independiente de la máquina,
inspirado en el lenguaje BCPL concebido por Martín Richard en 1967.
En 1972 , Dennis Ritchie, toma el relevo y modifica el lenguaje B,
creando el lenguaje C y rescribiendo el UNIX en dicho lenguaje. La novedad
que proporciono él lenguaje C sobre el B fue el diseño de tipos y estructuras
de datos.
En 1980 Bjarne Stroustrup de los laboratorios Bell de Murray Hill,
New Jersey, inspirado en el lenguaje Simula67 adiciono las características de
la programación orientada a objetos (incluyendo la ventaja de una biblioteca
de funciones orientada a objetos) y lo denomino C con clases. Para 1983 dicha
denominación cambio a la de C++. Con este nuevo enfoque surge la nueva
metodología que aumenta las posibilidades de la programación bajo nuevos
conceptos.
Con la popularidad de las microcomputadoras se crearon muchas
implementaciones de C. En lo que se podría decir que era un milagro, los
códigos fuentes aceptados por la mayoría de esas implementaciones eran
altamente compatibles. Sin embargo, como no existía ningún estándar,
aparecieron discrepancias. Para remediar la situación, el Instituto de
Estándares Americano (ANSI) estableció un comité a mediados de 1983 para
crear un estándar que definiera al lenguaje C. Este comité ANSI termino el
proceso de formalización en 1990.
Actualmente muchas empresas se dedican a vender el Compilador del
lenguaje C, dos de estos imperios son:
Microsoft Visual C++ Ver 6.0
Borland C++ Builder 5.0
La mayoría de los compiladores actuales soportan la programación en
C Estándar, C Orientado a Objetos y la Programación Visual.

ESTRUCTURA DE UN PROGRAMA
Un programa escrito en lenguaje C tiene la siguiente estructura, aunque no
necesariamente debe contener todos los puntos:
1.- Definición de archivos de cabeceras
2.- Definición de constantes y variables globales
3.- Definición de Funciones del usuario
4.- Definición e implementación del programa principal ( main() )
5.- Implementación de funciones del usuario.
A manera de ejemplo considérese el siguiente programa:
//*Est_Prog.cpp
//Definición de archivos de cabecera
#include <conio.h>
#include <stdio.h>
//Definición de Constantes y Variables Globales
#define PI 3.1416
float Area;
//Definición de funciones del usuario
void Area_Cir(int R);
//Definición e implementación del Programa Principal
void main()
{int Radio;
clrscr();
printf("BIEN BENIDO AL LENGUAJE C");
printf("nn CALCULO DEL AREA DE UN CIRCULO");
printf("n Radio: ");
scanf("%i",&Radio);
Area_Cir(Radio);
printf("n El Area es; %8.2f",Area);
getch();
}
//Implementación de funciones del Usuario
void Area_Cir(int R)
{
Area= 2*PI*R*R;
}
La idea de presentar un programa no muy pequeño de entrada a
diferencia de como lo hacen otros autores es para que el estudiante en su
primer día conozca gran cantidad de información sobre el Lenguaje C.
El programa Est_Pro.cpp contiene las 5 partes del que se compone un
programa escrito en el lenguaje C. en la sección de Definición de archivos de
cabecera se presentan los archivos conio.h y el stdio.h ambos son archivos de

cabecera definidos por el lenguaje, existen un gran numero de ellos que
acompaña al compilador según la versión y fabricante por lo regular hallados
en el directorio Include, los archivos de cabecera definidos en esta sección
que pertenezcen al compilador deberán estar entre los signos < > y aquellos
que el propio programador cree para sus aplicaciones entre comillas “ “ lo
cual le indicara al compilador que busque el archivo en el directorio de
trabajo y no en el directorio por defauld de archivos de cabecera (include).
La siguiente lista muestra algunos de los archivos de cabeceras que
más se usan así como una breve descripción de su contenido.
<stdio.h> para uso de funciones de entrada/salida standard.
<iostream.h> para uso de funciones de entrada/salida por flujos.
<conio.h> para uso de funciones de entrada/salida por teclado o
consola
<alloc.h> para la asignación dinámica de memoria
<graphics> para uso de funciones relacionadas con gráficas
<io.h> para uso de funciones de entrada/salida de bajo nivel
<math.h> para uso de funciones matemáticas.
<mem.h> para uso de funciones de manipulación de memoria.
<string.h> para uso de funciones relacionadas con cadenas
<time.h> para uso de funciones de hora y fecha.
Para definir un archivo de cabecera se usa una directiva de
preprocesamiento llamado #include seguido del archivo de cabecera
encerrado entre signos < > ó “ ” según el lugar donde este se encuentre, de
esta forma el compilador incluirá durante la compilación las variables,
constantes y funciones que se encuentren en el archivo y que sean usados por
el programa en desarrollo.
En la sección de definición de constantes y variables globales se encuentra
otra directiva de preprocesamiento conocido como #define que permite
definir la constante, observe que después del identificador PI no existe un
signo =, aunque el significado es que el identificador PI toma el valor de
3.1416, para la definición de las variables globales basta con indicar su tipo de
dato y el identificador seguido de punto y coma, aquí se define Area de tipo
real (float), recuerde que una variable global perdura a lo largo de la ejecución
de todo el programa y puede ser vista, modificable desde cualquier parte del
programa o función.
En la sección de definición de funciones del usuario se requiere
definir todas las funciones que se implementen por el programador, por que
solo de esta forma el compilador puede conocer de forma adelantada la
existencia de los mismos, es decir antes de llamar a una función primero el
compilador necesita saber de su existencia en caso contrario no podría
resolver esta referencia provocando un error en tiempo de compilación, el
lenguaje C es un lenguaje estructurado lo cual significa que un programa
según su tamaño se dividirá en varios módulos conocidos como funciones, de
esta forma se evita que la función principal este saturada de código. En este

ejemplo se define solamente una función, Area_Cir() sin tipo de retorno
(void) y recibe como parámetro un entero( El radio del circulo).
La función principal (main()) es el primero que se ejecuta cuando
inicia un programa, por lo que es indispensable que éste exista, en él se
establece la lógica o secuencia que seguirá el programa durante su ejecución.
Una descripción de lo que ocurre en el ejemplo es el siguiente:
Se define una variable local Radio de tipo entero
Borra la pantalla
Se Imprimen mensajes en pantalla
Lee un dato de tipo entero almacenándolo en la variable Radio
Llama a la función Area_Cir() pasándole como argumento el Radio leído
Imprime la variable Area calculada en la función
Espera la entrada de una tecla para terminar
Como puede observarse el orden de los comandos es el orden o
secuencia en que estos se ejecutan.
Finalmente en la sección de Implementación de funciones se tendrá
la implementación de todas las funciones que el programador halla definido
en la sección correspondiente, en este caso la función Area_Cir() solamente
tiene una línea de código que se encarga de asignar a la variable global Area ,
el resultado de multiplicar 2*3.1416*R*R , si el usuario introdujo un Radio =5
entonces sería: 2*3.1416*5*5.
Si una función se define y se llama desde alguna parte del programa y
no esta implementado, se detectara un error en tiempo de enlace y no en
tiempo de compilación tema que se tratará en la siguiente sección.

COMPILACIÓN Y LIGADO
Para crear un archivo ejecutable (Código maquina relocalizable) se realiza
mediante dos etapas o tiempos que son: Compilación y ligado.
Compilación.- Durante este proceso se examina el o los programas
fuente de la aplicación, los archivos de cabecera para hallar errores de
sintaxis, de no existir se genera un archivo objeto (.OBJ) por cada programa
fuente.
Ligado.- Durante este proceso se unen todos los programas objetos
del que se conforme la aplicación, así como los archivos de librería (.LIB)
para formar un solo programa independiente, o programa ejecutable (.EXE).
Para aclarar lo anterior observe la siguiente figura:
La implementación de las funciones halladas en los archivos de
cabecera predefinidos por el lenguaje se encuentran en librerías (Mathl.lib,
Cl.lib, etc.) incluidos también en el software del compilador, por lo que se
integran al programa en tiempo de enlace, es por esta razón que si una función
definido por el usuario no esta implementada en el programa ni tampoco en
una librería se detectará en tiempo de enlace.
De lo anterior se deduce entonces que un archivo de cabeceras (*.h) es
diferente de un archivo de librerías (*.Lib), lo cual es muy cierto y veamos
algunas diferencias:
Característica Archivo de Cabecera Archivo de Librería
Tipo Texto Binario
Cuando se usa Tiempo de Compilación Tiempo de ligado
Contenido Definiciones Implementaciones
compiladas
Tabla 1. 1 Diferencias entre un archivo de Cabecera y uno de Librería
Figura 1. 1 Proceso de Compilación y Ligado de un programa en C
Princip.cpp Archivo2.cpp
stdio.h conio.h
COMPILACION
Archivo2.objPrincip.obj
LIGADO
Extern.exe
Mathl.libCl.lib

Es frecuente que se confundan los términos archivo de librería con
archivo de cabecera, la tabla y dibujo anterior precisamente tiene la finalidad
de hacer notar que son diferentes. Durante la escritura de un programa es
frecuente probar una y otra vez si se esta haciendo lo correcto, para ello se usa
la ejecución paso a paso de un programa (Depuración), en ocasiones algunos
archivos de cabecera se cargan en el ambiente de programación y se debe
tener la precaución de no modificarlos para no producir incongruencias entre
el archivo de cabecera y el archivo de librería, al final de cuentas están
directamente relacionados entre si .
TIPOS DE DATOS Y MODIFICADORES
Todo lenguaje de programación suministra al diseñador de software un
conjunto de tipos de datos y un conjunto de instrucciones, el diseñador a partir
de estas puede crear nuevos tipos y nuevas instrucciones.
Palabras reservadas
Las palabras reservadas del compilador son todas aquellas palabras que se
usan para especificar tipos de variables, estructuras cíclicas, estructuras de
decisión, etc., y que no pueden ser usadas por el usuario como nombre de
variables, de funciones o de nuevos tipos .Estas palabras son las siguientes:
asm delete goto public this
auto do huge register union
break double if return unsigned
case else int Short virtual
carch enum interrupt signet void
char extern long sizeof volatile
class far near static while
const float new struct
continue for private switch
defauld friend protected template
Tabla 1. 2 Palabras Reservadas del Lenguaje
Las palabras reservadas deben escribirse siempre en minúsculas.
Tipos de datos
Un tipo de dato en C es la manera como el compilador almacena la
información en la memoria, por ejemplo el sistema operativo MS-DOS es un
sistema de 16 bits, mientras que Windows 98, Windows 2000, Windows NT
son de 32 bits, así que el compilador para cada uno de estos sistemas
operativos almacenara en algunos casos un mismo tipo de dato con longitud
diferente, más adelante se presenta una tabla de los tipos de datos para un
sistema de 16 bits.

C se distingue por ser un lenguaje con demasiados tipos, existen otros
lenguajes como PASCAL que cuentan con unos pocos tipos, esta variedad de
tipos nos obliga a ser demasiado cuidadosos a la hora de usar algunos
operadores de asignación.
Antes de empezar a describir los tipos disponibles en el lenguaje
estudiemos un poco lo que es una variable.
Las variables siempre pertenecen a un tipo de datos, este tipo de datos
puede ser alguno de los tipos predefinidos por el lenguaje o definido por el
usuario, algunos tipos predefinidos para un sistema de 16 bits son.
Tipos de datos # de Bits Intervalo
char 8 -127 a 127
int 16 -32768 a 32767
long 32 0 a 4294967295
float 32 Aprox. 6 dígitos de precisión
double 64 Aprox. 12 dígitos de precisión
void 0 Sin valor
Tabla 1. 3 Tipos de Datos Básicos de un sistema de 16 bits
Midificadores
Los modificadores son palabras reservadas que se le adicionan a los tipos para
modificarles su tamaño y/o su rango, estos son:
Signed
unsigned
long
short
Estas son algunas de las combinaciones que se pueden presentar:
Tipo # de Bits Intervalo
unsigned char 8 0 a 255
Char 8 -127 a 127
unsigned int 16 0 a 65535
short int 16 Lo mismo que int
Int 16 -32,768 a 32,767
unsigned long int 32 0 a 4,294,967,295
long int 32 -2,147,483,648 a 2,147,483,647
Float 32 3.4E-38 a 3.4E38
double float 64 1.7E-308 a 1.7E308
Tabla 1. 4 Tipos de Datos con modificadores en un Sistema de 16 Bits
Como se puede observar cada tipo tiene un tamaño en bits, este tamaño
define un rango de operación que limita los números que se puede almacenar
en una variable. imagínese que se desea diseñar un programa de nómina que

va ha manejar los sueldos de los empleados, piense en el tipo de datos que
usaría para la variable sueldo; seguramente pensó en un tipo unsigned int, si
observamos la tabla anterior el tipo unsigned int almacena valores entre 0 y
65535, ¿será el tipo unsigned int el más apropiado? Bueno tal vez contestará
que no, ya que los sueldos pueden ser superiores a 65535, tal vez el tipo más
apropiado será unsigned long que almacena valores entre 0 y 4294967295.
Bueno, pero que pasaría si escogiéramos el tipo unsigned int para la variable
sueldo, en el momento que almacenemos un valor superior a 65535 el
contenido quedará truncado.
Para el caso de un Sistema Operativo de 32 bits, el compilador
almacenaría los datos con tamaños diferentes, este sería el caso:
Tipo # de Bits Intervalo
unsigned char 8 0 a 255
char 8 -128 a 126
unsigned int 32 0 a 4,294,967,295
short int 16 -32,768 a 32,767
int 32 -2,147,483,648 a 2,147,483,648
unsigned long int 32 Lo mismo que unsigned int
long int 32 Lo mismo que int
float 32 1.2E-38 a 3.4E381
double float 64 2.2E-308 a 1.8E3082
Tabla 1. 5 Tipos de Datos con moficadores en un sistema de 32 bits
Al examinar la tabla anterior se puede observar que int es lo mismo
que long int mientras que para un sistema de 16 bits estos tienen diferente
longitudes y por lo tanto diferentes intervalos.
Como se deduce en consecuencia que la longitud en bytes de un tipo dato
depende del sistema operativo y del compilador que se use, para conocer con
precisión la longitud en bytes de una variable de un tipo de dato se puede
utilizar el operador sizeof. Por ejemplo:
int x;
x=sizeof(int));
En un compilador operado en el sistema operativo MS-DOS x tomaría
el valor de 2, mientras que en Windows 98 el valor de 4.
En este libro con la finalidad de evitar las complicaciones del ambiente
del compilador se abordarán los aspectos básicos de la programación estándar
y orientado a objetos usando un compilador que se ejecuta bajo el MS-DOS
(Hasta el capitulo 6), la parte restante del libro estará basado en el ambiente
Windows para conocer la programación Visual con C++.
Comentarios

Un comentario es una secuencia de caracteres utilizada para explicar el código
fuente y no se toma en cuenta durante la compilación (No se considera como
código). Existen dos formas para definir un comentario:
• Secuencia de caracteres encerrados entre los símbolos /* y */
• Comienza con los caracteres // y termina al final de la línea.
Variables
Es una posición de memoria de cierta longitud según el tipo de dato cuyo
valor puede ser modificado a lo largo de la ejecución de un programa .
Sintaxis:
[clase] tipo identificador[,identificador];
Donde:
clase representa un especificador de clase de almacenamiento (se
explica posteriormente).
tipo determina el tipo de variable (char, int, float, etc.)
identificador Indica el nombre de la variable.
Una variable que se declara al inicio del programa es considerada
como variable global y es accesible desde cualquier parte del programa. Por
lo contrario una variable declarada dentro de una función se considera como
variable local y es accesible solamente dentro de este.
Cada variable de un programa, debe declararse antes de ser utilizada.
La declaración consiste en enunciar el nombre de la variable y asociarle un
tipo. El tipo determina los valores que puede tomar así como las operaciones
que con ella pueden realizarse.
Ejemplos:
int Suma, Promedio;
char Car, Nombre[40];
Una variable puede ser inicializada cuando se declara:
char car = ’0’ ;
int Incremento = 10;
char Archivo[] = ”Datos.dbf”;
Conversión de Tipos de datos
Cuando se trabaja con datos de diferentes tipos es frecuente mezclarlos
durante una expresión o asignación, a diferencia de otros lenguajes, C realiza
la conversión de tipos compatibles de manera automática.
Por ejemplo:
int x=92; //Se declara la variable x de tipo entero inicializándola con 92
char car=x; //car es de tipo carácter y se le asigna el valor de un entero x
En este ejemplo se da la conversión automática de tipos, es decir a la
variable car se le asigna el carácter ’’ , que es el equivalente del código
ASCII.

Cuando se presenten casos de conversión de tipos se debe tener en
cuenta que es posible la perdida de datos. Supóngase que x=256 en lugar de
92, en este caso car tomaría el valor de ‘0’, es decir el carácter nulo. Esto se
debe a que un entero es de 16 bits (en MS-DOS) mientras que un char es 8
bits, por lo tanto los 8 bits más significativos del entero se perderán.
No todos los compiladores soportan la conversión de tipos durante las
asignaciones, algunos solamente lo soportan durante una expresión este es el
caso del C++ Builder, por ejemplo:
int x;
x= Edit1->Text; //Error No se puede convertir una cadena a entero
Como Edit1->Text es una propiedad de tipo cadena (Arreglo de
caracteres) no se puede llevar a cabo la conversión de manera directa, para
solucionar este problema la asignación se debe realizar de manera indirecta:
x = Edit1->Text*1; //OK La conversión se da en la expresión.
OPERADORES
Los operadores se utilizan para manipular datos: ejecutan cálculos, buscan
igualdades, realizan asignaciones, trabajan con variables y se encargan de
muchas otras tareas que los programadores nunca llevan a cabo. En la
siguiente tabla se presentan los de uso más común .
Operador Descripción Ejemplo Operador Descripción Ejemplo
OPERADORES ARITMÉTICOS OPERADORES DE ASIGNACIÓN
+ Adición x=x+z; = Asignación x=10;
- Sustracción x=x-z; += Asignar y sumar x+=10;
* Multiplicación x=x*z -= Asignar y restar x-=10;
/ División x=x/z; *= Asignar y multiplicar x*=10;
% Modulo o resto x=x%z; /= Asignar y dividir x/=10;
OPERADORES LÓGICOS &= Asig. operador AND x&=0x02;
&& AND Lógico if (x&&0xFF) |= Asignar operador OR x|=0x02;
|| OR Lógico if (x||0xFF) OPERADORES A NIVEL DE BITS
! NOT Lógico If (!Soltero) & AND a nivel de bits C=A&B;
OPERADORES RELACIONALES | OR a nivel de bits
== Igual que if (x==y) ∧ XOR a nivel de bits C=A∧B;
!= Diferente que << Desp. a la izquierda B=A<<3;
< Menor que >> Desp. a la derecha C=A>>2;
> Mayor que ~ NOT a nivel de bits A=~D;
<= Menor o igual que OPERADORES DE APUNTADORES
>= Mayor o igual que * Indirección Int *Ap;
OPERADORES DE CLASE Y ESTRUCT. & Dirección x=&Ap;
:: Resol. de alcance Punto::Dibujar() OTROS
-> Miembro indirecto P->Dibujar(); ++ Incremento x++;
. Miembro directo P.Borar(); -- Decremento x--;
Tabla 1. 6 Operadores de C++ más usados

Prioridad y orden de Procedencia
La prioridad de los operadores define el orden en que se evalúa una expresión
cuando tiene distintos operadores. C y C++ tienen reglas específicas para
determinar el orden de evaluación. Lo más sencillo de recordar es que la
multiplicación y división tienen prioridad sobre la suma y la resta. A partir de
esto, si una expresión no le resulta clara, tampoco lo será para alguien que lea
el código, por lo que deberá utilizar paréntesis para hacer más explicito el
orden de evaluación. Por ejemplo:
A= x + y – 2 / 2 + z;
Tendrá un significado distinto dependiendo de cómo se agrupen los
paréntesis:
A= x + (y - 2) / (2 + z);
En la siguiente tabla lista los operadores de C y C++ de mayor a menor
prioridad, y describe como se asocia cada operador (de izquierda a derecha o
de derecha a izquierda). Todos los operadores situados entre líneas tienen el
mismo nivel de prioridad.
Nivel Operadores Asociatividad
1 () [] -> :: . Izquierda – Derecha
2 ! ~ ++ -- & * Derecha . Izquierda
3 * / % Izquierda – Derecha
4 + - Izquierda – Derecha
5 << >> Izquierda – Derecha
6 < <= > >= Izquierda – Derecha
7 = != Izquierda – Derecha
8 & Izquierda – Derecha
9 ∧ Izquierda – Derecha
10 | Izquierda – Derecha
11 && Izquierda – Derecha
12 || Izquierda – Derecha
13 = *= -= *= %= < <= > >= &= ∧= |= Derecha – Izquierda
14 , Izquierda – Derecha
Tabla 1. 7 Prioridad y Asociatividad de operadores de C++
Ejemplos:
a).- 8/4*6
2*6
12
8*6/4
48/4
12
28/(3*4)
28/12
2
b).- 3/4*6
0*6
0
3*6/4
18/4
4
c).- (float) 2/4
2.0/4
0.5
d).- -3+4% 5/2
-3+4/2
-3+2
-1

ENTRADA Y SALIDA DE DATOS (ESTÁNDAR Y FLUJOS)
Prácticamente todos los programas requieren procesar información
proveniente de fuentes externas para obtener la solución de un problema
específico. Esta información constituye los datos de entrada del algoritmo que
definen nuestro programa y es mediante ellos que se obtendrá la salida o
solución correspondiente:
De ahí la importancia de proporcionar adecuadamente los valores o
datos de aquellas variables del programa que deba leer la computadora;
además de la importancia de incluir mensajes en las ordenes de salida que nos
indiquen la naturaleza o nombre de los resultados obtenidos.
El sistema operativo MS-DOS soporta dos métodos de entrada y salida de
datos que son:
• Entrada y Salida Estándar
• Entrada y salida por flujos
El sistema operativo Windows la entrada y salida por pantalla lo hace a
través de un conjunto de controles visuales, los cuales se analizaran
posteriormente. En esta sección se analizan los dos primeros métodos.
Entrada y Salida Estándar
Para la entrada y Salida de datos con formato se utilizan dos funciones
hallados en el archivo de cabecera stdio.h : printf() y scanf().
Salida por pantalla
Printf(char *cadena_de_control, Lista_argumentos);
La cadena de control está formada por dos tipos de elementos . El
primer elemento es el carácter que se mostrará en la pantalla. El segundo
elemento contiene especificadores de formato que definen la forma en que se
muestran los argumentos posteriores. El espicificador de formato empieza
con un % y va seguido por el código del formato. Debe haber exactamente el
mismo número de argumentos que especificadores de formato y ambos deben
coincidir en su orden de aparición de izquierda a derecha.
En la siguiente tabla se muestra una gran variedad de especificadores
de formato.
Código Formato
%c Carácter
%d Entero en decimales con signo
%i Entero decimales con signo
%e Notación científica

%f Punto flotante)
%h Entero corto
%o Octal sin signo
%s Cadena de caracteres
%x Hexadecimal sin signo
Tabla 1. 8 Especificadores de Formato
Ejemplo:
printf(“El Lado es: %i El Area del Cuadrado es: %f”,Lado, Area);
Si la variable Lado=5 por lo tanto la variable Area=25, así el mensaje sería:
El Lado es: 5 El Area del Cuadrado es: 25
También en la cadena de control pueden existir una serie de caracteres
que permitan formatear la salida, conocidos como secuencia de escape
Secuencia de escape Acción realizada
a Alarma
b Retroceso
f Avance de pagina
n Nueva Linea
r Retorno de carro
t Tabulación (horizontal)
v Tabulación (vertival)
Barra inclinada
Tabla 1. 9 Secuencias de Escape
Entrada por teclado
Scanf(char *cadena_de_control, Lista_argumentos);
Esta función direcciona automáticamente la lectura de valores por el
teclado de la microcomputadora. Como se aprecia el formato es idéntico al
printf().
El lenguaje C emplea apuntadores en lectura de toda cantidad
numérica debido a que asigna dichos valores a través de las direcciones de las
variables, por tal motivo los nombres de ellas van precedidas del símbolo &
(con lo que se indica que se usan apuntadores). En el caso de cadenas, los
nombres de las variables son en si mismos apuntadores y no requieren dicho
símbolo.
Ejemplo:

/*ES-Estan.cpp
Muestra el uso de las funciones printf() y scanf()
*/
#include <conio.h>
#include <stdio.h>
void main()
{char Nom[40];
int Edad;
float Peso;
clrscr();
printf("IDENTIFIQUESE POR FAVOR");
printf("nn NOMBRE: ");
scanf("%s",Nom);
printf("n EDAD: ");
scanf("%i",&Edad);
printf("n PESO: ");
scanf("%f",&Peso);
printf("nn SUS DATOS SON: ");
printf("%s %i %4.2f",Nom,Edad,Peso);
getch();
}
La Salida del programa después de ejecutarla sería:
IDENTIFIQUESE POR FAVOR
NOMBRE: Juvenal
EDAD: 36
PESO: 50.4
SUS DATOS SON: Juvenal 36 50.40
Observe que al leer las variables Edad y Peso de tipo entero y real
respectivamente se utiliza el operador & que indica dirección, mientras que la
variable Nom que es un arreglo de caracteres (cadena) no lo requiere, la
función printf() hace uso frecuentemente de la secuencia de escape n para
cambiar de línea, por ejemplo el penúltimo printf() hace que se deje una línea
en blanco.
Existen en el archivo de cabecera stdio.h una serie de funciones que
permiten específicamente leer y escribir datos de tipo carácter y cadena, no es
la finalidad de este libro profundizar en este tema más sin embargo se
considera necesario conocer de su existencia. En la siguiente tabla se
sintetizan:
Función Operación
getchar()
getche()
getch()
putchar()
gets()
puts()
Lee un carácter del teclado; espera un salto de carro.
Lee un carácter con eco; no espera un salto de carro.
Lee un carácter sin eco; no espera un salto de carro.
Escribe un carácter en pantalla.
Lee una cadena del teclado.
Escribe una cadena en pantalla.
Tabla 1. 10 Funciones complementarias de E/S

Entrada y Salida por flujos
C++ proporciona el archivo de cabecera iostream.h que contiene funciones
que realizan operaciones de Entrada/Salida, este archivo tiene la ventaja sobre
el stdio.h por ser una implementación orientada a objetos, dos de estos
objetos son: cin y cout. Donde:
• cin Usado para entrada de datos
• cout Usado para salida de datos
Para el manejo de de estos dos objetos se utilizan dos operadores:
• El operador de inserción (<<) transmite sus argumentos situados a la
derecha hacia el flujo cout.
• El operador de extracción (>>) lee informaciones del flujo cin a la
izquierda del operador y las almacena en las variables indicadas a la
derecha.
A manera de ejemplo rescribiremos el programa ES-Estan.cpp pero en
lugar de usar printf() y scanf() se usara cout y cin.
/*ES-Flujo.cpp*/
#include <conio.h>
#include <iostream.h> //En lugar de stdio.h
void main()
{char Nom[40];
int Edad;
float Peso;
clrscr();
cout<<"IDENTIFIQUESE POR FAVOR";
cout<<"nn NOMBRE: ";
cin>>Nom;
cout<<"n EDAD: ";
cin>>Edad;
cout<<"n PESO: ";
cin>>Peso;
cout<<"nn SUS DATOS SON: ";
cout<<Nom<<" "<<Edad<<" "<<Peso;
getch();
}
La Salida del programa después de ejecutarla sería identica al
a salida del programa ES-Estan.cpp
Cuando se lee un arreglo de caracteres como la variable Nom puede
ocurrir que el usuario escriba más de una palabra (Una línea), en cuyo caso no
sería conveniente utilizar cin sola, ya que este solamente tomaría la primera

palabra. Para leer más de una palabra se puede utilizar la función getline() de
la siguiente forma:
cin.getline(Cadena, num);
Donde:
Cadena es cualquier arreglo de caracteres que se haya definido con
anterioridad y que contiene la cadena de entrada.
Num es el número máximo de caracteres que desea leer con getline()
Ejemplo:
cin.getline(Nom, 40); //Se puede almacenar hasta 40 caracteres en Nom
En la penúltima línea se observa que se pueden concatenar varios operadores
<< en una sola línea. Otro aspecto importante de los flujos, es que los
operadores << y >> efectúan automáticamente las conversiones necesarias.
Los ejemplos que se mostraran a partir de esta parte del libro en adelante,
usarán el cout y el cin para la entrada y salida de datos en pantalla. Sin
embargo al abordar el tema de la programación visual se dejará de usar.
ESPECIFICADORES DE CLASE DE ALMACENAMIENTO
Aunque este tema esta ligado más con el tema de Variables se dejo para esta
sección porque se requiere de los conocimientos anteriores para comprenderlo
con más claridad.
Existen cuatro especificadores de clase de almacenamiento sopórtados por C:
• extern
• static
• register
• auto
Los especificadores le indican al compilador cómo debe almacenar la
variable. La clase de almacenamiento precede a la declaración de la variable.
Su forma general es:
[clase] tipo identificador[,identificador];
• extern
Dado que C permite enlazar juntos módulos de un programa, compilados por
separado con el fin de acelerar la compilación y ayudar a la gestión de grandes
proyectos, debe haber alguna forma de hacer conocer a todos los archivos las
variables globales requeridas por el programa, las variables globales se deben
de declarar sólo una vez. Si se declaran dos variables globales con el mismo
nombre en el mismo archivo, el compilador imprimirá un mensaje de error
indicando que se ha duplicado un nombre de variable, lo que significa que el
compilador no sabe que variable se va ha usar cada vez. Lo mismo ocurre si
declaran todas las variables globales necesitadas por el programa en cada
archivo. Aunque el compilador no daría ningun mensaje de error en tiempo de

compilación , realmente se intenta crear dos o más de cada variable. El
problema aparecería al intentar enlazar los modulos. El Enlazador mostraría el
mensaje de error “Identificador duplicado” por que no sabría que variable
usar. La solución está en declarar todas las variables globales en un archivo y
usar declaraciones extern en los otros.
Ejemplo:
/*Princip.cpp proyecto:exten.prj
*/
#include <conio.h>
#include <iostream.h>
float Prom;
void Promedio();
void main()
{
clrscr();
cout<<"nCALCULO DEL PROMEDIO DE
CALIFCACIONES";
Promedio();
cout<<"nnEl Promedio es:
"<<Prom;
getch();
}
/*Archivo2.cpp proyecto:exten.prj
*/
#include <conio.h>
extern float Prom; //Ojo
void Promedio()
{int C1,C2,C3;
cout<<"nESCRIBA LAS 3
CALIFICACIONES DEL ALUMNO";
cout<<"nnI UNIDAD: ";
cin>>C1;
cout<<"nII UNIDAD: ";
cin>>C2;
cout<<"nIII UNIDAD: ";
cin>>C3;
Prom=(C1+C2+C3)/3;
}
La Salida del programa después de ejecutarla sería:
CALCULO DEL PROMEDIO DE CALIFCACIONES
ESCRIBA LAS 3 CALIFICACIONES DEL ALUMNO
I UNIDAD: 80
II UNIDAD: 90
III UNIDAD: 100
El Promedio es: 90
El programa anterior esta compuesto por los archivos Princip.cpp y
Archivo2.cpp la variable global Prom se encuentra dafinida en el archivo
Princip.cpp sin embargo se utiliza tambien en el Archivo2.cpp, para indicar
al compilador que se trata de la misma variable se usa el expecificador extern
en su declaración. Observe que la función Promedio() se define unicamente
en Princip.cpp y se implementa en Archivo2.cpp, esto no trae ningún
problema durante la compilación porque es durante el enlace que se resuelve
la referencia hacia esta función.
Tal vez se preguntará ¿pero como se puede lograr que dos archivos
fuentes conformen un solo programa?. Se puede llevar a cabo con cualquiera
de los dos métodos: El primero consiste en realizar la compilación y enlazado
mediante la línea de comandos del MS-DOS el segundo creando un proyecto
de esta aplicación para que los detalles los efectúe el propio ambiente del
software.
El primer método es un tanto rudimentario ya que consume una gran
cantidad de tiempo para llevarlo a cabo, sin embargo el segundo es mucho
más eficiente y es el que se explicará a continuación.

Creación de Proyectos
En la mayoría de los ambientes de programación modernos se considera este
método, los pasos a seguir diferirán unos de otros dependiendo del fabricante
y versión, a manera de ejemplo se explicará como se lleva a cabo la creación
de proyectos usando el Software de Borland ver. 1.0 para MS-DOS, para
poder compilar y enlazar de manera directa y transparente para el
programador el programa Extern.prj. El nombre que se le da a un proyecto
será el mismo que tendrá el programa ejecutable despues de su compilación y
ligado. Pasos:
1.- Crear un directorio de trabajo estando en el directorio del compilador
C:tc>md ejerc-I
2.- Ejecutar el programa del compilador
C:tc>tc
3.- En el ambiente definir como directorio de trabajo el directorio recien
creado
Seleccionar File | Change dir... y escribir en la caja de dialogos c:tcejerc-I y OK
4.- Crear el proyecto, por defauld se guarda en el directorio de trabajo
Seleccionar Project | Open Project… escribir en la caja de dialogos extern.prj y
seleccionar el botón OK
5.- Agregar los archivos fuentes al proyecto
Estando en la ventana project oprimir la tecla <Insert> en la caja de dialogos escribir
el nombre del primer archivo fuente: Princip.cpp y seleccionar el boton “Add” se
observa como el nombre del archivo aparece ahora en la ventana projects, escribir el
nombre del segundo archivo: Archivo2.cpp y seleccionar “Add”, este proceso puede
seguir para cada archivo fuente que se desee agregar, para el programa anterior con
esto basta.
6.- Escribir el código en cada programa fuente
Para abrir un archivo fuente que pertenesca al proyecto basta con posicionarse
sobre él en la ventana Project y obrimir <Enter> se abre la venta de edición donde se
podrá escribir todo el código necesario como muestra la siguiente figura, no olvide
guardar los cambios que se realizan

Figura 1. 2.- Ventana de BorlandC 1.0 para manejo de proyectos
7.- Ejecutar el programa
Con las teclas <Ctrl>+<F9> se compila, enlaza y ejecuta el programa si no
aparecen errores.
• static
Las varibles static son variables permanentes dentro de una función o archivo
según si se declaran como locales o globales respectivamente.
Variables static locales
Cuando se aplica el modificador static a una variable local, el compilador crea
un almacenamiento permanente para ella de forma muy parecida que cuando
crea almacenamiento para una variable global. La diferencia clave entre una
variable local static y una variable global es que la variable local static es
una variable local que retiene su valor entre llamadas de funciones.
Ejemplo:
/*Estatic1.cpp */
#include <conio.h>
void serie();
void main()
{int x;
clrscr();
for (x=0;x<5;x++)
serie();
getch();
}

void serie()
{static int cont=0; //Variable Local static
cont=cont+10;
cout<<"t"<<cont;
}
La salida de este programa será:
10 20 30 40 50
Aunque aun no se ha abordado el tema de la instrucción for se utiliza
en el programa para ilustrar el efecto del especificador static. Cuando se llama
a la función serie() por primera vez se crea el espacio de almacenamiento para
la variable cont y se inicializa con 0, la siguienta línea la incrementa a 10 y es
el primer valor que se visualiza despues de un tabulador, en la siguiente
llamada a la función serie() como no se destruye la variable cont este retiene
su valor, al incrementarse durante la segunda llamada a la función serie()
ahora tendrá 20 y así sucesivamente.
De no definir la variable cont como static (int cont=0; ) cada vez que se llame a
la función serie() se creara un espacio para el y al finalizar se destruirá por lo
que el resultado sería:
10 10 10 10 10
Las variables static son muy importantes en la creación de funciones
independientes, ya que existen varios tipos de rutinas que deben preservar su
valor entre llamadas. Si no se permitiera usar static entonces habría que usar
variables globales y las variables globales dejan la puerta abierta a posibles
efectos secundarios.
Variables static globales
Cuando se aplica el modificador static a una variable global, se indica al
compilador que cree una variable global conocida únicamente en el archivo en
el que se declara. Esto significa que aunque la variable es global, las rutinas de
otros archivos no la reconocerán ni alterarán su contenido directamente,
estando así libre de efectos secundarios.
Ejemplo:
/*Staticg1.cpp, Static.prj */
#include <conio.h>
void Inicia_Semilla(int i);
int serie();
void main()
{int x;
clrscr();
Inicia_Semilla(0);
for (x=0;x<5;x++)
cout<<"t"<<serie();
getch();
}
/*Staticg2.cpp, Static.prj */
static int cont; //ojo
void Inicia_Semilla(int i)
{
cont=i;
}
int serie()
{
cont=cont+10;
return(cont);
}

En el archivo Staticg2.cpp se define la variable cont como variable global
static, lo cual impide que se pueda acceder desde otro archivo, este será vista
y modificada solamente en el propio archivo, por eso se requiere de una
función adicional para poder inicializarla desde otro archivo. La salida del
programa será exactamente igual que el archivo Estatic1.cpp aunque usando
una técnica diferente.
• register
El especificador de almacenamiento register originalmente pedía al
compilador que mantuviera el valor de una variable en un registro de la CPU
en lugar de en memoria, que es donde se almacena normalmente las variables.
Esto significaba que las operaciones debían de realizarse con mayor rapidez.
Actualmente el estándar ANSI simplemente establece “que el acceso al objeto
sea lo más rápido posible”, lo anterior es aplicado a cualquier tipo de dato.
El especificador registers solo puede aplicarse a variables locales y a
los parámetros de una función. Ejemplo:
void imprime_Caracter()
{
register int x;
for (x=0; to N; x++)
cout <<leer_puerto();
}
En este ejemplo se imprimen N caracteres en pantalla retornados por
una función Leer_puerto(), al definir x con el especificador register el ciclo se
lleva a cabo lo más rápido que se pueda.
• auto
Cuando se define una variable sin indicar su especificador, por defauld su
especificador es auto. El especificador de almacenamiento auto declara una
variable con existencia local. Esta es visible solamente en el bloque en el que
es declarada.

EJERCICIOS RESUELTOS
1.- Usando la entrada salida estándar escribir un programa que calculé el área
de un triangulo a partir de su base y altura usando la formula:
Area=(Base*Altura)/2.
/* Area.cpp */
#include <stdio.h>
#include <conio.h>
void main ()
{
float Altura,Base,Area;
clrscr();
printf ("CALCULA EL AREA DE UN TRIANGULO.");
printf("nnTECLEE LA BASE: ");
scanf("%f",&Base);
printf("nTECLEE LA ALTURA: ");
scanf("%f",&Altura);
Area=(Base*Altura)/2;
printf("nEl EL AREA ES: %8.2f", Area);
printf("nPRESIONE <ENTER> PARA TERMINAR");
getch();
}
2.- Usando la entrada salida estándar escribir un programa que calcule el
sueldo de un empleado, solicitando su nombre, Número de horas trabajadas y
el costo por hora.
/* Sueldo.cpp
# include <stdio.h>
# include <conio.h>
void main ()
{
char nombre[40];
float chr, hrst, Sueldo;
clrscr();
printf ("n CALCULA EL SUELDO DE UN EMPLEADO");
printf ("nn NOMBRE DEL EMPLEADO: ");
gets(nombre);
printf ("n HORAS TRABAJADAS: ");
scanf ("%f", &hrst);
printf ("n COSTO POR HORA: ");
scanf ("%f",&chr);
Sueldo=hrst*chr;
printf("n EL SUELDO DE %s es de: $ %8.2f",nombre,Sueldo);
getch();
}

3.- Programa que calcula el precio de venta de un artículo . El precio de venta
se calcula añadiéndole al costo el 120% como utilidad y el 15% de impuesto.
/*Preventa.cpp
# include <stdio.h>
# include <conio.h>
void main ()
{
char descripcion[40];
float CosP, Temp, CVenta;
clrscr();
printf ("n CALCULA EL PRECIO DE VENTA DE UN ARTICULO.");
printf ("nn DESCRIPCION DEL ARTICULO: ");
gets (descripcion);
printf ("n COSTO DE PRODUCCION: ");
scanf("%f", &CosP);
Temp= (CosP+(CosP*1.2));
CVenta=Temp + Temp*.15;
printf("n EL COSTO DE VENTA DE %s ES: $ %8.2f", descripcion,
CVenta);
getch();
}
4. – Usando la entrada salida por flujos escribir un programa que lee la
longitud de los lados A y B de un triangulo y calcule la hipotenusa (C),
aplicando el teorema de Pitágoras, C 2
= A2
+ B2
. o sea:
C 2
= a2
+ b2
.
/* Hipotenu.cpp */
# include <iostream.h>
# include <conio.h>
# include <math.h> //Por las funciones matemáticas
void main ()
{
float A, B, C;
clrscr();
cout<<"CALCULO DE LA HIPOTENUSA";
cout<<"n CATETO A:" ;
cin>>A;
cout<<"n CATETO B:";
cin>>B;
C= sqrt (pow(A,2)+pow(B,2));
cout<<"n LA HIPOTENUSA ES: "<<C;
getch();
}

5.- Programa que lee una temperatura en grados Fahrenheit e imprime su
equivalente en grados Celsius, kelvin, y Rankine. Donde:
Celsius=(Fahrenheit-32)x5/9, Kelvin=Celsius+273, Rankine=Fahrenheit+460.
/*Fahrenhe.cpp */
# include <conio.h>
void main ()
{
float Fahr, Celsius, Kelvin, Rankine;
clrscr();
cout<<"n CONVIERTE GRADOS FAHRENHEIT A CELSIUS, KELVIN, Y
RANKINE.";
cout<<"n GRADOS FAHRENHEIT:";
cin>>Fahr;
Celsius= (Fahr-32)*5/9;
Kelvin=Celsius+273;
Rankine=Fahr+460;
cout<<"n EQUIVALENCIA A GRADOS ";
cout<<"n CELSIUS : "<<Celsius;
cout<<"n KELVIN : "<<Kelvin;
cout<<"n RANKINE : "<<Rankine;
getch();
}
6.- Utilizando el especificador extern, escriba un programa compuesto por 2
archivos que calcule el costo total de venta de 3 productos.
En el archivo Venta2.cpp deberá leer el precio de los 3 productos
vendidos por un comerciante y calculará el total de ventas que tuvo
En el archivo Venta1.cpp deberá imprimir el resultado.
/*Venta1.cpp
Proyecto: Venta.prj */
#include <conio.h>
float Vta;
void func1();
void main()
{
clrscr();
func1();
cout<<"n EL TOTAL DE
VENTAS ES:$ "<<Vta;
getch();
}
/*Venta2.cpp
proyecto: Venta.prj */
#include <conio.h>
extern float Vta; //Variable
externa
void func1()
{
float a,b,c;
cout<<"INTRODUSCA LOS PRECIOS DE
LOS 3 PRODUCTOS:";
cout<<"nnPRIMER PRODUCTO: ";
cin>>a;
cout<<"nSEGUNDO PRODUCTO:";
cin>>b;
cout<<"nTERCERO PRODUCTO:";
cin>>c;
Vta=a+b+c;
}

7.- Utilizando el especificador extern escriba un programa compuesto por 3
archivos que calcule el interés simple y la deuda de un Préstamo a una taza de
interés en N años:
En el archivo Banco2.cpp Leerá la Inversión, La taza de interés y el
número de años, calculando el Interés simple a partir de estos datos
En el archivo Banco3.cpp calculará la deuda acumulada
En el archivo Banco1.cpp mostrará en pantalla tanto el Interés como la
deuda calculados.
/*Banco1.cpp
proyecto: Banco.prj */
# include <conio.h>
float Inversion,Interes,Deuda;
void Calcula();
void Calcula2();
void main()
{
clrscr();
cout<<"CALCULO DE INTERESESnn
";
Calcula();
Calcula2();
cout<<"nLOS INTERESES SON :
"<<Interes;
cout<<"nnLA DEUDA SERIA :
"<<Deuda;
getch();
}
/* Banco2.cpp
Proyecto: Banco.prj */
extern float Inversion, Interes;
void Calcula()
{
float Taza;
int N;
cout<<"nINVERSION :";
cin>>Inversion;
cout<<"nTAZA DE INTERES : ";
cin>>Taza;
cout<<"nCUANTOS AÑOS: ";
cin>>N;
Interes=Inversion*Taza*N;
}
// Banco3.cpp
Proyecto: Banco.prj
extern float Inversion,Interes,Deuda;
void Calcula2()
{
Deuda=Interes+Inversion;
}

EJERCICIOS PROPUESTOS.
1. Elaborar un programa que calcule e imprima el costo de un terreno
cuadrado o rectangular, teniendo como datos la anchura, la longitud en
metros, y el costo del metro cuadrado.
2. Una temperatura en grados centígrados (C) se puede convertir a su
equivalente Fahrenheit (F) con la fórmula:
F = 9/5 C + 32 .
Elaborar un programa que lea una temperatura en grados centígrados
y obtenga e imprima la temperatura Fahrenheit equivalente.
3. Elabore un programa que lea un número de pies y calcule e imprima su
equivalente en yardas, pulgadas, centímetros y metros, de acuerdo con
las siguientes equivalencias:
1 pie = 12 pulgadas, 1 yarda = 3 pies, 1 pulgada =2.54 cms. , 1 metro =
100 cm.
4. Elaborar un programa que lea el artículo y su costo; la utilidad es el
200% y el impuesto es el 15%; calcular e imprimir el artículo, utilidad,
impuesto y precio de venta.
5. Elaborar un programa que lea dos números enteros y positivos e
imprima la media aritmética, es decir, el punto medio entre los dos
números.
6. Elaborar un programa que lea el radio (r) de una esfera, calcule e
imprima el volumen y el área.
Volumen = 4/3 Π r3
Area= 4 Π r2
7. Elaborar un programa que lea una cantidad de horas e imprima su
equivalente en minutos, segundos y días.
8.- Elaborar un programa que lea el valor de w e imprima el valor de z.
Z= 1 / 2Π e –w2/2
9.- Elaborar un programa que lea la cantidad de dólares a comprar y el tipo de
cambio en pesos (costo de un dólar en pesos); calcular e imprimir la cantidad a
pagar en pesos por la cantidad de dólares indicada.
10.- Utilizando el especificador extern, escriba un programa compuesto por 2
archivos que calcule la distancia que recorre la luz en un tiempo dado.
En el archivo Luz2.cpp deberá leer el tiempo en segundos y calculará
la distancia recorrida (Distancia = Velocidad* Tiempo)
En el archivo Luz.cpp deberá imprimir el resultado.

Capitulo 2
Sentencias de control de programa
• Sentencias de Selección
• Sentencias de Iteración
• Sentencias de Salto
• Ejercicios
En este capitulo se discute el conjunto de sentencias de control de programa
que el lenguaje C soporta .

SENTENCIAS DE SELECCIÓN
A las sentencia de selección tambien se les conoce como sentencia
condicional, entre las que se incluyen if y switch
Muchas sentencias de C se basan en una prueba condicional que
determina la acción que se ha de llaver acabo. Una expresión condicional
tiene como resultado un valor cierto o falso. En C cualquier valor distinto de
cero es cierto, incluyendo los números negativos. El 0 es el único valor falso.
• if, if-else
La sintaxis de esta sentencia es:
if (expresion es verdadera)
{
sentencia_1;
sentencias_2;
}
Si al evaluar la expresión, ésta es verdadera se ejecutan las sentencias
del bloque (un bloque comienza con { y termina en }), en caso contrario se
ejecutan las sentencias a continuación del bloque. La cláusula else se puede
añadir a la sentencia if cuando la expresión es falsa y se desean ejecutar
sentencias distintas.
if (expresion es verdadera)
{
sentencia_1;
sentencias_2;
}
else
{
sentencia_11;
sentencias_22;
}
Ejemplo:
/*IF.cpp
Determina si una persona es mayor o menor de edad
usando la Instrucción if*/
#include <conio.h>
void main()
{int Edad;
clrscr();
cout<<"PROPORCIONE SU EDAD: ";
cin>>Edad;
if (Edad<18)
cout<<"n Aun es menor de edad";
else
cout<<"n Es mayor de edad";
getch();
}

Si el usuario escribe un número menor que 18 entonces se muestra el
mensaje “Aun es menor de edad” y si escribe un número igual o mayor que 18
entonces el mensaje será “Es mayor de edad”.
Se pueden anidar if evaluándose de arriba hacia abajo tan pronto como
se encuentre una condición cierta, se ejecuta la sentencia asociada con ella y
se pasa por alto el resto de la escala.
Ejemplo:
/*IF2.cp
Encuentra el mayor de 3 números*/
#include <conio.h>
void main()
{clrscr();
int A=3,B=10,C=15; //Probar con otros valores
int Mayor;
if ((A>B) &&(A>C))
Mayor=A;
else
if ((B>A) && (B>C))
Mayor=B;
else
Mayor=C;
cout<<"El Mayor es: "<<Mayor;
getch();
}
• switch
La sentencia switch permite evaluar una expresión y tomar diversas acciones
en función del resultado de la expresión.
Switch (expresión entera)
{
case constante_1:
sentencia_11;
sentencia_12;
...
break;
case constante_2:
sentencia_21;
sentencia_22;
...
break;
...
default:
sentencia_11;
sentencia_12;
...
}

La siguientes reglas se aplican en el uso de la sentencia switch
• Expresión entera, puede ser una constante, una variable, una llamada a
función o una expresión. La sentencia switch no funciona con datos de
tipo coma flotante
• El valor después de cada etiqueta case debe ser una constante entera o
carácter, como 3 o ‘b’, o bien una expresión que se evalúe a una
constante como ‘a’ +’32’.
• Necesita utilizar una sentencia break después de cada conjunto de
sentencias ejecutables. La sentencia break hace que la ejecución del
programa se reanude después del final de la sentencia switch actual. Si
no se utiliza la sentencia break, la ejecución del programa se reanudará
en las siguientes etiquetas case.
• El conjunto de sentencias case no necesita ser encerradas entre llaves.
• Si ninguno de la valores de constante_1, constante_2, etc. Coincide con
el valor de expresión_entera, se ejecutarán las sentencias que vienen a
continuación de la sentencia opcional default.
Ejemplo:
/*Switch.cpp
Calcula el área de figuras Geométricas
usando la Instrucción switch*/
#include <conio.h>
void main()
{char op;
int L,B,H,R;
float Area;
clrscr();
cout<<" CALCULO DE AREAS";
cout<<"n 1.- RECTANGULO";
cout<<"n 2.- TRINGULO";
cout<<"n 3.- CIRCULO";
cout<<"n Opcion:";
op=getche();
switch (op)
{
case '1': cout<<"nn Lado:";
cin>>L;
Area=L*L;
break;
case '2': cout<<"nn Base:";
cin>>B;
cout<<"n Altura:";
cin>>H;
Area=(B*H)/2;
break;

case '3': cout<<"nn Radio:";
cin>>R;
Area=2*3.1416*R*R;
break;
default:cout<<"nn OPCION NO VALIDA";
}
if ((op>='1')&&(op<='3'))
cout<<"n El Area es: "<<Area;
getch();
}
La salida de una ejecución sería:
CALCULO DE AREAS
1.- RECTANGULO
2.- TRINGULO
3.- CIRCULO
Opcion:2
Base:10
Altura:20
El Area es: 100
Dependiendo de la opción seleccionada por el usuario será el conjunto
de sentencias que se ejecuten, si el usuario selecciona la opción 2 entonces
solicita la Base y la Altura del triangulo almacenando los datos en las
variables B y H respectivamente, calcula el Area con la formula (B*H)/2, en
este punto se interrumpe la secuencia de ejecución de sentencias por la
presencia de la instrucción break, reanudándose este al final del switch donde
se encuentra la instrucción if que evalúa si la opción seleccionada esta en el
intervalo de 1 a 3 para desplegar el contenido del Area calculada. El programa
al no limitar los valores posibles que el usuario puede seleccionar
(Validación), puede introducir cualquier otro valor diferente de 1, 2 ó 3, en
este caso se ejecuta la sentencia hallada después del default y al final del
programa no se imprimiría el Area.
SENTENCIAS DE ITERACIÓN
Entre las sentencias de iteración se incluyen for, while y do-while. Cualquier
sentencia de iteración tiene tres partes importantes que son: Inicialización,
condición e incremento, aunque cada sentencia de iteración debe usarse
preferente según la situación en la mayoría de los casos se puede adaptar
cualquiera de las tres a cualquier situación.
• for
Cuando se desea ejecutar una sentencia simple o compuesta, repetitivamente
un número de veces conocido, la construcción adecuada es la sentencia for.
for(exp_inicialización; condición; expresión_incremento)

instrucción;
Cuando se encuentra la instrucción for se ejecuta primero la expresión de
inicialización, no volviendo a ejecutarse más. Generalmente esta instrucción
realiza la inicialización de la variable de control de ciclo. Tras esto se prueba
la condición. Siempre que condición se evalúa como verdadero, la instrucción
o instrucciones dentro del ciclo son ejecutados. Después de entrar en el ciclo
y ejecutar todas las instrucciones dentro de éste se ejecuta
expresión_incremento. Sin embargo si condición toma el valor Falso, las
instrucciones dentro del ciclo son ignoradas y la ejecución continúa con la
instrucción al final del ciclo.
Cuando se necesitan ejecutar varias instrucciones dentro del ciclo se
hacen necesarias definir el bloque con las llaves {}
Ejemplo:
/*for.cpp
Efectúa ciclos según Ini, Fin, Inc */
#include <conio.h>
void main()
{clrscr();
int x, Ini=0, Inc=5, Fin=20; //Probar con otros valores
for (x=Ini;x<Fin;x=x+Inc)
cout<<"t"<<x;
getch();
}
La salida sería:
0 5 10 15
El programa efectúa un total de 5 ciclos, aunque en este último la condición se
hace falsa por lo que finaliza, transfiriendo el control a la línea de código que
lee una tecla. La secuencia de eventos es el siguiente:
No. Ciclo x condicion Acción
1 0 0<20 Imprime 0
2 5 5<20 Imprime 5
3 10 10<20 Imprime 10
4 15 15<20 Imprime 15
5 20 20<20 Fin ciclo for..

for anidados
Un ciclo for puede colocarse dentro de otro, en este caso el ciclo interno se
ejecutará totalmente cada vez que se ejecute el ciclo que lo contiene.
Ejemplo:
/*for2.cpp
Imprime tabla de multiplicación */
#include <conio.h>
void main()
{clrscr();
int x,y;
int fin1=6, fin2=5; //Probar con otros valores
for (x=1;x<=fin1;x++)
{
cout<<"n";
for (y=1;y<=fin2;y++)
cout<<x*y<<"t";
}
getch();
}
La salida sería:
1 2 3 4 5
2 4 6 8 10
3 6 9 12 15
4 8 12 16 20
5 10 15 20 25
6 12 18 24 30
Por cada valor que toma x en el ciclo for externo se efectúa totalmente el ciclo
for interno es decir y inicialmente toma el valor de 1 y se imprime 1*1=1,
luego y=2 y se imprime 2, y así hasta que y=5 imprime 5, en el siguiente
ciclo la condición se hace falsa dándose por terminado el ciclo interno, pero el
ciclo externo incrementa su valor y ejecuta nuevamente el ciclo interno, este
proceso se sigue hasta que la condición del ciclo externo se hace falsa.
• while
La sentencia while es un ciclo de verificación preliminar, esto significa que la
condición es evaluada antes de entrar a ejecutar las instrucciones dentro del
cuerpo del ciclo. Debido a esto se pueden ejecutar de cero a muchas veces.
while (condicion)
{
instrucción_1;
instrucción_2;
}

La inicialización de un ciclo while por lo regular se realiza antes de ella y el
incremento dentro del bloque.
/*While.cpp
Visualiza números en orden descendente */
#include <conio.h>
void main()
{int ini=50,fin=0,inc=10;
int x=ini; //Inicialización
while (x>fin)
{
cout<<x<<"t";
x=x-inc; //Decremento
}
}
La salida sería:
50 40 30 20 10
• do-while
Difiere tanto de for como de while en que es un ciclo de verificación
posterior, es decir al ciclo se entra al menos una vez , y la condición del ciclo
se prueba al cabo de la primera iteración. Como los ciclos do-while se
ejecutan como mínimo una vez, es mejor utilizarlos en aquellas aplicaciones
en las que se quiere entrar al ciclo.
do
{
Instrucción_1;
Instrucción_2;
}
while(condición);

Ejemplo:
/*Do-While.cpp
Menu de Opciones */
#include <conio.h>
void main()
{clrscr();
char op;
do
{ cout<<" MENU";
cout<<"n 1.-Altas";
cout<<"n 2.-Bajas";
cout<<"n 3.-Consultas";
cout<<"n 4.-Salir";
cout<<"nOpcion:";
do
{
op=getch();
}
while(op!='1'&&op!='2'&&op!='3'&&op!='4');
//Código adicional
}
while (op!='4');
}
La salida del programa sería:
MENU
1.-Altas
2.-Bajas
3.-Consultas
4.-Salir
Opcion:
En este ejemplo se utilizan dos ciclos do-while anidados. El ciclo exterior
controla la terminación del programa y el ciclo interior valida la opción
seleccionada por el usuario, de tal forma que si el usuario selecciona una
opción distinta a las permitidas (1,2,3,4) se vuelve a leer sin salir del ciclo
interior. Solamente si el usuario selecciona la opción ‘4’ la condición del ciclo
exterior será falsa y finalizará, en caso contrario desplegará nuevamente el
menú de opciones.
SENTENCIAS DE SALTO
C tiene cuatro sentencias que llevan a cabo un salto incondicional: return,
goto, break y continue. De ellas, se puede usar return y goto en cualquier
parte del programa . Las sentencias break y continue se deben usar junto con
una sentencia de ciclo.
• return
La sentencias return se usa para volver de una función. Se trata de una
sentencia de salto porque hace que la ejecución vuelva (salte atrás) al punto en
que se hizo la llamada a la función.

Return (expresión)
Donde: el valor de expresión se devuelve como valor a la función.
Se puede usar tantas sentencias return como se quiera en una función.
Sin embargo, la función termina tan pronto como encuentra el primer return.
Una función declarada como void no debe contener una sentencia return. La
función exit() definido en el archivo de cabecera stdio.h es parecida a return
aunque este en lugar de afectar a una función afecta a todo el programa, más
adelante en el tema de funciones se podrán apreciar ejemplos.
• goto
La sentencia goto se puede usar para realizar ciclos usando una etiqueta, o
para saltar a otra parte de un programa, actualmente no es recomendable su
uso por que hace ilegible el código.
Etiqueta:
Setencia_1;
Sentencia_2;
...
goto Etiqueta;
Donde: Etiqueta es cualquier etiqueta valida anterior o posterior al goto.
Ejemplo:
/*goto.cp */
#include <conio.h>
void main()
{clrscr();
int x=0;
Inicio:
x++;
cout<<"n"<<x;
if (x<10)
goto Inicio;
}
• break
La sentencia break tiene dos usos. Se puede usar para finalizar un case en una
sentencia switch. También se puede usar para forzar la terminación inmediata
de una bucle, saltando la evaluación condicional normal del ciclo.
Cuando se encuentra la sentencia break dentro de un ciclo, el ciclo
finaliza inmediatamente.

Ejemplo:
/*break.cpp
Lee caracteres hasta que se pulse la tecla <esc> */
#include <conio.h>
void main()
{ clrscr();
char car;
cout<<"PULSE <Esc> PARA TERMINARnn";
for(;;) //Ciclo infinito
{
car=getche();
if (car==27)
break;
}
}
• continue
La sentencia continue funciona de una forma algo similar a break. Sin
embargo, en vez de forzar la terminación, continue, forza una nueva iteración
del ciclo y salta cualquier código que exista abajo en el bloque.
Ejemplo:
/*continue.cpp
Imprime los números del 0 al 50 que sean múltiplos de 4 */
#include <conio.h>
void main()
{ clrscr();
int x;
for (x=0;x<50;x++)
{
if (x % 4) //Cualquier valor diferente de cero es verdadero
continue;
cout<<x<<" ";
}
}
La salida del programa es:
0 4 8 12 16 20 24 28 32 36 40 44 48

1.- Programa para calcula la calificación final de un alumno, teniendo como
datos N calificaciones parciales (3). Imprime el nombre, la calificación final y
un comentario de “Aprobado” si obtiene 70 o más y “Reprobado” en caso
contrario.
/*Alumno.cpp */
#include <stdio.h>
#include <conio.h>
#define N 3
void main()
{ clrscr();
float Prom,SumCal=0,Cal;
int x;
char Nom[40];
cout<<"DETERMINA SI UN ALUMNO APRUEBA O NO";
cout<<"nnNOMBRE DEL ALUMNO: ";
gets(Nom);
for (x=1;x<=N;x++)
{
cout<<"n CALIFICACION No "<<x<<": ";
cin>>Cal;
SumCal=SumCal+Cal;
}
Prom= SumCal/N;
cout<<"nEL ALUMNO "<<Nom<<" TIENE EL PROMEDIO DE: "
<<Prom<<" Y ESTA:";
if(Prom>=70)
cout<<"nnAPROBADO";
else
cout<<"nnREPROBADO";
getch();
}

2.- En un hotel se hace un descuento del 10% si el cliente se hospeda más de
5 días, el 15% si se hospeda más de 10 días y del 20% si se hospeda más de 15
días. Programa que lee el número de días y el precio diario de la habitación e
imprima el subtotal a pagar, el descuento y el total a pagar.
/*Hotel.cpp */
#include <conio.h>
void main()
{ clrscr();
float CosHabi,Dias,Desc,SubTotal,Total;
cout<<"CALCULA EL COSTO DE UNA HABITACION DE UN HOTEL";
cout<<"nnCOSTO DE LA HABITACION: ";
cin>>CosHabi;
cout<<"No. DE DIAS: ";
cin>>Dias;
SubTotal=CosHabi*Dias;
if (Dias<=5)
Desc=0;
else
if (Dias>5 && Dias<=10)
Desc=SubTotal*.10;
else
if (Dias>10 && Dias<=15)
Desc=SubTotal*.15;
else
Desc=SubTotal*.20;
Total=SubTotal-Desc;
cout<<"nSUB-TOTAL: "<<SubTotal;
cout<<"nDESCUENTO: "<<Desc;
cout<<"n _______ ";
cout<<"nTOTAL: "<<Total;
}

3.- Programa que calcula el salario de un empleado, Según el número de horas
trabajadas por semana y el salario por hora. Si el número de horas trabajadas
es menor o igual a 40 se paga la cuota normal por hora. Si el número de horas
rebasa las 40 horas reglamentarias, el excedente se paga como tiempo extra:
1 a 10 hrs. Extras se paga al doble de la cuota por hora
11 a 20 hrs. Extras se paga al triple de la cuota por hora
21 ó más hrs. Extras se paga al cuádruple de la cuota por hora
En ningún caso el número de horas trabajadas por semana podrá ser superior a
80.
/*Salario.cpp */
#include <stdio.h>
#include <conio.h>
void main()
{ clrscr();
float SalSem, SalHra, SalTE=0,SalBase;
int Hrs;
char Nom[40];
cout<<"CALCULA EL SALARIO SEMANAL DE UN TRABAJADOR";
cout<<"nnNOMBRE DEL TRABAJADOR: ";
gets(Nom);
cout<<"nNo. DE HORAS TRABAJADAS POR SEMANA: ";
do{ //Valida el intervalo de Hrs permitidas
cin>>Hrs;
}
while(Hrs<0 || Hrs>80);
cout<<"nSALARIO POR HORA:";
cin>>SalHra;
if (Hrs<=40)
{
SalBase=Hrs*SalHra;
SalSem=SalBase;
}
else
{
SalBase=40*SalHra;
if (Hrs>40 && Hrs <=50)
SalTE=(Hrs-40)*SalHra*2;
else
if (Hrs>50 && Hrs <=60)
else
SalSem=SalBase+SalTE;
}
cout<<"nTRABAJADOR: "<<Nom;
cout<<"nSALARIO BASE: "<<SalBase;
cout<<"nSALARIO POR TIEMPO EXTRA: "<<SalTE;
cout<<"n _______ ";
cout<<"nSALARIO TOTAL SEMANAL: "<<SalSem;
}

4.- Escribir un programa para dibujar un rectángulo en modo texto en la
pantalla, solicitar las coordenadas x1, y1, x2 y y2, según la siguiente figura:
/*Rectang.cpp */
#include <conio.h>
void main()
{ clrscr();
int x,y,x1,y1,x2,y2;
cout<<"DIBUJA UN RECTANGULO EN PANTALLA SEGUN COORDENADAS";
cout<<"nESCRIBA LAS COORDENADAS X1,Y1,X2,Y2 MODO TEXTO ";
cout<<"SEPARADOS POR UN ESPACIO: n";
cin>>x1>>y1>>x2>>y2;
for (x=x1;x<x2;x++) //Dibuja Línea horizontal
{
gotoxy(x,y1);cout<<"−";
gotoxy(x,y2);cout<<"−";
}
for (y=y1+1;y<y2;y++) //Dibuja línea Vertical
{
gotoxy(x1,y);cout<<"⏐";
gotoxy(x2,y);cout<<"⏐";
}
gotoxy(x1,y1);cout<<"⌐"; //Para las Esquinas
gotoxy(x2,y1);cout<<"¬";
gotoxy(x1,y2);cout<<"└";
gotoxy(x2,y2);cout<<"┘";
}
x1,y1
x2,y2

EJERCICIOS PROPUESTOS.
1.- Elabore un programa para calcular e imprimir el precio de un terreno del
cual se tienen los siguientes datos: largo, ancho y precio por metro cuadrado.
Si el terreno tienen más de 400 metros cuadrados se hace un descuento de
10%, si el terreno tiene más de 500 metros cuadrados el descuento es de 17%
y si tiene más de 1000 el descuento es de 25%.
2.- Una librería vende libros con las condiciones siguientes: Si el cliente es
tipo 1 se le descuenta el 30%, si el cliente es tipo 2 se le descuenta el 20%, si
el cliente es tipo 3 se le descuenta 10%. Cuando el cliente realiza una compra
se generan los datos siguientes: Nombre del cliente, Tipo de cliente (1,2,3),
cantidad de libros, costo por libro. Elabore un programa que lea estos datos e
imprima: Nombre del cliente, Total a pagar, Descuento y el Neto a pagar.
3.- Igual que el ejercicio anterior, pero además:
Si la cantidad de libros solicitada es mayor que 50, se hace un descuento
adicional de 5%; en caso de ser mayor que 100 el descuento adicional es de
10%.
4.- Elaborar un programa que lea los datos de un estudiante: nombre y tres
calificaciones parciales e imprimir el nombre y la calificación final de
acuerdo a lo siguiente: Para aprobar el curso, debe tener 70 o más en cada
una de las tres calificaciones, la calificación final será el promedio. En caso
de haber reprobado uno o más exámenes ordinarios, la calificación final será
NA (NO ACREDITADO).
5.- En un almacén de ventas de trajes si se compra uno se hace el 50% de
descuento, si compra 2 el 55%, si compra 3 el 60% y si compra más de 3 el
65%. Elaborar un programa que lea la cantidad de trajes y el precio unitario
(todos tienen el mismo precio) e imprima el subtotal a pagar, el descuento y
el total a pagar.
6.- Reescriba el programa del ejercicio resulto 1 pero sin usar ciclos
7.- Programa que dibuje una secuencia de N rectangulos (5) a partir de un
rectangulo cuyas coordenadas sean proporcionados por el usuario, los
rectangulos siguientes se irán haciendo más pequeños en forma proporcional
cada vez.

Capitulo 3
Arreglos y Apuntadores
• Que son los arreglos
• Arreglos unidimensionales
• Cadenas
• Arreglos bidimensionales
• Apuntadores
• Punteros y arreglos
• Inicialización de apuntadores
• Funciones de asignación dinámica
• Ejercicios
Los arreglos, punteros y cadenas de caracteres son conceptos relacionados en
el lenguaje C, por esta razón se integran en este capitulo.

QUE SON LOS ARREGLOS
Un arreglo es una colección de variables del mismo tipo que se referencia por
un nombre común. A un elemento específico de un arreglo se accede
mediante un índice. En C todos los arreglos constan de posiciones de
memoria contiguas. La dirección más baja corresponde al primer elemento y
la dirección más alta al último elemento. Los arreglos pueden tener una o más
dimensiones.
ARREGLOS UNIDIMENSIONALES
A los arreglos unidimensionales también se les conoce como listas.
Tipo nombre[Tamaño];
Tipo nombre[];
Donde: tipo Indica el tipo de datos de los elementos del arreglo.
nombre Es el identificador del arreglo
tamaño Especifica el número de elementos del arreglo. El tamaño
puede omitirse cuando se inicializa el arreglo, cuando se declara como un
parámetro en una función o cuando se hace referencia a un arreglo declarado
en otra parte del programa, es recomendable que el tamaño sea definido como
una constante para garantizar no rebasar el límite del arreglo.
Ejemplo:
#define N 30
int Calif[N];
La declaración de la variable anterior hace que el compilador reserve
espacio de memoria para almacenar 30 datos de tipo entero. En C todos los
arreglos tienen el 0 como índice de su primer elemento, por tanto el primer
elemento de la variable anterior sería Calif[0] y el último elemento Calif[29].
El lenguaje C no checa los límites de un arreglo. Es responsabilidad
del programador realizar este tipo de operaciones para no escribir o modificar
porciones de memoria que no le pertenecen al arreglo.
La cantidad de memoria requerida para guardar un arreglo esta
directamente relacionada con su tipo y su tamaño. Para un arreglo
unidimensional, el tamaño total en bytes se calcula:
Tatal en bytes =sizeof(tipo)*tamaño = sizeof(nombre_ arreglo).
Ejemplo:
float Salario[10];
int Tam;
Tam=sizeof (Salario); //Tam=40
• Inicialización de un arreglo
Cuando se crea un arreglo sólo se puede utilizar constantes para inicializarlo
e aquí algunos ejemplos:
int Calif[4]={80,90,75,100};
float real[5]={23.45,90.34,70.1,75,10};

char Caracter[]={‘a’,’b’,’c’,’d’,’e’,’f’};
char Cadena[11]=”HOLA AMIGOS”;
char Cadena2[]=”PROGRAMACIÓN EN LENGUAJE C”;
Para comprender mejor el manejo de los arreglos se presentan a continuación
algunos ejemplos:
/*Arreglo2.cpp.cpp
Visualiza el contenido de un arreglo */
#include <conio.h>
#define N 4
void main()
{ clrscr();
int Cal[N],x;
Cal[0]=90; Cal[1]=80;Cal[2]=100; Cal[3]=70;
for (x=0;x<N;x++)
cout<<"t"<<Cal[x];
getch();
}
La salida es
90 80 100 70
La asignación anterior contempla los cuatro elementos del arreglo desde el
índice 0 hasta el índice 3, durante la impresión se utiliza la constante N para
limitar el número de iteraciones que efectúa el ciclo for
/*Arreglo3.cpp.cpp
Determina el número mayor que existe en un arreglo
unidimensional generados aleatoriamente.*/
#include <conio.h>
#include <stdlib.h> //por random() y randomize()
#define N 10
void main()
{ clrscr();
int Aleat[N],x;
int Mayor=0;
randomize(); //inicializa la semilla
for (x=0;x<N;x++)
{
Aleat[x]=random(100); //genera números aleat. entre 0 y 100
cout<<" "<<Aleat[x];
}
//Encuentra el número mayor en el arreglo
for (x=0;x<N;x++)
if (Aleat[x]>Mayor)
Mayor=Aleat[x];
cout<<"nnEl mayor es: "<<Mayor;
}

En cada ejecución del programa la secuencia de números aleatorios cambia, por lo
consiguiente también la salida, aquí se presenta una de ellas:
79 24 59 18 41 37 64 3 23 29
El mayor es: 79
/*Arreglo4.cpp
Ordena un arreglo unidimensional en forma ascendente
aplicando el método de selección */
#include <conio.h>
#define N 10
void main()
{ clrscr();
int A[N]={79,24,59,18,41,37,64,3,23,29}; //Arr. inicializado
int menor,temp,ind,x,y;
for (x=0;x<N-1;x++)
{
menor=A[x];
ind=x;
for (y=x+1;y<N;y++) //Recorre la lista y determina
if (A[y]<menor) //el menor
{
menor=A[y];
ind=y;
}
if (ind!=x) //Intercambia el elemento menor a la posición x
{
temp=A[x];
A[x]=A[ind];
A[ind]=temp;
}
}
for (x=0;x<N;x++)
cout<<" "<<A[x];
getch();
}
3 18 23 24 29 37 41 59 64 79
El método de ordenación por selección separa el elemento con menor
valor y lo intercambia con el primer elemento. Después, de los N-1 elementos
se busca el siguiente elemento con menor valor y se intercambia con el
segundo elemento y así sucesivamente. El intercambio continúa hasta llegar a
los dos últimos elementos.

CADENAS
C no tiene un tipo de dato para cadenas de caracteres. Una cadena de
caracteres es un arreglo unidimensional, en el cual todos sus elementos son de
tipo char, al final del arreglo contiene el carácter nulo ‘/0’. C soporta una gran
variedad de funciones para el manejo de cadenas definidos en el archivo de
cabecera string.h e aquí algunos:
Nombre Función
strcpy(c1,c2) Copia c2 en c1
strcat(c1,2) Concatena c2 al final de c1
strlen(c1,c2) Devuelve la longitud de la cadena
strcmp(c1,c2) Devuelve 0 si c1 y c2 son iguales; menor que 0 si c1<c2;
mayor que 0 si c1>c2
strchr(c1,car) Devuelve un puntero a la primera ocurrencia de car en c1
strstr(c1,c2) Devuelve un puntero a la primera ocurrencia de c2 en c1
Tabla 3. 1.- Funciones para el manejo de cadena
Ejemplos:
/*Cadena.cpp */
#include <string.h>
#include <conio.h>
void main()
{ clrscr();
int L,x;
char Cad[]="HOLA AMIGO"; //Esta es la cadena
L=strlen(Cad); //Longitud de la cadena
for (x=L-1;x>=0;x--)
cout<<Cad[x];
getch();
}
OGIMA ALOH
Con la función strlen() se calcula la longitud de la cadena, para que en el ciclo
for se inicie a partir del último índice del arreglo de caracteres,
decrementandolo de uno en uno hasta llegar a cero, en cada ciclo se imprime
un carácter a la vez.

/*Cadena2.cpp
Operaciones con cadena */
#include <string.h>
#include <stdio.h>
#include <conio.h>
#define N 40
void main()
{ clrscr();
int L,x;
char C1[]="INSTITUTO ";
char C2[]="TECNOLOGICO DEL ISTMO";
char C[N];
char Est[N];
strcpy(C,C1); //Copia C1 en C
strcat(C,C2); //Concatena C2 en C
cout<<"nDonde Estudio el autor de este libro: ";
gets(Est); //En lugar de cin.getline();
if (strcmp(C,Est)==0)
cout<<"nAcertaste";
else
cout<<"nNo Acertaste, él estudio en el: "<<C;
getch();
}
La salida es:
Donde Estudio el autor de este libro: INSTITUTO POLITECNICO NACIONAL
No Acertaste, él estudio en el: INSTITUTO TECNOLOGICO DEL ISTMO
La lectura de una cadena con la función cin.getline() agrega el carácter
cambio de línea (‘n’) al final de la cadena por lo que jamás abría una
coincidencia con la cadena Concatenada C, en su lugar se usa mejor la función
gets() de stdio.h
ARREGLOS BIDIMENSIONALES
El termino dimensión representa la cantidad de índices utilizados para
referenciar un elemento particular en un arreglo. Los arreglos de más de una
dimensión se conocen como arreglos multidimensionales. La forma más
simple de un arreglo multidimensional es el arreglo bidimensional. Para
definir un arreglo Tabla de enteros bidimensional de tamaño 5,4 se escribiría:
Int Tabla[5][4];
Un arreglo bidimensional puede verse como una tabla, donde el primer
índice denota el número de filas y el segundo el número de columnas, así la
declaración anterior denotaría una tabla de 5 filas por 4 columnas.

0 1 2 3
0 0 5 10 15
1 20 25 30 35
2 40 45 50 55
3 60 65 70 75
4 80 85 90 95
Un programa que asigne valores a los elementos del arreglo bidimensional
como en la tabla anterior sería:
/*A_Bidim.cpp
Asigna valores múltiplos de 5 a un arreglo bidimensional */
#define N 5
#define K 4
void main()
{ int Tabla[N][K];
int x,y,cont=0;
for (x=0;x<N;x++)
for(y=0;y<K;y++)
{
Tabla[x][y]=5*cont;
cont++;
}
}
El programa utiliza dos ciclos for para asignar valores a cada uno de
los elementos del arreglo, el for interno controla el 2º. índice (columnas) y el
for externo el primer índice (filas).
La cantidad de memoria en bytes para almacenar un arreglo
bidimensional, se puede calcular aplicando la siguiente formula.
Tamaño en bytes=sizeof(tipo)*tamaño del 1er. índice * tamaño del 2º. índice
Así la definición int Tabla[5][4]; requeriría: 2*5*4 = 40 Bytes de
memoria.
Ejemplo:
/*A_Bidim2.cpp
Lee las K calificaciones de N alumnos, calcula sus promedios,
el aprovechamiento del grupo y visualiza los resultados */
#include <conio.h>
#define N 5
#define K 4
void main()
Tabla[1][2]

{ clrscr();
int Calif[N][K];
float Prom[N], Aprov;
int x,y, Suma1,Suma2=0;
cout<<"ALUMNO I II III IVn";
for (y=0;y<N;y++)
{
cout<<y+1;
Suma1=0;
for(x=0;x<K;x++)
{
gotoxy(x*5+10,y+2);
cin>>Calif[y][x];
Suma1=Suma1+Calif[y][x];
}
Prom[y]=Suma1/K; //Promedio por alumno
Suma2=Suma2+Prom[y];
}
Aprov=Suma2/N; //Aprovechamiento de grupo
//Visualización
cout<<"nALUMNO I II III IV Prom";
for (y=0;y<N;y++)
{
cout<<"n"<<y+1;
for(x=0;x<K;x++)
{
gotoxy(x*5+10,y+N+4);
cout<<Calif[y][x];
}
gotoxy(x*5+10,y+N+4);
cout<<Prom[y];
}
cout<<"nAprovechamiento : "<<Aprov;
getch();
}
ALUMNO I II III IV
1 70 85 90 80
2 100 90 70 95
3 75 80 85 90
4 70 85 75 100
5 100 100 95 95
ALUMNO I II III IV Prom
1 70 85 90 80 81
2 100 90 70 95 88
3 75 80 85 90 82
4 70 85 75 100 82
5 100 100 95 95 97
Aprovechamiento : 86
El programa esta diseñado para adaptarse ante el cambio de los valores
de las constantes K y N, si en lugar de 4 unidades se requiere de 5 basta con
modificar este valor y todo funciona a la perfección, de igual forma se puede

modificar el valor de N, en lugar de 5 alumnos puede modificarse a 10, en el
programa se incluye la instrucción gotoxy() hallado en el archivo de cabecera
conio.h para el control del cursor en la pantalla.
Un programa bien escrito debe reunir la característica anterior para adaptarse ante un
cambio sin ninguna o casi ninguna modificación en el código.
El lenguaje C permite arreglos de más de dos dimensiones . El límite, si lo hay
depende del compilador. La forma general de declaración de un arreglo
multidimensional es:
Tipo nombre[T1][T2][T3]...[Tn]
Es raro que en algún programa se utilicen los arreglos de tres o más
dimensiones por la cantidad de memoria que se requiere para almacenarlos.
Ejemplo:
Int Tri[20][10][5];
Requeriría de 2*20*10*5 = 2,000 bytes de memoria para almacenarla.
APUNTADORES
Un puntero es una variable que contiene una dirección de memoria.
Normalmente, esa dirección es la posición de otra variable de memoria. Si una
variable contiene la dirección de otra variable, entonces se dice que la primera
variable apunta a la segunda.
Dirección de
memoria
Variable en
memoria
*P 2C00 2C03
2C01
2C02
Car 2C03 ‘A’
Figura 3. 1.- Una variable apuntando a otra
P es una variable de tipo puntero, que apunta a la dirección de memoria
2C03H, es decir apunta a la variable Car, este último es una variable estática
que contiene el carácter ‘A’.
• Declaración de un Apuntador
Una declaración de un puntero consiste en un tipo base, un * y el nombre de la
variable. La forma general para declarar una variable puntero es:
Tipo * nombre;
Ejemplo:
int *P;

Existen dos operadores especiales de punteros: & y *. El & es un operador
monario (sólo necesita un operando) que devuelve la dirección de memoria de
su operando; El *, es el complemento de &, devuelve el valor de la variable
localizada en la dirección que sigue.
Ejemplo:
int x=10,y;
int *P;
P=&x; //Asigna la dirección de x a P
y=*P; //Asigna el cont. de lo apuntado por P a y, o sea 10
Las variables puntero deben apuntar siempre a otra variable de su
mismo tipo, aunque C permite apuntar a una variable de un tipo distinto sin
mensajes de error durante la compilación en algunos casos, hacerlo sería
incongruente. Ejemplo:
float x=10;
int *P;
P=&x; //Las variables no son del mismo tipo
• Aritmética de punteros
Existen sólo dos operaciones aritméticas que se pueden realizar con los
punteros: la suma(++) y la resta(--). Cada vez que se incrementa un puntero,
apunta a la posición de memoria del siguiente elemento de su tipo base. Cada
vez que se decrementa, apunta a la posición del elemento anterior. Con
punteros a caracteres , parece una aritmética normal. Sin embargo, el resto de
los punteros aumentan o decrementan en la longitud del tipo de datos a los que
apuntan. Suponiendo los enteros de 2 bytes de longitud, cuando se incrementa
un puntero a entero, su valor aumenta en 2. El siguiente programa ilustra este
ejemplo:
/*Apunta2.cpp
Aritmética de punteros/
#include <conio.h>
void main()
{ clrscr();
int x;
int *P;
for (x=0;x<5;x++)
{
cout<<P<<" ";
P++; //Incremento
}
}
La salida sería:
0x3dc10000 0x3dc10002 0x3dc10004 0x3dc10006 0x3dc10008

Al principio el apuntador P apunta a la dirección 0x3dc10000, en el
primer ciclo se incrementa un elemento de tipo entero es decir un incremento
de 2 por lo que ahora apunta a la dirección 0x3dc10002, y así sucesivamente
por cada ciclo.
La dirección inicial de una apuntador no siempre va a ser el mismo en
cada ejecución del programa, la dirección inicial dependerá del estado de la
memoria en el momento de la ejecución, es decir dependerá del sistema
operativo y los programas de aplicación cargados. Si al probar el programa
anterior las direcciones no coinciden con los aquí mostrados se debe
precisamente a esta situación.
El siguiente ejemplo muestra un sencillo programa para manejar una
pila de enteros.
/*Apunta3.cpp
Pila de Enteros */
#include <conio.h>
#define N 5
void main()
{ clrscr();
int Pila[N],Val;
int *P,*Tope;
P=Pila; //Apunta al inicio de la pila
Tope=Pila+N; //Apunta al final de la pila
cout<<"Agregue elementos en la pila, 0 para terminar:n";
do
{
cin>>Val;
if (Val!=0) //Agrega elementos a la pila
if(P<Tope)
{
*P=Val; //Agrega el elemento
P++; //Incrementa el apuntador
}
else
cout<<"Pila Llenan";
else //Visualiza el contenido de la pila
{
cout<<"Contenido de la pilan";
do{
P--;
cout<<*P<<"t";
}
while (P>Tope-N);
}
}
while (Val!=0);
getch();
}
La salida Sería:
Agregue elementos en la pila, 0 para terminar:
80

30
95
50
10
40
Pila Llena
0
Contenido de la pila
10 50 95 30 80
PUNTEROS Y ARREGLOS
Existe una estrecha relación entre los punteros y los arreglos, considérese el
siguiente fragmento:
int Arr[10], *Ap;
Ap=Arr;
Aquí Ap ha sido asignado a la dirección del primer elemento del arreglo Arr,
por que el nombre de un arreglo sin índice devuelve la dirección de inicio del
arreglo. Para acceder al tercer elemento del arreglo Arr, se escribe:
Arr[2] ó *(Ap+2);
Ambas sentencias devuelven el tercer valor. Para acceder a los elementos de
un arreglo se puede efectuar por cualquiera de los dos métodos: La indexación
del arreglo ó la aritmética de punteros, la ventaja del segundo método es que
mejora la velocidad. Ejemplo:
/*Apunta4.cpp */
#include <conio.h>
void main()
{ clrscr();
int Arr[10]={10,20,30,40,50,60,70,80,90,100};
int *Ap,x;
Ap=Arr; //Apunta al inicio del arreglo
*(Arr+2)=999; //Cambia el valor del tercer elemento
for (x=0;x<10;x++)
cout<<" "<<*(Ap+x);
}
La Salida sería:
10 20 999 40 50 60 70 80 90 100
INICIALIZACIÓN DE APUNTADORES
Después de declarar un puntero y antes de asignarle un valor, contiene un
valor desconocido. Si se intenta utilizar el puntero antes de darle el valor ,
probablemente se estrellara no sólo el programa sino también el sistema
operativo de la computadora.
Un puntero debe ser correctamente inicializado para evitar cualquier
problema, se pueden usar dos métodos:
• Que apunte a una variable estática
• Asignarle memoria dinámica.

El primer método consiste en asignarle la dirección de otra variable
previamente definida, ya sea una variable local o global, simple ó a un arreglo
como en el programa anterior. El segundo método es el que se aborda a
continuación.
FUNCIONES DE ASIGNACIÓN DINÁMICA
La asignación dinámica es la forma en que un programa puede obtener
memoria mientras se esta ejecutando. A las variables globales se le asigna
memoria en tiempo de compilación. Las variables locales usan la pila. Sin
embargo, durante la ejecución de un programa no se pueden añadir variables
globales o locales. Pero hay ocasiones en que un programa necesita usar
cantidades de memorias variables. Por ejemplo: un procesador de textos, una
hoja de cálculos, etc.
La memoria dispuesta mediante las funciones de asignación dinámica
de C se obtienen del montón (La región de memoria libre que queda entre el
programa y la pila), generalmente contiene una gran cantidad de memoria
libre.
En los programas tradicionales de C, toda asignación dinámica de
memoria se manipula mediante funciones tales como malloc() y free()
hallados en el archivo de cabecera stdlib.h. La función malloc() estable
bloques de memoria, mientras que free() se utiliza para liberar estos bloques
asignados. En C++ se define un método para signar memoria dinámica
utilizando los operadores new y delete.
En el siguiente ejemplo se ilustra un programa para la asignación dinámica de
memoria en C.
/*As_Dinam.cpp*/
#include <conio.h>
#include <stdlib.h> //Por las funciones de asignación dinámica
void main()
{ clrscr();
int *P;
P=(int *) malloc(2*sizeof(int)); //Asigna espacio para 2 Ent.
*P=1;
P++;
*P=2;
cout<<*P<<" "<<*(P-1); //Visualiza: 2 1
free(P); //Libera la memoria
}
El mismo ejemplo pero ahora con new y delete
/*As_Dina2.cpp */
#include <conio.h>
void main()

{ int *P;
P=new int[2]; //Asigna espacio para 2 Enteros (4 bytes)
*P=1;
P++;
*P=2;
cout<<*P<<" "<<*(P-1); //Visualiza: 2 1
delete(P); //libera la memoria
getch();
}
• new
El operador new está disponible inmediatamente en C++, de modo que no se
necesita utilizar ningún archivo de cabecera; new se puede utilizar con dos
formatos:
new tipo Asigna un único elemento
new tipo[Número_elementos] Asigna un Arreglo.
Siempre que se asigne memoria, es necesario comprobar antes de usar
el puntero, el valor devuelto por new, si no existe memoria disponible, el
operador new proporciona el valor 0 ó NULL. Ejemplo:
/*As_Dina3.cpp
Verifica la cantidad de memoria dinámica libre */
#include <conio.h>
void main()
{ clrscr();
char *Cad;
int x;
for (x=1;;x++) //Ciclo infinito
{
Cad=new char[1024]; //Asigna 1 Kbyte de memoria
if (Cad==0)
break;
}
cout<<"Se detecto: "<<x<<" Kbytes de memoria libre";
delete(Cad);
}
La salida es:
Se detecto: 60 Kbytes de memoria libre
El programa realiza un ciclo for infinito, en cada ciclo asigna 1 Kbyte de
memoria dinámica a la variable Cad , cuando la memoria se agota el operador
new retorna un 0 asignándosele a Cad, y es cuando el ciclo deja de ejecutarse
por la presencia de la sentencia break. El valor de x se muestra en pantalla,
indicando la cantidad de memoria asignada.

• delete
El operador delete libera la memoria asignada con new.
delete dirección
El operador delete toma como argumento un puntero. El bloque de memoria
apartado por este puntero se libera, es decir, se devuelve al sistema operativo
para que pueda ser reutilizada.
1.- Un vendedor de equipo de computo desea saber la ganancia total por la
venta de N partes de computadoras. Escribir un programa que lea el costo de
compra de cada uno de los N artículos, calcule el costo de venta agregándole
el 35% de ganancia más el 15% de IVA sobre el precio de compra y visualice
los resultados en forma de tabla.
/*Ganacia.cpp */
#include <conio.h>
#define N 5
void main()
{ clrscr();
int x,GanTotal=0;
float CosArt[N], Gan[N],Iva[N], Venta[N];
cout<<"CALCULA LA GANANCIA EN LA VENTA DE "<<N<<" ARTICULOS";
cout<<"nPROPORCIONE EL COSTO DE LOS ARTICULOSn";
for (x=0;x<N;x++)
{
cout<<"n"<<x+1<<" : ";
cin>>CosArt[x];
Gan[x]=CosArt[x]*.30; //Ganancia por artículo
Iva[x]=CosArt[x]*.15; //IVA por artículo
Venta[x]=CosArt[x]+Gan[x]+Iva[x]; //Prec.de Venta por art.
GanTotal=GanTotal+Gan[x]; //Ganancia total
}
clrscr();
cout<<"ARTIC. COSTO IVA GANACIA VENTA";
for (x=0;x<N;x++)
cout<<"n"<<x+1<<"t"<<CosArt[x]<<"t"<<Iva[x]<<"t"
<<Gan[x] <<"t"<<Venta[x];
cout<<"nttt_____ntGanancia Total= "<<GanTotal;
getch();
}

2.- Programa que lea los nombres de N alumnos y los ordene en forma
ascendente aplicando el método de burbuja.
/*Burbuja.cpp */
#include <string.h>
#include <stdio.h>
#include <conio.h>
#define N 5
void main()
{ clrscr();
char Nom[N][40],Temp[40];
int x,y;
cout<<"ORDENA EN FORMA ASCENDENTE "<<N<<" NOMBRES ";
cout<<"nPROPORCIONE LOS NOMBRESn";
for (x=0;x<N;x++)
{
cout<<x+1<<" : ";
gets(Nom[x]);
}
//Método de burbuja
for (x=1;x<N;x++)
for(y=N-1;y>=x;y--)
if(strcmp(Nom[y-1],Nom[y])>0)
{
strcpy(Temp,Nom[y-1]); //Intercambio de elementos
strcpy(Nom[y-1],Nom[y]);
strcpy(Nom[y],Temp);
}
cout<<"nLOS NOMBRES ORDENADOS SON: ";
for (x=0;x<N;x++)
cout<<"n"<<x+1<<" : "<<Nom[x];
getch();
}
3.- Un grupo de 5 asesores desean conocer los promedios finales obtenidos
por N alumnos de cierta especialidad que desean titularse por la opción VI,
este consiste en un examen escrito y un examen oral. En el examen escrito
cada uno de los asesores registra la calificación obtenido por el alumno
durante la asesoría de su materia, en el examen oral solamente intervienen 3
asesores que dictaminan mediante un conjunto de criterios previamente
establecido la calificación del alumno. Escribir un programa que muestre en
forma de tabla, cada uno de los alumnos, las calificaciones en la fase escrita,
el promedio en la fase escrita, las calificaciones en la fase oral, el promedio en
la fase oral y el promedio general, e indicar con “SI” a los alumnos que
aprueben y “NO” a los alumnos que reprueben. Para poder aprobar el examen
se debe tener un promedio general superior o igual a 80%.

/*OpcionVI.cpp */
#include <conio.h>
#define N 2 //No. de Alumnos
#define M 5 //No. de Materias
#define S 3 //No. de Sinodales
void main()
{ clrscr();
int CalEs[N][M];
int CalOr[N][S];
float PrEs[N], PrOr[N],PrGrl[N];
int x,y, Sum;
cout<<"PROMEDIO GENERAL DE LOS ALUMNOS PARA LA TITULACION";
for (x=0;x<N;x++)
{ Sum=0;
cout<<"nCAL. DE LA FASE ESCRITA, ALUMNO No. "<<x+1<<"n";
for(y=0;y<M;y++)
{
cout<<"MATERIA "<<y+1<<" : ";
cin>>CalEs[x][y]; //Lee Calificaciones fase Escrita
Sum=Sum+CalEs[x][y];
}
PrEs[x]=Sum/M; //Promedio por alumno en la fase Escrita
clrscr();
}
for (x=0;x<N;x++)
{ Sum=0;
cout<<"CALIFICACIONES DE LA FASE ORAL, ALUMNO "<<x+1<<"n";
for(y=0;y<S;y++)
{
cout<<"SINODAL "<<y+1<<" : ";
cin>>CalOr[x][y]; //Lee Calificaciones fase Oral
Sum=Sum+CalOr[x][y];
}
PrOr[x]=Sum/S; //Promedio por alumno en la fase Oral
PrGrl[x]=(PrEs[x]+PrOr[x])/2;
clrscr();
}
cout<<"n RESULTADOS";
cout<<"n MATERIAS SINODALES";
cout<<"nNo. 1 2 3 4 5 PrEsc. 1 2 3 PrOr PrGrl.";
for (x=0;x<N;x++)
{ cout<<"n"<<x<<" "<<CalEs[x][0]<<" "<<CalEs[x][1]<<" "<<CalEs[x][2];
cout<<" "<<CalEs[x][3]<<" "<<CalEs[x][4]<<" "<<PrEs[x];
cout<<"t"<<CalOr[x][0]<<" "<<CalOr[x][1]<<" "<<CalOr[x][2];
cout<<" "<<PrOr[x]<<"tt"<<PrGrl[x];
if (PrGrl[x]>=80)
cout<<"tSI";
else
cout<<"tNO";
}
}

4.- Utilizando apuntadores y asignación dinámica de memoria construya un
programa para dar de alta una serie de N números, comprobar la existencia de
memoria al hacer la asignación dinámica, al finalizar el programa mostrar los
números ordenados en forma ascendente utilizando el método de burbuja.
/*Ordenar.cpp */
#include <stdlib.h>
#include <conio.h>
#define N 5 //Numero de elementos
void main()
{ clrscr();
int *Num,x,y,Temp;
Num=new int [N];
if (Num==0) //Verifica si no hay memoria dinámica
{
cout<<"nNo existe memoria disponible";
exit(0); //Finaliza el programa
}
cout<<"DA DE ALTA UNA SERIE DE "<<N
<<" NUMEROS Y LOS ORDENAn";
for (x=0;x<N;x++) //Alta de la serie de números
{
cout<<"No. "<<x+1<<": ";
cin>>*Num; //Asigna el numero
Num++; //Incrementa el apuntador
}
Num=Num-N; //Apunta al primer elemento
for (x=1;x<N;x++) //Método de burbuja
for(y=N-1;y>=x;y--)
if(*(Num+y-1)>*(Num+y))
{
Temp=*(Num+y-1); //Intercambio de elementos
*(Num+y-1)=*(Num+y);
*(Num+y)=Temp;
}
for (x=0;x<N;x++) //Imprime el contenido del apuntador
{
cout<<"n "<<*Num;
Num++;
}
delete(Num);
getch();
}

Programación en c++

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Similar to Programación en c++

Similar to Programación en c++ (20)

Recently uploaded

Recently uploaded (20)

Programación en c++