Libro digital de programación

Las Generalidades de la
Programación
Estructurada
Turbo C++

07 de Enero de 2014
Universidad Técnica de Ambato
Estefanía Sánchez Núñez

INDICE

Tabla de contenido
¿Qué es el Turbo C++? .................................................................................................................4
CARACTERÍSTICAS ................................................................................................................1
ELEMENTOS BÁSICOS DEL LENGUAJE C ........................................................................2
ESTRUCTURA ..........................................................................................................................4
COMENTARIOS ........................................................................................................................5
IDENTIFICADORES .................................................................................................................6
TIPOS DE DATOS ....................................................................................................................6
SALIDA / ENTRADA ...............................................................................................................11
SENTENCIAS CONDICIONALES ........................................................................................14


Estructura IF...ELSE ..................................................................................................14



Estructura SWITCH ...................................................................................................15

BUCLES ...................................................................................................................................16


Sentencia WHILE .......................................................................................................16

Sentencia DO...WHILE .......................................................................................................17
Sentencia FOR ....................................................................................................................18
Sentencia BREAK ...............................................................................................................19
Sentencia CONTINUE ........................................................................................................19
FUNCIONES ............................................................................................................................20


Funciones ....................................................................................................................21

VECTORES..............................................................................................................................25
MATRICES ...............................................................................................................................28
LIBRERÍAS...............................................................................................................................33
Librería stdio.h .....................................................................................................................33
Librería stdlib.h ....................................................................................................................34
Librería conio.h ....................................................................................................................34
Librería string.h ....................................................................................................................35
BIBLIOGRAFIA ........................................................................................................................95

2

INTRODUCCIÓN
C es un lenguaje de programación de propósito general que ofrece economía
sintáctica, control de flujo y estructuras sencillas y un buen conjunto de
operadores. No es un lenguaje de muy alto nivel y más bien un lenguaje
pequeño, sencillo y no está especializado en ningún tipo de aplicación. Esto lo
hace un lenguaje potente, con un campo de aplicación ilimitado y sobre todo,
se aprende rápidamente. En poco tiempo, un programador puede utilizar la
totalidad del lenguaje.

3

¿Qué es el Turbo C++?
Turbo C es un Entorno de desarrollo integrado y compilador para programar en
lenguaje C, desarrollado por Borland.

El Turbo C++ es un lenguaje de programación que nos ayuda a desarrollar
aplicaciones de distintos tipos, como por ejemplo: juegos programas
educativos, científicos y hasta de administración de bases de dato.

El Turbo C++ se utiliza bajo el sistema operativo DOS, pero se puede acceder
a él desde windows. Normalmente cuando se instala el Turbo C++ sus archivos
se almacenan dentro de una carpeta llamada TC.

4

CARACTERÍSTICAS


El lenguaje C se conoce como un lenguaje compilado. Existen dos tipos
de lenguaje: interpretados y compilados. Los interpretados son aquellos
que necesitan del código fuente para funcionar.
Ejemplo: Basic. Los compilados convierten el código fuente en un
fichero objeto y éste en un fichero ejecutable.



Podemos decir que el lenguaje C es un lenguaje de nivel medio, ya que
combina elementos de lenguaje de alto nivel con la funcionalidad del
lenguaje ensamblador. Es un lenguaje estructurado, ya que permite
crear procedimientos en bloques dentro de otros procedimientos. Hay
que destacar que el C es un lenguaje portable, ya que permite utilizar el
mismo código en diferentes equipos y sistemas informáticos: el lenguaje
es independiente de la arquitectura de cualquier máquina en particular.



Por último solo queda decir que el C es un lenguaje relativamente
pequeño; se puede describir en poco espacio y aprender rápidamente.

1

ELEMENTOS BÁSICOS DEL LENGUAJE C
Un programa en C++ está definido por funciones, grupo de instrucciones que
pueden o no hacer algún cálculo, donde la función principal debe ser llamada
main. La composición general de un programa en C++ es:

Directivas de pre
procesamiento

Declaración
global

Función main

Funciones
definidas po

Comentarios
para entender el
funcionamiento
del programar el
usuario

2

 Directivas
Las directivas de pre procesamiento son definidas para que el compilador
realice algo antes de compilar el programa, revisar si la sintaxis es correcta y
generar un código ejecutable por la computadora, como el incluir funciones de
alguna biblioteca conocida.
La directiva para incluir bibliotecas es como las siguientes:
Ejemplo:
#include <iostream.h>
Esta directiva permitirá utilizar la función de lectura cin y la función de
escritura cout propias de C++.
#include <stdio.h>
Esta directiva permitirá utilizar las funciones de lectura y escritura propias de C.
 Declaraciones Globales
Las declaraciones globales son definiciones de variables o constantes que
serán utilizadas por cualquiera de todas las funciones definidas en el programa.
La sintaxis para la declaración de una variable es:
Tipo var1, var2,..., var3; o bien
Tipo var1= valor, var2,..., var3;
 Función main
La función main( ), es obligatoria en cada programa C, C++. Indica el comienzo
del programa y requiere los paréntesis ( ) a continuación de main( ).

 Funciones definidas por el usuario
La definición de una función se realiza escribiendo primero el tipo del valor de
retorno de la función, después el nombre de la función, posteriormente entre
paréntesis las variables que utilizará dicha función, parámetros, y finalmente las
instrucciones de la función.

3

Ejemplo:
double promedio ( int a, int b, int c)
{

return (a + b + c ) / 3.0; }

Declara a la función promedio, la cual recibe tres valores enteros y calcula y
regresa el promedio de ellos.

 Comentarios
Los comentarios pueden escribirse utilizando alguna de las siguientes formas:
comentando en la misma línea, utiliza //,
Ejemplo:
int edad; // la edad se utilizará como un valor entero.
Comentando entre varias líneas, utiliza /*
*/,

ESTRUCTURA
Todo programa en C consta de una o más funciones, una de las cuales se
llama main. El programa comienza en la función main, desde la cual es posible
llamar a otras funciones.
Cada función estará formada por la cabecera de la función, compuesta por el
nombre de la misma y la lista de argumentos, la declaración de las variables a
utilizar y la secuencia de sentencias a ejecutar.
Ejemplo:
declaraciones globales
main( )
{
variables locales
bloque
}
funcion1( )
{
variables locales
bloque
}
4

COMENTARIOS
A la hora de programar es conveniente añadir comentarios para poder saber
que función tiene cada parte del código, en caso de que no lo utilicemos
durante algún tiempo. Además facilitaremos el trabajo a otros programadores
que puedan utilizar nuestro archivo fuente.
Para poner comentarios en un programa escrito en C usamos los símbolos /*y
*/:
/* Este es un ejemplo de comentario */
/* Un comentario también puede
Estar escrito en varias líneas */
El símbolo /* se coloca al principio del comentario y el símbolo */ al final.
El comentario, contenido entre estos dos símbolos, no será tenido en cuenta
por el compilador.

Palabras clave
Existen una serie de indicadores reservados, con una finalidad determinada,
que no podemos utilizar como identificadores.
A continuación vemos algunas de estas palabras clave:

char

int

float

double if

else

do

while

short

long

extern static

default

break

sizeof

continue

for

register

typedef

5

switch

IDENTIFICADORES
Un identificador es el nombre que damos a las variables y funciones. Está
formado por una secuencia de letras y dígitos, aunque también acepta el
carácter de subrayado. Por contra no acepta los acentos ni la ñ/Ñ.
El primer carácter de un identificador no puede ser un número, es decir que
debe ser una letra o el símbolo.
Se diferencian las mayúsculas de las minúsculas, así num, Num y nuM son
distintos identificadores.

TIPOS DE DATOS


Enteros

Dentro de los enteros están los tipos: short, int, long, los cuales varían en
rango de acuerdo al compilador que se utilice, siendo long rango mayor y
short el de menor.


Flotantes

Dentro de los flotantes C++ tiene los tipos: float, double y long double donde
al igual que los enteros varía el rango de cada uno de acuerdo al
compilador que se utilice. De igual forma el float es el de menor rango
siendo long double el de rango mayor.


Caracteres

Se utiliza el tipo char. Para representar un carácter en C++ se utilizan
apóstrofes.
Ejemplos: „a‟, „b‟ , „5‟
Para representar una cadena de caracteres se utilizan las comillas.
Ejemplo: “soy una cadena”

6

TIPO
char
int
float
double

Tamaño
1 byte
2 bytes
4 bytes
8 bytes

Rango de valores
-128 a 127
-32768 a 32767
3'4 E-38 a 3'4 E+38
1'7 E-308 a 1'7 E+308

Calificadores de tipo
Los calificadores de tipo tienen la misión de modificar el rango de valores de un
determinado tipo de variable. Estos calificadores son cuatro:
 signed
Le indica a la variable que va a llevar signo. Es el utilizado por defecto.
Tamaño
signed char 1 byte
signed int
2 bytes

Rango de valores
-128 a 127
-32768 a 32767

 unsigned
Le indica a la variable que no va a llevar signo (valor absoluto).
Tamaño
unsigned char 1 byte
unsigned int
2 bytes

rango de valores
0 a 255
0 a 65535

 short
Rango de valores en formato corto (limitado). Es el utilizado por defecto.
Tamaño
short char
short int

1 byte
2 bytes

rango de valores
-128 a 127
-32768 a 32767

 long
Rango de valores en formato largo (ampliado).
Tamaño
long int
4 bytes
long double 10 bytes

rango de valores
-2.147.483.648 a 2.147.483.647
-3'36 E-4932 a 1'18 E+4932

También es posible combinar calificadores entre sí:
signed long int = long int = long
unsigned long int = unsigned long
4 bytes

0 a 4.294.967.295 El mayor entero permitido en 'C'
7

Las variables
Una variable es un tipo de dato, referenciado mediante un identificador llamado
de la variable. Su contenido podrá ser modificado a lo largo del programa.
Una variable sólo puede pertenecer a un tipo de dato. Para poder utilizar una
variable, primero tiene que ser declarada:
[calificador] <tipo> <nombre>
Es posible inicializar y declarar más de una variable del mismo tipo en la misma
sentencia:
[calificador]<tipo><nombre1>,<nombre2>=<valor>,<nombre3>=<valor>,<no
mbre4>
Ejemplo:
/* Uso de las variables */
#include <stdio.h>
main() /* Suma dos valores */
{
int num1=4,num2,num3=6;
printf("El valor de num1 es %d",num1);
printf("nEl valor de num3 es %d",num3);
num2=num1+num3;
printf("nnum1 + num3 = %d",num2);
}

¿Dónde se declaran?
Las variables pueden ser de dos tipos según el lugar en que las declaremos:
globales o locales.
La variable global se declara antes de la main( ). Puede ser utilizada en
cualquier parte del programa y se destruye al finalizar éste.

8

La variable local se declara después de la main( ), en la función en que vaya a
ser utilizada. Sólo existe dentro de la función en que se declara y se destruye al
finalizar dicha función.
El identificador, nombre de la variable, no puede ser una palabra clave y los
caracteres que podemos utilizar son las letras: a-z y A-Z, la ñ o Ñ no está
permitida, los números: 0-9 y el símbolo de subrayado. Además hay que tener
en cuenta que el primer carácter no puede ser un número.
Ejemplo:
/* Declaración de variables */
#include <stdio.h>
int a;
main() /* Muestra dos valores */
{
int b=4;
printf("b es local y vale %d",b);
a=5;
printf("na es global y vale %d",a);
}

Constantes
Al contrario que las variables, las constantes mantienen su valor a lo largo de
todo el programa.
Para indicar al compilador que se trata de una constante, usaremos la directiva
#define:
#define <identificador> <valor>
Observa que no se indica el punto y coma de final de sentencia ni tampoco el
tipo de dato.
La directiva #define no sólo nos permite sustituir un nombre por un valor
numérico, sino también por una cadena de caracteres.
El valor de una constante no puede ser modificado de ninguna manera.
Ejemplo:
/* Uso de las constantes */
#include <stdio.h>
#define pi 3.1416
9

#define escribe printf
main() /* Calcula el perímetro */
{
int r;
escribe("Introduce el radio: ");
scanf("%d",&r);
escribe("El perímetro es: %f",2*pi*r);
}

Secuencias de escape
Ciertos caracteres no representados gráficamente se pueden representar
mediante lo que se conoce como secuencia de escape.
A continuación vemos una tabla de las más significativas:

n

salto de línea

b

retroceso

t

tabulación horizontal

v

tabulación vertical

contrabarra

f

salto de página

'

apóstrofe

"

comillas dobles

0

fin de una cadena de caracteres

Ejemplo:
/* Uso de las secuencias de escape */
#include <stdio.h>
main() /* Escribe diversas sec. de escape */
{
printf("Me llamo "Nemo" el grande");

10

printf("nDirección: C Mayor 25");
printf("nHa salido la letra 'L'");
printf("nRetrocesob");
printf("ntEsto ha sido todo");
}

Inclusión de ficheros
En la programación en C es posible utilizar funciones que no estén incluidas en
el propio programa. Para ello utilizamos la directiva #include, que nos permite
añadir librerías o funciones que se encuentran en otros ficheros a nuestro
programa.
Para indicar al compilador que vamos a incluir ficheros externos podemos
hacerlo de dos maneras, siempre antes de las declaraciones.
1. Indicándole al compilador la ruta donde se encuentra el fichero.
#include "misfunc.h"
#include "c:includesmisfunc.h"
2. Indicando que se encuentran en el directorio por defecto del compilador.
#include <misfunc.h>

SALIDA / ENTRADA


Sentencia printf( )

La rutina printf permite la aparición de valores numéricos, caracteres y cadenas
de texto por pantalla.
El prototipo de la sentencia printf es el siguiente:
printf(control,arg1,arg2...);
En la cadena de control indicamos la forma en que se mostrarán los
argumentos posteriores. También podemos introducir una cadena de texto, sin
necesidad de argumentos, o combinar ambas posibilidades, así como
secuencias de escape.

11

En el caso de que utilicemos argumentos deberemos indicar en la cadena de
control tantos modificadores como argumentos vayamos a presentar.
El modificador está compuesto por el carácter % seguido por un carácter de
conversión, que indica de qué tipo de dato se trata.
Ejemplo:
/* Uso de la sentencia printf() 1. */
#include <stdio.h>
main() /* Saca por pantalla una suma */
{
int a=20,b=10;
printf("El valor de a es %dn",a);
printf("El valor de b es %dn",b);
printf("Por tanto %d+%d=%d",a,b,a+b);
}

Los modificadores más utilizados son:
%c
%d
%u
%o
%x
%e
%f
%s
%p

Un único carácter
Un entero con signo, en base decimal
Un entero sin signo, en base decimal
Un entero en base octal
Un entero en base hexadecimal
Un número real en coma flotante, con exponente
Un número real en coma flotante, sin exponente
Una cadena de caracteres
Un puntero o dirección de memoria

Ejemplo:
#include <stdio.h>
main() /* Modificadores 1 */
{
char cad[]="El valor de";
int a=-15;
unsigned int b=3;

12

float c=932.5;
printf("%s a es %dn",cad,a);
printf("%s b es %un",cad,b);
printf("%s c es %e o %f",cad,c,c);
}
El formato completo de los modificadores es el siguiente:
% [signo] [longitud] [.precisión] [l/L] conversión
Signo: indicamos si el valor se ajustará a la izquierda, en cuyo caso
utilizaremos el signo menos, o a la derecha.
Longitud: especifica la longitud máxima del valor que aparece por pantalla. Si
la longitud es menor que el número de dígitos del valor, éste aparecerá
ajustado a la izquierda.
Precisión: indicamos el número máximo de decimales que tendrá el valor.
l/L: utilizamos l cuando se trata de una variable de tipo long y L cuando es de
tipo double.
Ejemplo:
#include <stdio.h>
main() /* Modificadores 2 */
{
char cad[ ]="El valor de";
int a=25986;
long int b=1976524;
float c=9.57645;
printf("%s a es %9dn",cad,a);
printf("%s b es %ldn",cad,b);
printf("%s c es %.3f",cad,c);
}


Sentencia scanf( )

La rutina scanf permite entrar datos en la memoria del ordenador a través del
teclado.

13

El prototipo de la sentencia scanf es el siguiente:
scanf(control,arg1,arg2...);
En la cadena de control indicaremos, por regla general, los modificadores que
harán referencia al tipo de dato de los argumentos. Al igual que en la sentencia
printf los modificadores estarán formados por el carácter % seguido de un
carácter de conversión. Los argumentos indicados serán, nuevamente, las
variables.
La principal característica de la sentencia scanf es que necesita saber la
posición de la memoria del ordenador en que se encuentra la variable para
poder almacenar la información obtenida. Para indicarle esta posición
utilizaremos el símbolo ampersand &, que colocaremos delante del nombre de
cada variable. Esto no será necesario en los arrays.
Ejemplo:
/* Uso de la sentencia scanf(). */
#include <stdio.h>
main() /* Solicita dos datos */
{
char nombre[10];
int edad;
printf("Introduce tu nombre: ");
scanf("%s",nombre);
printf("Introduce tu edad: ");
scanf("%d",&edad);
}

SENTENCIAS CONDICIONALES
Este tipo de sentencias permiten variar el flujo del programa en base a unas
determinadas condiciones.
Existen varias estructuras diferentes:


Estructura IF...ELSE

Sintaxis:
if (condición) sentencia;
La sentencia solo se ejecuta si se cumple la condición. En caso contrario el
programa sigue su curso sin ejecutar la sentencia.

14

Otro formato:
if (condición) sentencia1;
else sentencia2;
Si se cumple la condición ejecutará la sentencia1, sinó ejecutará la sentencia2.
En cualquier caso, el programa continuará a partir de la sentencia2.
Ejemplo:
/* Uso de la sentencia condicional IF. */
#include <stdio.h>
main() /* Simula una clave de acceso */
{
int usuario,clave=18276;
printf("Introduce tu clave: ");
scanf("%d",&usuario);
if(usuario==clave)
printf("Acceso permitido");
else
printf("Acceso denegado");
}



Estructura SWITCH

Esta estructura se suele utilizar en los menús, de manera que según la opción
seleccionada se ejecuten una serie de sentencias.
Su sintaxis es:
switch (variable){
case contenido_variable1:
sentencias;
break;
case contenido_variable2:
sentencias;
break;
default:
sentencias;
}
15

Cada case puede incluir una o más sentencias sin necesidad de ir entre llaves,
ya que se ejecutan todas hasta que se encuentra la sentencia BREAK. La
variable evaluada sólo puede ser de tipo entero o caracter. default ejecutará las
sentencias que incluya, en caso de que la opción escogida no exista.
Ejemplo:
/* Uso de la sentencia condicional SWITCH. */
#include <stdio.h>
main() /* Escribe el día de la semana */
{
int dia;
printf("Introduce el día: ");
scanf("%d",&dia);
switch(dia){
case 1: printf("Lunes"); break;
case 2: printf("Martes"); break;
case 3: printf("Miércoles"); break;
case 4: printf("Jueves"); break;
case 5: printf("Viernes"); break;
case 6: printf("Sábado"); break;
case 7: printf("Domingo"); break;
}
}

BUCLES
Los bucles son estructuras que permiten ejecutar partes del código de forma
repetida mientras se cumpla una condición.
Esta condición puede ser simple o compuesta de otras condiciones unidas por
operadores lógicos.
 Sentencia WHILE
Su sintaxis es:
while (condición) sentencia;
16

Con esta sentencia se controla la condición antes de entrar en el bucle. Si ésta
no se cumple, el programa no entrará en el bucle.
Naturalmente, si en el interior del bucle hay más de una sentencia, éstas
deberán ir entre llaves para que se ejecuten como un bloque.
Ejemplo:
/* Uso de la sentencia WHILE. */
#include <stdio.h>
main() /* Escribe los números del 1 al 10 */
{
int numero=1;
while(numero<=10)
{
printf("%dn",numero);
numero++;
}
}

Sentencia DO...WHILE
Su sintaxis es:
do{
sentencia1;
sentencia2;
}while (condición);
Con esta sentencia se controla la condición al final del bucle. Si ésta se
cumple, el programa vuelve a ejecutar las sentencias del bucle.
La única diferencia entre las sentencias while y do-while es que con la
segunda el cuerpo del bucle se ejecutará por lo menos una vez.
Ejemplo:
/* Uso de la sentencia DO...WHILE. */
#include <stdio.h>¡
main() /* Muestra un menú si no se pulsa 4 */
{
char seleccion;
17

do{
printf("1.- Comenzarn");
printf("2.- Abrirn");
printf("3.- Grabarn");
printf("4.- Salirn");
printf("Escoge una opción: ");
seleccion=getchar();
switch(seleccion){
case '1':printf("Opción 1");
break;
break;
}
}while(seleccion!='4');
}

Sentencia FOR
Su sintaxis es:
for (inicialización;condición;incremento){
sentencia1;
sentencia2;
}
La inicialización indica una variable de control que condiciona la repetición del
bucle. Si hay más, van separadas por comas:
for (a=1,b=100;a!=b;a++,b- -){
El flujo del bucle FOR transcurre de la siguiente forma:

Ejemplo:
/* Uso de la sentencia FOR. */
#include <stdio.h>
main() /* Escribe la tabla de multiplicar */
{
18

int num,x,result;
printf("Introduce un número: ");
scanf("%d",&num);
for (x=0;x<=10;x++){
result=num*x;
printf("n%d por %d = %dn",num,x,result);
}
}

Sentencia BREAK
Esta sentencia se utiliza para terminar la ejecución de un bucle o salir de una
sentencia SWITCH.
Sentencia CONTINUE
Se utiliza dentro de un bucle. Cuando el programa llega a una sentencia
CONTINUE no ejecuta las líneas de código que hay a continuación y salta a la
siguiente iteración del bucle.
Y aquí termina el capítulo dedicado a los bucles. Existe otra sentencia, GOTO,
que permite al programa saltar hacia un punto identificado con una etiqueta,
pero el buen programador debe prescindir de su utilización. Es una sentencia
muy mal vista en la programación en 'C'.
Ejemplo:
/* Uso de la sentencia CONTINUE. */
#include <stdio.h>
main() /* Escribe del 1 al 100 menos el 25 */
{
int numero=1;
while(numero<=100)
{
if (numero==25)
{
numero++;

19

continue;
}
printf("%dn",numero);
numero++;
}
}

FUNCIONES
 Tiempo de vida de los datos
Según el lugar donde son declaradas puede haber dos tipos de variables.
Globales: las variables permanecen activas durante todo el programa. Se
crean al iniciarse éste y se destruyen de la memoria al finalizar. Pueden ser
utilizadas en cualquier función.
Locales: las variables son creadas cuando el programa llega a la función en la
que están definidas. Al finalizar la función desaparecen de la memoria.
Si dos variables, una global y una local, tienen el mismo nombre, la local
prevalecerá sobre la global dentro de la función en que ha sido declarada.
Dos variables locales pueden tener el mismo nombre siempre que estén
declaradas en funciones diferentes.
Ejemplo:
/* Variables globales y locales. */
#include <stdio.h>
int num1=1;
main() /* Escribe dos cifras */
{
int num2=10;
printf("%dn",num1);
printf("%dn",num2);
}

20

 Funciones
Las funciones son bloques de código utilizados para dividir un programa en
partes más pequeñas, cada una de las cuáles tendrá una tarea determinada.
Su sintaxis es:
tipo_función nombre_función (tipo y nombre de argumentos)
{
bloque de sentencias
}
Tipo función: puede ser de cualquier tipo de los que conocemos. El valor
devuelto por la función será de este tipo. Por defecto, es decir, si no indicamos
el tipo, la función devolverá un valor de tipo entero ( int ). Si no queremos que
retorne ningún valor deberemos indicar el tipo vacío ( void ).
Nombre función: es el nombre que le daremos a la función.
Tipo y nombre de argumentos: son los parámetros que recibe la función. Los
argumentos de una función no son más que variables locales que reciben un
valor. Este valor se lo enviamos al hacer la llamada a la función. Pueden existir
funciones que no reciban argumentos.
Bloque de sentencias: es el conjunto de sentencias que serán ejecutadas
cuando se realice la llamada a la función.
Las funciones pueden ser llamadas desde la función main o desde otras
funciones. Nunca se debe llamar a la función main desde otro lugar del
programa. Por último recalcar que los argumentos de la función y sus variables
locales se destruirán al finalizar la ejecución de la misma.



Declaración de las funciones

Al igual que las variables, las funciones también han de ser declaradas. Esto es
lo que se conoce como prototipo de una función. Para que un programa en C
sea compatible entre distintos compiladores es imprescindible escribir los
prototipos de las funciones.
Los prototipos de las funciones pueden escribirse antes de la función main o
bien en otro fichero. En este último caso se lo indicaremos al compilador
mediante la directiva #include.
En el ejemplo adjunto podremos ver la declaración de una función, prototipo. Al
no recibir ni retornar ningún valor, está declarada como void en ambos lados.
También vemos que existe una variable global llamada num. Esta variable es
reconocible en todas las funciones del programa. Ya en la función main
21

encontramos una variable local llamada num. Al ser una variable local, ésta
tendrá preferencia sobre la global. Por tanto la función escribirá los números 10
y 5.
Ejemplo:
/* Declaración de funciones. */
#include <stdio.h>
void funcion(void); /* prototipo */
int num=5; /* variable global */
main() /* Escribe dos números */
{
int num=10; /* variable local */
printf("%dn",num);
funcion(); /* llamada */
}
void funcion(void)
{
printf("%dn",num);
}


Paso de parámetros a una función

Las funciones pueden retornar un valor. Esto se hace mediante la instrucción
return, que finaliza la ejecución de la función, devolviendo o no un valor.
En una misma función podemos tener más de una instrucción return. La forma
de retornar un valor es la siguiente:
return ( valor o expresión );
El valor devuelto por la función debe asignarse a una variable. De lo contrario,
el valor se perderá.
En el ejemplo puedes ver lo que ocurre si no guardamos el valor en una
variable. Fíjate que a la hora de mostrar el resultado de la suma, en el printf,
también podemos llamar a la función.
Ejemplo:
/* Paso de parámetros. */
#include <stdio.h>
int suma(int,int); /* prototipo */
22

main() /* Realiza una suma */
{
int a=10,b=25,t;
t=suma(a,b); /* guardamos el valor */
printf("%d=%d",suma(a,b),t);
suma(a,b); /* el valor se pierde */
}
int suma(int a,int b)
{
return (a+b);
}

Paso de parámetros
Existen dos formas de enviar parámetros a una función:
Por valor: cualquier cambio que se realice dentro de la función en el
argumento enviado, NO afectará al valor original de las variables utilizadas en
la llamada. Es como si trabajáramos con una copia, no con el original. No es
posible enviar por valor arrays, deberemos hacerlo por referencia.
Por referencia: lo que hacemos es enviar a la función la dirección de memoria
donde se encuentra la variable o dato. Cualquier modificación SI afectará a las
variables utilizadas en la llamada. Trabajamos directamente con el original.
Ejemplo:
/* Paso por valor. */
#include <stdio.h>
void intercambio(int,int);
main() /* Intercambio de valores */
{
int a=1,b=2;
printf("a=%d y b=%d",a,b);
intercambio(a,b); /* llamada */
}
void intercambio (int x,int y)
{
int aux;
aux=x;
x=y;
23

y=aux;
printf("a=%d y b=%d",x,y);
}
Para enviar un valor por referencia se utiliza el símbolo &, ampersand, delante
de la variable enviada. Esto le indica al compilador que la función que se
ejecutará tendrá que obtener la dirección de memoria en que se encuentra la
variable.
Vamos a fijarnos en los ejemplos. En el ejemplo anterior podrás comprobar que
antes y después de la llamada, las variables mantienen su valor. Solamente se
modifica en la función intercambio-paso por valor.
En el siguiente ejemplo las variables intercambian su valor tras la llamada de la
función-paso por referencia.
Las variables con un * son conocidas como punteros, el único dato en 'C' que
puede almacenar una dirección de memoria.
Ejemplo:
/* Paso por referencia. */
#include <stdio.h>
void intercambio(int *,int *);
main() /* Intercambio de valores */
{
int a=1,b=2;
intercambio(&a,&b); /* llamada */
}
void intercambio (int *x,int *y)
{
int aux;
aux=*x;
*x=*y;
*y=aux;
printf("a=%d y b=%d",*x,*y);
}

24

Los argumentos de la función main:
La función main no podía ser menos y también puede recibir argumentos, en
este caso desde el exterior.
Los argumentos que puede recibir son:
argc: es un contador. Su valor es igual al número de argumentos escritos en la
línea de comandos, contando el nombre del programa que es el primer
argumento.
argv: es un puntero a un array de cadenas de caracteres que contiene los
argumentos, uno por cadena.
En este ejemplo vamos a ver un pequeño programa que escribirá un saludo por
pantalla. El programa FUNCION6.EXE.
Ejemplo:
/* Argumentos de la main. */
#include <stdio.h>
main(int argc,char *argv[]) /* argumentos */
{
printf("nCurso de Programación en C - Copyright (c) 1997-2001,
Sergio Pachon");
printf("Programa de ejemplo.nn");
if (argc<2)
{
printf("Teclee: funcion6 su_nombre");
exit(1); /* fin */
}
printf("Hola %s",argv[1]);
}

VECTORES
Un vector es un array unidimensional, es decir, sólo utiliza un índice para
referenciar a cada uno de los elementos. Un array es un identificador que
referencia un conjunto de datos del mismo tipo. Imagina un tipo de dato int;
podremos crear un conjunto de datos de ese tipo y utilizar uno u otro con sólo
cambiar el índice que lo referencia. El índice será un valor entero y positivo. En
C los arrays comienzan por la posición 0.
25

Su declaración será:
tipo nombre [tamaño];
El tipo puede ser cualquiera de los ya conocidos y el tamaño indica el número
de elementos del vector, se debe indicar entre corchetes [ ]. En el ejemplo
puedes observar que la variable i es utilizada como índice, el primer for sirve
para rellenar el vector y el segundo para visualizarlo. Como ves, las posiciones
van de 0 a 9, total 10 elementos.
Ejemplo:
/* Declaración de un array. */
#include <stdio.h>
main() /* Rellenamos del 0 - 9 */
{
int vector[10],i;
for (i=0;i<10;i++) vector[i]=i;
for (i=0;i<10;i++) printf(" %d",vector[i]);
}
Podemos inicializar, asignarle valores un vector en el momento de declararlo.
Si lo hacemos así no es necesario indicar el tamaño.
Su sintaxis es:
tipo nombre []={ valor 1, valor 2...}
Ejemplos:
int vector[ ]={1,2,3,4,5,6,7,8};
char vector[ ]="programador";
char vector[ ]={'p','r','o','g','r','a','m','a','d','o','r'};
Una particularidad con los vectores de tipo char, cadena de caracteres, es que
deberemos indicar en que elemento se encuentra el fin de la cadena mediante
el carácter nulo (0). Esto no lo controla el compilador, y tendremos que ser
nosotros los que insertemos este carácter al final de la cadena.
Por tanto, en un vector de 10 elementos de tipo char podremos rellenar un
máximo de 9, es decir, hasta vector[8]. Si sólo rellenamos los 5 primeros, hasta
vector[4], debemos asignar el carácter nulo a vector[5]. Es muy sencillo:
vector[5]='0'; .

26

Ejemplo de cómo se rellena un vector de tipo char.
/* Vector de tipo char. */
#include <stdio.h>
main() /* Rellenamos un vector char */
{
char cadena[20];
int i;
for (i=0;i<19 && cadena[i-1]!=13;i++)
cadena[i]=getche( );
if (i==19) cadena[i]='0';
else cadena[i-1]='0';
printf("n%s",cadena);
}
Podemos ver que en el for se encuentran dos condiciones:
1.- Que no se hayan rellenado todos los elementos (i<19).
2.- Que el usuario no haya pulsado la tecla ENTER, cuyo código ASCII
es 13. (cadena[x-i]!=13).
También podemos observar una nueva función llamada getche( ), que se
encuentra en conio.h. Esta función permite la entrada de un carácter por
teclado. Después se encuentra un if, que comprueba si se ha rellenado todo el
vector. Si es cierto, coloca el carácter nulo en el elemento nº20 (cadena[19]).
En caso contrario tenemos el else, que asigna el carácter nulo al elemento que
almacenó el carácter ENTER.
En resumen: al declarar una cadena deberemos reservar una posición más que
la longitud que queremos que tenga dicha cadena.

Llamadas a funciones con arrays
Como ya se comentó en el tema anterior, los arrays únicamente pueden ser
enviados a una función por referencia. Para ello deberemos enviar la dirección
de memoria del primer elemento del array. Por tanto, el argumento de la
función deberá ser un puntero.
Ejemplo:
/* Envío de un array a una función. */
#include <stdio.h>
void visualizar(int []); /* prototipo */
main() /* rellenamos y visualizamos */
{
int array[25],i;
27

for (i=0;i<25;i++)
{
printf("Elemento nº %d",i+1);
scanf("%d",&array[i]);
}
visualizar(&array[0]);
}
void visualizar(int array[]) /* desarrollo */
{
int i;
for (i=0;i<25;i++) printf("%d",array[i]);
}
En el ejemplo se puede apreciar la forma de enviar un array por referencia. La
función se podía haber declarado de otra manera, aunque funciona
exactamente igual:
declaración o prototipo
void visualizar(int *);
desarrollo de la función
void visualizar(int *array)

MATRICES
Una matriz es un array multidimensional. Se definen igual que los vectores
excepto que se requiere un índice por cada dimensión.
Su sintaxis es la siguiente:
tipo nombre [tamaño 1][tamaño 2]...;
Una matriz bidimensional se podría representar gráficamente como una tabla
con filas y columnas.
La matriz tridimensional se utiliza, por ejemplo, para trabajos gráficos con
objetos 3D.
En el ejemplo puedes ver como se rellena y visualiza una matriz bidimensional.
Se necesitan dos bucles para cada una de las operaciones. Un bucle controla
las filas y otro las columnas.
28

Ejemplo:
/* Matriz bidimensional. */
#include <stdio.h>
main() /* Rellenamos una matriz */
{
int x,i,numeros[3][4];
/* rellenamos la matriz */
for (x=0;x<3;x++)
for (i=0;i<4;i++)
scanf("%d",&numeros[x][i]);
/* visualizamos la matriz */
for (x=0;x<3;x++)
for (i=0;i<4;i++)
printf("%d",numeros[x][i]);
}

Si al declarar una matriz también queremos inicializarla, habrá que tener en
cuenta el orden en el que los valores son asignados a los elementos de la
matriz.
Ejemplos:
int numeros[3][4]={1,2,3,4,5,6,7,8,9,10,11,12};
quedarían asignados de la siguiente manera:
numeros[0][0]=1 numeros[0][1]=2

numeros[0][2]=3

numeros[0][3]=4
numeros[1][0]=5 numeros[1][1]=6

numeros[1][2]=7

numeros[1][3]=8
numeros[2][0]=9 numeros[2][1]=10 numeros[2][2]=11
numeros[2][3]=12

También se pueden inicializar cadenas de texto:
char
dias[7][10]={"lunes","martes","miércoles","jueves","viernes","sábado","domingo"
};
29

Para referirnos a cada palabra bastaría con el primer índice:
printf("%s",dias[i]);


PUNTEROS

Un puntero es una variable que contiene la dirección de memoria de otra
variable. Se utilizan para pasar información entre una función y sus puntos de
llamada.

Declaración
Su sintaxis es la siguiente:
tipo *nombre;
Donde nombre es, naturalmente, el nombre de la variable, y tipo es el tipo del
elemento cuya dirección almacena el puntero.

Operadores
Existen dos operadores especiales para trabajar con punteros: & y *.
El primero devuelve la dirección de memoria de su operando. Por ejemplo, si
queremos guardar en el puntero x la dirección de memoria de la variable num,
deberemos hacer lo siguiente:
x=#
El segundo devuelve el valor de la variable cuya dirección es contenida por el
puntero. Este ejemplo sitúa el contenido de la variable apuntada por x, es decir
num, en la variable a:
a=*x;
Asignación
Los punteros se asignan igual que el resto de las variables. El programa
ejemplo mostrará las direcciones contenidas en p1 y p2, que será la misma en
ambos punteros.
Ejemplo:
/* Asignaciones de punteros. */
#include <stdio.h>
main() /* Asignamos direcciones */
{
int a;
int *p1,*p2;
30

p1=&a;
p2=p1;
printf("%p %p",p1,p2);
}
Aritmética de direcciones
Es posible desplazar un puntero recorriendo posiciones de memoria. Para ello
podemos usar los operadores de suma, resta, incremento y decremento (+, -,
++, - -). Si tenemos un puntero ( p1 ) de tipo int ( 2 bytes ), apuntando a la
posición 30000 y hacemos: p1=p1+5; el puntero almacenará la posición 30010,
porque apunta 5 enteros por encima ( 10 bytes más ).

Concepto de estructura
Una estructura es un conjunto de una o más variables, de distinto tipo,
agrupadas bajo un mismo nombre para que su manejo sea más sencillo.
Su utilización más habitual es para la programación de bases de datos, ya que
están especialmente indicadas para el trabajo con registros o fichas.
La sintaxis de su declaración es la siguiente:
{
tipo_variable nombre_variable1;
};
Donde tipo-estructura es el nombre del nuevo tipo de dato que hemos creado.
Por último, tipo-variable y nombre-variable son las variables que forman parte
de la estructura.
Para definir variables del tipo que acabamos de crear lo podemos hacer de
varias maneras, aunque las dos más utilizadas son éstas:

Una forma de definir la estructura:
struct trabajador
{
char nombre[20];
char apellidos[40];
int edad;
31

char puesto[10];
};
struct trabajador fijo, temporal;
Otra forma:
struct trabajador
{
char nombre[20];
char apellidos[40];
int edad;
char puesto[10];
}fijo, temporal;
En el primer caso declaramos la estructura, y en el momento en que
necesitamos las variables, las declaramos. En el segundo las declaramos al
mismo tiempo que la estructura. El problema del segundo método es que no
podremos declarar más variables de este tipo a lo largo del programa. Para
poder declarar una variable de tipo estructura, la estructura tiene que estar
declarada previamente. Se debe declarar antes de la función main.
El manejo de las estructuras es muy sencillo, así como el acceso a los campos
o variables de estas estructuras. La forma de acceder a estos campos es la
siguiente:
variable.campo;
Donde variable es el nombre de la variable de tipo estructura que hemos
creado, y campo es el nombre de la variable que forma parte de la estructura.
Lo veremos mejor con un ejemplo basado en la estructura definida
anteriormente:
temporal.edad=25;
Almacena el valor 25 en el campo edad de la variable temporal de tipo
trabajador.
Otra característica interesante de las estructuras es que permiten pasar el
contenido de una estructura a otra, siempre que sean del mismo tipo
naturalmente:
fijo=temporal;
Al igual que con los otros tipos de datos, también es posible inicializar variables
de tipo estructura en el momento de su declaración:

32

struct trabajador fijo={"Pedro","Hernández Suárez", 32, "gerente"};
Si uno de los campos de la estructura es un array de números, los valores de la
inicialización deberán ir entre llaves:
struct notas
{
char nombre[30];
int notas[5];
};
struct notas alumno={"Carlos Pérez",{8,7,9,6,10}};

LIBRERÍAS
Librería stdio.h
printf
Función: Escribe en la salida estándar con formato.
Sintaxis: printf(formato , arg1 , ...);
scanf
Función: Lee de la salida estándar con formato.
Sintaxis: scanf(formato , arg1 , ...);
puts
Función: Escribe una cadena y salto de linea.
Sintaxis: puts(cadena);
gets
Función: Lee y guarda una cadena introducida por teclado.
Sintaxis: gets(cadena);
fopen
Función: Abre un fichero en el modo indicado.
Sintaxis: pf=fopen(fichero , modo);
fclose
Función: Cierra un fichero cuyo puntero le indicamos.
Sintaxis: fclose(pf);
fprintf
Función: Escribe con formato en un fichero.
Sintaxis: fprintf(pf , formato , arg1 , ...);
fgets
33

Función: Lee una cadena de un fichero.
Sintaxis: fgets(cadena , longitud , pf);

Librería stdlib.h
atof
Función: Convierte una cadena de texto en un valor de tipo float.
Sintaxis: numflo=atof(cadena);
atoi
Función: Convierte una cadena de texto en un valor de tipo entero.
Sintaxis: nument=atoi(cadena);
itoa
Función: Convierte un valor numérico entero en una cadena de texto. La
base generalmente será 10, aunque se puede indicar otra distinta.
Sintaxis: itoa(número , cadena , base);
exit
Función: Termina la ejecución y abandona el programa.
Sintaxis: exit(estado); /* Normalmente el estado será 0 */

Librería conio.h
clrscr
Función: Borra la pantalla.
Sintaxis: clrscr( );
clreol
Función: Borra desde la posición del cursor hasta el final de la linea.
Sintaxis: clreol( )
gotoxy
Función: Cambia la posición del cursor a las coordenadas indicadas.
Sintaxis: gotoxy(columna , fila);
textcolor
Función: Selecciona el color de texto (0 - 15).
Sintaxis: textcolor(color);
textbackground
Función: Selecciona el color de fondo (0 - 7).
Sintaxis: textbackground(color);
wherex
Función: Retorna la columna en la que se encuentra el cursor.
34

Sintaxis: col=wherex( );
wherey
Función: Retorna la fila en la que se encuentra el cursor.
Sintaxis: fila=wherey( );
getch
Función: Lee y retorna un único caracter introducido mediante el teclado por
el usuario. No muestra el caracter por la pantalla.
Sintaxis: letra=getch( );

Librería string.h
strlen
Función: Calcula la longitud de una cadena.
Sintaxis: longitud=strlen(cadena);
strcpy
Función: Copia el contenido de una cadena sobre otra.
Sintaxis: strcpy(copia , original);
strcat
Función: Concatena dos cadenas.
Sintaxis: strcat(cadena1 , cadena2);
strcmp
Función: Compara el contenido de dos cadenas. Si cadena1 < cadena2
retorna un número negativo. Si cadena1 > cadena2, un número positivo, y si
cadena1 es igual que cadena2 retorna 0 ( o NULL ).
Sintaxis: valor=strcmp(cadena1 , cadena2);

35

FUNDAMENTOS DE PROGRAMACIÓN
Programa.- Conjunto de sentencias ordenadas secuencialmente para generar
procesos automáticos.

Datos de
entrada

ELEMENTOS
DE UN
PROGRAMA
Resultados o
Datos de
salida

Procesos

Lenguaje de Programación.- Sintaxis que permite generar instrucciones para
desarrollar aplicaciones.

Librerías
Palabras
reservadas

Identificadores

ELEMENTOS DE
UN LENGUAJE DE
PROGRAMACIÓN

36

PARTES DE UN PROGRAMA
 Librerías.- Es una colección de clases y funciones, escritas en el núcleo del
lenguaje.
#include<conio.h>
#include<stdio.h>
#include<stdlib.h>
#include<math.h>



Variables.- son un tipo de dato, referenciado mediante un identificador
llamado de la variable. Su contenido podrá ser modificado a lo largo del
programa.

int op, j, a, b, c, d, v;
float c, v, vt, s, su ,total;
char p[15];
 Función main.- Indica el comienzo del programa y requiere los paréntesis ( )
a continuación de main( ) o void main ().
main ()
{
viod main ()
{
 Función clrscr.- Limpia la pantalla.

clrscr();
 Impresión de dados.

gotoxy(15,2);printf("SUMA DE DOS NUMEROS");
gotoxy(15,14);printf("Eltotal de la suma es = %d ",c);


Lectura de variables.- Lee cualquier carácter, numero o símbolo incrasado
desde teclado.

gotoxy(6,6);printf("Ingrese un número: ");scanf("%d",&a);
gotoxy(6,8);printf("Ingrese otro número: ");scanf("%d",&b);


Funciones.- Las funciones son bloques de código utilizados para dividir un
programa en partes más pequeñas, cada una de las cuáles tendrá una tarea
determinada.
37

void nun ( )
{
if(a>b && a>c)
{
gotoxy(16,14);printf("%d",a);
}
else
{
if(b<a && b>c)
{
gotoxy(16,15);printf("%d",b);
}
else
{
gotoxy(16,16);printf("%d",c);
}
}
}
nun ();


Estructura SWITCH.- Esta estructura se suele utilizar en los menús, de manera
que según la opción seleccionada se ejecuten una serie de sentencias.
switch(op)
{
case 1:
break;
case 2:
break;
case 5:
exit;
break;
}
 Procesos.- Suma, resta, multiplicación, división, potencia, radicación.
p=r*t;
total=r/2.3
 Sentencia do while.- Proceso de repetición.
do
{
}while (op==1)

38



Sentencias “for” para realizar el borde.

for(i=1;i<=80;i++)
{
gotoxy(i,1);printf("*");
}
for(i=1;i<=24;i++)
{
gotoxy(1,i);printf("*");
}
}


getch.- Esperar a que el usuario presione una tecla para saltar a la siguiente
instruccion o finalizar el programa si es que ya no quedan sentencias.

getche();


Sentencia IF...ELSE.- solo se ejecuta si se cumple la condición. En
caso contrario el programa sigue su curso sin ejecutar la sentencia.

if(d>=7)
{
gotoxy(6,15);printf("Aprobado");
}
else
{
gotoxy(6,15);printf("Suspenso");
}

 return.- es una sentencia la cual tiene como finalidad indicarle al compilador
que tiene que regresar el valor de retorno que tú le indiques.

return(0);

39

Programa Nº1
 Diseñe un programa que me permita ingresar un número entero desde teclado
de 1 a 7, y q me visualice el nombre del día de la semana que me corresponda.
Análisis.- Utilizamos una variable de tipo entera para ingresar por teclado, la sentencia
do-while para regresar si el número un no está entre 1-7, un swich para las opciones de
los siete días e imprimimos por pantalla el día correspondiente según el número
ingresado.
DOCUMENTACION
#include<stdio.h>
#include<conio.h>
int a;
main ()
{
clrscr();
gotoxy(25,3);printf("DIAS DE LA SEMANA");
do
{
gotoxy(29,5);printf(" ");
}while(a<1 || a>7);
switch(a)
{
case 1:
gotoxy(10,7);printf("Lunes");
break;
case 2:
gotoxy(10,7);printf("Martes");
break;
case 3:
gotoxy(10,7);printf("Miercoles");
break;
case 4:
gotoxy(10,7);printf("Jueves");
break;
case 5:
gotoxy(10,7);printf("Viernes");
break;
case 6:
gotoxy(10,7);printf("Sábado");
break;
case 7:
gotoxy(10,7);printf("Domingo");
break;
}
40

LIBRERIAS
VARIABLES
INICIO

LECTURA DE
VARIABLES

SENTENCIA SWICH

FIN

getch();
}

CORRIDO DEL PROGRAMA

41

Programa Nº2
 Diseñe un programa que me permita ingresar 2 números por teclado y realizar la
suma de los mismos
Análisis.- Utilizamos tres variables de tipo entero, las dos para ingresar por teclado
y la otra para realizar la suma, e imprimimos el resultado por pantalla.
DOCUMENTACIÓN
#include<stdio.h>
#include<conio.h>
int a,b,c;
main ()
{
clrscr();
gotoxy(6,8);printf("Ingrese otro número: ");scanf("%d",&b);
c=a+b;
getche();
return(0);
}

42

LIBRERIAS
VARIABLES

INICIO

LECTURA DE
VARIABLES

FIN


Programa Nº3
 Diseñe un programa que me permita ingresar 3 números enteros desde teclado
que corresponden a 3 notas las mismas que deben estar entre 1 y 10, obtenga el
promedio correspondiente y determine su equivalencia.
 Si el promedio es mayor o igual a 7, está aprobado.
 Si el promedio es mayor o igual a 5 y
 Menor que 7 esta suspenso
 Si el promedio es menor que 5 esta reprobado
Análisis.- Utilizamos cuatro variables de tipo enteras, un do-wille para que las notas
solo sean de 1-10, realizamos los procesos e imprimimos el resultado.
DOCUMENTACIÓN
#include<stdio.h>
#include<conio.h>
int a,b,c,d;
main ()
{
clrscr();
gotoxy(15,2);printf("PROMEDIO");
do
{
gotoxy(6,6);printf("Ingrese la primera nota: ");scanf("%d",&a);
}while(a<0 || a>10);
do
{
gotoxy(6,8);printf("Ingrese la segunda nota: ");scanf("%d",&b);
43

LIBRERIAS
VARIABLES
INICIO

LECTURA DE
VARIABLES

}while(b<0 || b>10);
do
{
gotoxy(6,10);printf("Ingrese la tercera nota: ");scanf("%d",&c);
}while (c<0 || c>10);
d=(a+b+c)/3;
gotoxy(6,14);printf("Promedio %d",d);
if(d>=7)
{
gotoxy(6,15);printf("Aprobado");
}
else
{
if(d>=5&&d<7)
{
gotoxy(6,15);printf("Suspenso");
}
else
{
if(c<5)
{
gotoxy(6,15);printf("Reprobado"); }}
}
getche();
return(0);
}

44

LECTURA DE
VARIABLES

CONDICIONAL “IF”

FIN

Programa Nº4
 Diseñe un programa que realice la suma de dos números, siempre que el
primer valor este entre 3 y 23 y el segundo valor este entre 5 y 17.
Análisis.- Utilizamos tres variables de tipo enteras, dos do-while para que cumpla la
condición requerida, realizamos el proceso y presentamos resultados
DOCUMENTACIÓN
#include<stdio.h>
#include<conio.h>
int a,b,c;
main ()
{
clrscr();
do
{
gotoxy(6,6);printf("Ingrese un n£mero: ");scanf("%d",&a);
}while (a<3 || a>23);
do
{
gotoxy(6,8);printf("Ingrese otro n£mero: ");scanf("%d",&b);
}while (b<5 || b>17);
c=a+b;
getche();
return(0);
}

46

LIBRERIAS
VARIABLES
INICIO

LECTURA DE
VARIABLES

FIN

Programa Nº5
 Diseñe un programa que me permita obtener las comisiones de ventas de la
empresa XYZ, bajo los siguientes condicionamientos si el valor de la venta es
igual a
>= 3000 y <=5000 el porcentaje es de 5%,
>=5000 y <=8500 el porcentaje es de 7%;
>=8500 y <=10000 el porcentaje es de 8%
>10000 el porcentaje es de 10%;
Visualice el valor total de ventas ingresadas y el total de comisiones entregadas el
proceso se repite n veces.
DOCUMENTACIÓN
#include<stdio.h>
#include<conio.h>
main ()
{
int a=1,b=0,oper;
float c,p,v,s,t,f,g,r,q;
do
{
clrscr();
a=1;
b=0;
gotoxy(30,2);printf("COMISIONES DE VENTAS");
gotoxy(5,5);printf("Ingresar el valor de la venta:");scanf("%f",&c);
if((c>2999)&&(c<5001))
{
p=(c*5)/100;
v=c+p;
gotoxy(8,10);printf("La venta total es=%f",v);
gotoxy(8,13);printf("La ganancia es=%f",p);
}
if((c>5000)&&(c<8499))
47

LIBRERIAS
VARIABLES
INICIO

LECTURA DE
VARIABLES

{
s=(c*7)/100;
t=s+c;
gotoxy(8,10);printf("La venta total es=%f",t);
gotoxy(8,13);printf("La ganancia es=%f",s);
}
if((c>8500)&&(c<10001))
{
r=(c*8)/100;
q=r+c;
gotoxy(8,10);printf("La venta total es=%f",q);
gotoxy(8,13);printf("La ganancia es=%f",r);
}
if(c>10000)
{
f=(c*10)/100;
g=f+c;
gotoxy(8,10);printf("La venta total es=%f",g);
gotoxy(8,13);printf("La ganancia es=%f",f);
}
gotoxy(30,20);printf("PRESS 1 para continuar o 0 abandonar");
scanf("%d",&oper);
}
while(oper==1);
getch();
}


48

SENTECIA “IF”

FIN

Programa Nº6
 Diseñe un programa que me permita ingresar el nombre de una persona y la edad de
la misma que debe estar entre 3 y 85, para obtener las siguientes equivalencias:
 Si la edad está entre 3 y 5 debe visualizarse: nombre, “es un bebé”
 Si la edad es > 5 y <13 debe visualizarse: nombre, “es un niño”
 Si la edad es > 13 y ≤ 21 debe visualizarse: nombre, “es un adolescente”
 Si la edad es > 21 y ≤ 60 debe visualizarse: nombre, “es un adulto”
 Si la edad es > 60 debe visualizarse: nombre, “es un adulto mayor”
El programa se repite tantas veces como el usuario lo desee.

Análisis.- Utilizamos tres variables, una de tipo entera y otra de tipo carácter,
sentencias if-else para realizar las equivalencias requeridas y un do-while para
repetir el proceso.
DOCUMENTACIÓN
#include<stdio.h>
#include<conio.h>
#include<string.h>
void main()
{
int ed,op;
char nombre[15];
do
{
clrscr();
gotoxy(31,1);printf("Saber edad y equivalencia");
flushall();
gotoxy(10,3);printf("Ingrese nombre: ");gets(nombre);
49

LIBRERIAS
VARIABLES
INICIO

LECTURA DE
VARIABLES

do
{
gotoxy(10,4);printf("Ingrese la edad: ");scanf("%d",&ed);
}while(ed>85 || ed<3);
if(ed>=3 && ed<=5)
{
gotoxy(10,7);printf("Es un bebe");
}
else
{
if(ed>5 && ed<=13)
SENTECIA “IF”
{
gotoxy(10,7);printf("Ni¤o");
}
else
{
if(ed>15 && ed<=21)
{
gotoxy(10,7);printf("Adolecente");
}
else
{
if(ed>21 && ed<=61)
{
gotoxy(10,7);printf("Adulto");
}
else
{
gotoxy(10,7);printf("Adulto Mayor");
}
}
}
}
gotoxy(10,6);puts(nombre);
gotoxy(10,10);printf("Presione 1 para continuar o 0 para salir: ");scanf("%d",&op);
}while(op==1);
getch();
FIN
}

}

50

Programa Nº7
 Diseñe un programa que me permita simular la venta de productos en
una factura, de la cual necesitamos ingresar el nombre del producto, la
cantidad, precio unitario y calcular el precio total. El programa se repite n
veces según los productos que el usuario desee ingresar.
Análisis.- Utilizamos 15 variables de tipo enteras, decimales y de caracte, un dowhile para que se repita el proceso, realizamos el proceso y presentamos
resultados.
DOCUMENTACIÓN
LIBRERIAS
#include<stdio.h>
#include<conio.h>
VARIABLES
main()
{
INICIO
int op,j,a=4,b=4,c=4,d=4,v=0;
float cant,vuni,vtotal,iva,s,sub,totalp;
char p[15];
clrscr();
gotoxy(23,1); printf("SIMULACION DE FACTURA");
gotoxy(5,4); printf("Producto");
IMPRESION
gotoxy(20,4); printf("Cantidad");
gotoxy(34,4); printf("Precio Unitario");
gotoxy(55,4); printf("Valor");
do
{
flushall();
a=a+1;gotoxy(5,a);gets(p);
b=b+1;gotoxy(23,b);scanf("%2f",&cant);
OPERASIONES
c=c+1;gotoxy(39,c);scanf("%2f",&vuni);
vtotal=cant*vuni;
d=d+1;gotoxy(55,d);printf("%.2f",vtotal);
v=v+vtotal;
LECTURA DE
gotoxy(2,24);printf("presione 1 para ingresar otro producto o 0 para
finalizar la factura: ");scanf("%d",&op);
}while(op==1);
j=v;
sub=j;
gotoxy(45,21); printf("subtotal: %.2f",sub);
iva=(sub*12)/100;
IMPRESION
gotoxy(50,22); printf("iva: %.2f",iva);
vtotal=sub+iva;
gotoxy(40,23); printf("valor a pagar: %.2f",vtotal);
getch();
FIN
}

52

Programa Nº8
 Diseñe un programa que me permita calcular el promedio general de
las notas de distintas materias correspondientes al 2do semestre de
docencia en informática, en donde cada uno de las notas ingresadas
debe estar entre 1 y 10.
Análisis.- Utilizamos 6 variables de tipo enteras y decimales realizamos los
procesos e imprimimos por pantalla.
DOCUMENTACIÓN
#include<stdio.h>
#include<conio.h>
main()
{
int c=5,n1,n2,n3,op;
float prom;
clrscr();
gotoxy(27,2);printf("Facultad de Ciencias Humanas");
gotoxy(30,3);printf("Segundo Informatica");
gotoxy(8,5); printf("Modulos nota 1nota 2 nota 3promedio");
gotoxy(5,6); printf("Programacion 1");
gotoxy(5,7); printf("Fisica 2");
gotoxy(5,8); printf("Matematica Basica");
gotoxy(5,9); printf("M. de la Investigacion");
gotoxy(5,10);printf("Trabajo en Equipo");
gotoxy(5,11);printf("Realidad Nacional");
gotoxy(5,12);printf("Ntics");
do
{
c=c+1;
do
{
gotoxy(39,c);printf(" ");
gotoxy(39,c);scanf("%d",&n1);
}
while (n1>10);
do
{
gotoxy(49,c);scanf("%d",&n2);
}
while (n2>10);
do
{
gotoxy(60,c);scanf ("%d",&n3);
54

LIBRERIAS
VARIABLES
INICIO

IMPRESION

SENTECIA “IF”

}
while (n3>10);
prom=(n1+n2+n3)/3;
gotoxy(70,c);printf("%.2f",prom);
gotoxy(5,15);printf("presione 1 para continuar o 0 para salir");scanf("%d",&op);
}
while (op==1);
getch();
FIN
}

55


Programa Nº9
 Realice un programa en C++ que me permita obtener el líquido a recibir
de un empleado bajo los siguientes parámetros:
El empleado percibe un salario mínimo vital el mismo que depende de su
categoría, existen 3 posibles alternativas, este dato deberá ser ingresada al
inicio del programa conjuntamente con el nombre del empleado:
 Categoría 1
180,00
 Categoría 2
250,00
 Categoría 3
380,00
A este salario mínimo vital se le incluye algunos rubros que son:
1. Horas extras, las mimas que no pueden exceder 8, cada hora extra
cuesta Usd. 1,80.
2. Bono familiar la misma que esta condicionada. Si el empleado tiene mas
de dos hijos se le paga Usd. 4,50 por cada hijo caso contrario se le
reconoce Usd. 6,20 por cada hijo.
3. Obtenga el valor del IESS que es el 11,5 % del nominal
4. Se le descuenta el 2% del nominal como aporte a la asociación
5. Obtenga los valores correspondientes de ingresos, egresos y total a
recibir
El programa se genera n veces.

56

Análisis.- Utilizamos variables de tipo enteras, decimales y de carácter, dowhile para repetir el proceso, if para que cumpla las condiciones requeridas,
realizamos los proceso e imprimimos el resultado por pantalla.
DOCUMENTACIÓN
#include<stdio.h>
LIBRERIAS
#include<conio.h>
main ()
VARIABLES
{
floatx=180,y=250,z=380,s,iess,i=11.5,dcto,a=2,p=1.80,ex,hex,j=4.50,k=6.20,
INICIO
b,in,eg,t;
int c,h,op;
char n[50];
do
{
flushall();
clrscr();
gotoxy(31,3); printf("INGRESO DE DATOS");
gotoxy(2,5); printf("Ingrese su nombre: ");flushall(); gets(n);
do
{
gotoxy(2,8); printf("Escoja su categoria: 1, 2 o 3: "); scanf("%d",&c);
}
while(c>3 || c<1);
gotoxy(2,11); printf("Cantidad de hijos registrados: "); scanf("%d",&h);
do
{
gotoxy(2,14);printf("Horas extras registradas: "); scanf("%f",&hex);
}
while(hex<1 || hex>8);
clrscr();
gotoxy(5,3); printf("********************ROL DE PAGOS********************");
gotoxy(5,5); printf("Empleado: %s",n);
gotoxy(5,6); printf("Corresponde: Septiembre 2013");
gotoxy(5,7); printf("Dias laborados: 30 dias");
gotoxy(5,8); printf("**************************");
gotoxy(10,10); printf("Ingresos");
LECTURA DE
gotoxy(46,10); printf("Egresos");
gotoxy(5,12); printf("Sueldo nominal ");
if(c==1)
{
s=x;
gotoxy(21,12); printf("%.2f",s);
}
if(c==2)
{
s=y;
}
57

if(c==3)
{
s=z;
}
iess=(s*i)/100;
gotoxy(38,12); printf("Seguro: ");
gotoxy(52,12); printf("%.2f",iess);
dcto=(s*a)/100;
gotoxy(38,13); printf("Dcto. Asoc.: ");
gotoxy(52,13); printf("%.2f",dcto);
ex=(hex*p);
gotoxy(5,13); printf("Horas extras: ");
gotoxy(21,13);printf("%.2f",ex);
gotoxy(5,14); printf("Bono Familiar: ");
if (h>2)
{
b=(h*j);
gotoxy(21,14);printf("%.2f",b);
}
if (h<3)
{
b=(h*k);
gotoxy(21,14);printf("%.2f",b);
}
in=(s+ex+b);
gotoxy(5,18); printf("Total Ingresos: ");
gotoxy(21,18);printf("%.2f",in);
eg=(iess+dcto);
gotoxy(38,18);printf("Total Egresos: ");
gotoxy(52,18);printf("%.2f",eg);
t=(in-eg);
gotoxy(38,24);printf("TOTAL A RECIBIR: ");
gotoxy(55,24);printf("%.2f",t);
gotoxy(37,23);printf("*************************");
gotoxy(37,25);printf("*************************");
gotoxy(5,23); printf("presione 1 para regresar o ");
gotoxy(5,24); printf("presione 0 para salir: ");
scanf("%d",&op);
}
while (op==1);
getch();
}

58

IMPRESION

IMPRESION

FIN

Programa Nº10
 Diseñe un programa que me permita imprimir un borde de pantalla.
Análisis.- Utilizamos una variable de tipo entera y un ciclo for para imprimir
el borde.
DOCUMENTACIÓN
LIBRERIAS

#include<stdio.h>
#include<conio.h>
main()
{
int i,limite,fila=6,op;
fila=6;
clrscr();
for (i=1;i<=80;i++)
{
}
for (i=1;i<=24;i++)
{
}
getch();
}

VARIABLES
INICIO

SENTENCIA “FOR”

FIN

61


Programa Nº11
 Diseñe un programa que me permita visualizar la serie de los
números pares y los impares que existen hasta el número límite
ingresado desde teclado.
Análisis.- Utilizamos 4 variables de tipo entera, realizamos el proceso y
presentamos resultados
DOCUMENTACIÓN
LIBRERIAS

#include<stdio.h>
#include<conio.h>
main()
{
int i,limite,fila=6,op;
do
{
fila=6;
clrscr();
for (i=1;i<=80;i++)

VARIABLES
INICIO

62

{

}
SENTENCIA “FOR”
for (i=1;i<=24;i++)
{
}
gotoxy(5,2);printf("ingrese el limite: ");scanf("%d",&limite);
gotoxy(20,4);printf("Pares:");
for (i=2;i<=limite;i+=2)
{
gotoxy(23,fila);printf("%d",i);
fila=fila+1;
}
SENTENCIA “FOR”
fila=6;
gotoxy(42,4);printf("Impares:");
for (i=1;i<=limite;i+=2)
{
gotoxy(46,fila);printf("%d",i);
fila=fila+1;
}
gotoxy(60,21);printf("presione:");
gotoxy(60,22);printf("1 para continuar");
gotoxy(60,23);printf("0 para salir: "); scanf("%d",&op);
}
while(op==1);
getch();
}

FIN

63

Programa Nº612
 Realizar un programa y visualizar los números primos.
Análisis.- Activamos la librerías, utilizamos variables de tipo enteras, dowhile para que cumpla la condición requerida, realizamos el proceso y
presentamos resultados
DOCUMENTACIÓN
LIBRERIAS

#include<stdio.h>
#include<conio.h>
#include<string.h>
main()
{
int i, j, fla=7, lim, cnt=0, resul, op;
do
{
fla=7;
clrscr();
gotoxy(35,3);printf("NUMEROS PRIMOS");
for(i=1;i<=80;i++)
{
}
for(i=1;i<=24;i++)
{
}
gotoxy(5,8);printf("ingrese limite: ");scanf("%d",&lim);
for(i=1;i<=lim;i++)
{
cnt=0;
for(j=1;j<=i;j++)
{
resul=i%j;
if(resul==0)
{
cnt=cnt+1;
}
}
if(cnt==2)
{
gotoxy(40,fla);printf("%d",i);
fla=fla+1;
}
}

65

VARIABLES
INICIO

SENTENCIA “FOR”

SENTENCIA “FOR”


Programa Nº13
 Diseñe un programa que me permita visualizar la factorial de un número
ingresado desde teclado.
Análisis.- Utilizamos variables de tipo enteras, do-while para que cumpla la
condición requerida, sentencias for y realizamos los proceso y presentamos
resultados.
DOCUMENTACIÓN
LIBRERIAS

#include<stdio.h>
#include<conio.h>
main()
{
int i,j,m,l,f=1,op;
do
{
clrscr();
f=1;
//borde de pantalla
m=10;
for (i=1;i<=80;i++)
{
gotoxy(i,1); printf("*");
}

VARIABLES
INICIO

SENTENCIA “FOR”

66

for (i=1;i<=24;i++)
{
gotoxy(1,i); printf("*");
}
gotoxy(31,3);printf("FACTORIALES");
gotoxy(15,7);printf("ingrese el limite: ");scanf("%d",&l);
for (j=1;j<=l;j++)
{
f=f*j;
gotoxy(20,m);printf("El factorial de: %d = %d",j,f);
m=m+1;
}
gotoxy(15,22);printf("presione 1 para continuar o 0 para salir:
");scanf("%d",&op);
}
while (op==1);
getch();
}

67

LECTURA DE

FIN


Programa Nº14
 Diseñe un programa que me permita ejercer la tabla de multiplicación de
cualquier factor imprimido desde teclado y por cualquier limite impreso
desde teclado, el programa se genera n veces, diseñe el borde de la
pantalla.
condición requerida, sentencias for, realizamos los procesos y presentamos
resultados.
DOCUMENTACIÓN
LIBRERIAS

#include<stdio.h>
#include<conio.h>
main ()
{
int fac,lim,i,n,m,j,op ;
do
{
clrscr();
//borde de pantalla
m=9;
for (i=1;i<=80;i++)
{
}
for (i=1;i<=24;i++)

VARIABLES
INICIO

SENTENCIA “FOR”

68

{
}
//tabla de multiplicar
gotoxy(31,3); printf("TABLAS DE MULTIPLICAR");
gotoxy(10,5); printf("Factor: ");scanf("%d",&fac);
gotoxy(10,7); printf("Limite: ");scanf("%d",&lim);
for(j=1;j<=lim;j++)
{
n=fac*j;
gotoxy(19,m); printf("%d",fac);
gotoxy(21,m); printf("*");
gotoxy(23,m); printf("%d",j);
gotoxy(25,m); printf("=");
gotoxy(27,m); printf("%d",n);
m=m+1;
}
gotoxy(8,22); printf("presione 1 para regresar o 0 para salir:
");scanf("%d",&op);
}
while (op==1);
getch();
}

69

FIN


Programa Nº15
 Diseñe un programa en c++ que me permita visualizar los números
primos con repetición y el borde.
resultados.
DOCUMENTACIÓN
LIBRERIAS

#include<conio.h>
#include<stdio.h>
main()
{
int i=0,j=0,lt,c,res=0,op=1,nc=0;
do
{
clrscr();
for(i=1;i<=24;i++)
{
}
for(i=1;i<=80;i++)
{

VARIABLES
INICIO

SENTENCIA “FOR”

70

}
gotoxy(29,2);printf("NUMEROS PRIMOS");
gotoxy(6,4);printf("INGRESE EL LIMITE : ");scanf("%d",&lt);
gotoxy(6,6);printf("1");
c=2;
for(i=2;i<=lt;i++)
{
for(j=1;j<=c;j++)
{
if(i%j==0)
{
nc=nc+1;
}
}
if(nc==2)
{
printf("%6d",i);
}
nc=0;
c=c+1;
}
gotoxy(2,23),printf("REPETIR 1 Y 0 PARA SALIR : ");scanf("%d",&op);
}
while(op==1);
getch();
FIN
}

71


Programa Nº16
 Diseñe un programa que me permita generar cualquier seria de
números.
condición requerida, sentencias for, realizamos los proceso y presentamos
resultados.
DOCUMENTACIÓN
LIBRERIAS

#include<conio.h>
#include<stdio.h>
void main()
{
int limite,i,fla,op;
do
{
clrscr();
for(i=1;i<=80;i++)
{
}
for(i=1;i<=24;i++)

VARIABLES
INICIO

SENTENCIA “FOR”

72

{
}
flushall();
gotoxy(25,5);printf("Series");
gotoxy(15,6);printf("Ingrese limite: ");scanf("%d",&limite);
fla=6;
for(i=2;i<=limite;i+=2)
{
gotoxy(20,fla+1);printf("%d",i);
fla=fla+1;
}
fla=7;
for(i=1;i<=limite;i+=2)
{
gotoxy(40,fla);printf("%d",i);
fla=fla+1;
}
gotoxy(15,20);printf("Desea salir 1/0: ");scanf("%d",&op);
}while(op==1);
getch();
}

73

SENTENCIA “FOR”

FIN


Programa Nº17
 Diseñe un programa que me permita generar una serie de números, en
donde el numerados es cualquier factor ingresado desde teclado, y el
numerador es la serie de los números impares.
resultados.
DOCUMENTACIÓN

LIBRERIAS

#include<stdio.h>
#include<conio.h>
void main ()
{
int i,l,j,c,d,s,p,op,fa;
do
{
clrscr();
for(i=1;i<=80;i++)
{
}
for(i=1;i<=24;i++)

VARIABLES
INICIO

SENTENCIA “FOR”

74

{
}
gotoxy(16,2);printf("SERIE DE NUMEROS NUMERADOR
CUALQUIER,DENOMINADOR IMPAR");
gotoxy(10,3);printf("Ingrse el limite: ");scanf("%d",&l);
gotoxy(10,4);printf("ingrese el factor:");scanf("%d",&fa);
c=0;
d=1;
for(i=1;i<=l;i++)
{
c=c+3;
gotoxy(5,6+i);printf("%d",c);
d=d+2;
gotoxy(13,6+i);printf("%d",d);
gotoxy(9,6+i);printf("/");
}
gotoxy(10,20);printf("Desea continuar 1 caso contario 0:
");scanf("%d",&op);
}while(op==1);
getch();
}

75

LECTURA DE

FIN


Programa Nº18
 Realice un programa que me permita general la siguiente serie de datos:
N= 5
Factor impar como numerador
Factorial como denominador
Análisis.- Utilizamos variables de tipo enteras y decimales, do-while para
que cumpla la condición requerida, sentencias for, realizamos los procesos
y presentamos resultados.
DOCUMENTACIÓN

LIBRERIAS

#include<conio.h>
#include<stdio.h>
void main()
{
int s,f,i,d,j,op;
float factorial;
do
{
clrscr();
for(i=1;i<=80;i++)
{

VARIABLES
INICIO

SENTENCIA “FOR”

76

}
for(i=1;i<=24;i++)
{
}
gotoxy(15,2);printf("SERIE DE NUMEROS CON NUMERADOR
IMPAR E FACTORIAL DENOMINADOR");
gotoxy(10,3);printf("Ingrse el limite: ");scanf("%d",&s);
do
{
gotoxy(10,4);printf("ingrese el factor:");scanf("%d",&f);
} while(f%2==0);
factorial=1;
for(i=1;i<=s;i++)
{
factorial=factorial*i;
gotoxy(5,6+i);printf("%d",f);
f=f+2;
gotoxy(13,6+i);printf("%4.0f",factorial);
}
");scanf("%d",&op);
}while(op==1);
getch();
}

77

IMPRESION

FIN


Programa Nº19ç
 Generar n elementos de la siguiente serie, cualquier factor ingresando
desde teclado como numerador, el denominador números pares.
resultados.
DOCUMENTACIÓN
#include<stdio.h>
#include<conio.h>
void main ()
{
int i,l,j,c,d,s,p,op,fa;
do
{
clrscr();
for(i=1;i<=80;i++)
{
}
for(i=1;i<=24;i++)
{

LIBRERIAS
VARIABLES
INICIO

SENTENCIA “FOR”

78

}
gotoxy(16,2);printf("SERIE DE NUMEROS NUMERADOR
CUALQUIER,DENOMINADOR PAR");
gotoxy(10,3);printf("Ingrse el limite: ");scanf("%d",&l);
gotoxy(10,4);printf("ingrese el factor:");scanf("%d",&fa);
c=0;
d=0;
for(i=1;i<=l;i++)
{
c=c+3;
gotoxy(5,6+i);printf("%d",c);
d=d+2;
gotoxy(13,6+i);printf("%d",d);
}
");scanf("%d",&op);
}while(op==1);
getch();
}

79

IMPRESION

FIN


Programa Nº20
 Genere una serie de datos que lleve por numerador el factorial y por
denominador la serie de Fibonacci
resultados.
DOCUMENTACIÓN

LIBRERIAS

#include<conio.h>
#include<stdio.h>
main()
{
int i, limit, fibon=0, colum=5, b=1, c=0, fac=1, op;
do
{
fibon=0, colum=5, b=1, c=0, fac=1;
clrscr();
for(i=1;i<=80;i++)
{
}
for(i=1;i<=24;i++)
{
80

VARIABLES
INICIO

SENTENCIA “FOR”

}
gotoxy(17,3);printf("SERIE NUMERADOR FACTORIAL
Y DENOMINADOR FIBONACCI");
gotoxy(4,5);printf("numero a visualizar: ");scanf("%d",&limit);
LECTURA DE
for(i=1;i<=limit;i++)
{
gotoxy(colum,9);printf("%d",fibon);
fibon=b+c;
b=c;
OPERACIONES
c=fibon;
gotoxy(colum,8);printf("-");
gotoxy(colum,7);printf("%d",fac);
fac=fac*i;
colum=colum+5;
}
gotoxy(3,22);printf("PRESIONE 1 PARA REPETIR LA SERIE O 0 PARA LECTURA DE
FINALIZAR>> ");scanf("%d",&op);
}
while(op==1);
getch();
}
FIN

81


Programa Nº21
 Genere la siguiente serie de datos primos en el numerador e impares en
el denominador.
condición requerida, sentencias for, sentencias if realizamos los procesos y
presentamos resultados.
DOCUMENTACIÓN

LIBRERIAS

#include<stdio.h>
#include<conio.h>
#include<string.h>
main()
{
int i, j, np, cot=0, c=5, resul, op, colum=15, imp=1, aux;
do
{
imp=1;
colum=15;
c=10;
clrscr();

VARIABLES

82

INICIO

gotoxy(16,3);printf("SERIE NUMERADOR PRIMOS DENOMINADOR
IMPARES");
for(i=1;i<=80;i++)
{
SENTENCIA “FOR”
}
for(i=1;i<=24;i++)
{
}
gotoxy(3,5);printf("Limite: ");scanf("%d",&np);
gotoxy(10,7);printf("1");
gotoxy(8,6);printf("Serie: ");
aux=0;
for(i=1;i<=(2*np);i++)
{
if(aux==np)
{break;
}
SENTENCIA “FOR”
cot=0;
for(j=1;j<=i;j++)
{
resul=i%j;
if(resul==0)
{
cot=cot+1;
}
}
if(cot==2)
{
gotoxy(colum,7);printf("%d",i);
aux=aux+1;
gotoxy(colum,8);printf("-");
IMPRESION
colum=colum+5;
gotoxy(c,9);printf("%d",imp);
imp=imp+2;
c=c+5;
}
}
gotoxy(3,23);printf("PRESIONE 1 PARA REPETIR EL PROCESO O 0 PARA
FINALIZAR: ");scanf("%d",&op);
}
while(op==1);
getch();
FIN
}

83

Programa Nº22
 Realice un menú que me permita realizar las conversiones básicas de
metro, kilometro, hectómetro y decímetro.
Análisis.- Activamos las librerías, utilizamos variables de tipo enteras, y
decimales, do-while para que cumpla la condición requerida, sentencias for,
un swich para las opciones, realizamos los procesos y presentamos
resultados.
DOCUMENTACIÓN
LIBRERIAS

#include<conio.h>
#include<stdio.h>
VARIABLES
#include<stdlib.h>
INICIO
void borde()
{
int i;
clrscr();
for(i=1;i<=80;i++)
{
gotoxy(i,1);printf("±");
SENTENCIA “FOR”
}
for(i=1;i<=24;i++)
{
gotoxy(1,i);printf("±");
}
}
void main()
{
int op,col=8;
float km,nu,dam,hm,m;
clrscr();
do
{
borde();
gotoxy(32,3);printf("CONVERSIONES BASICAS");
gotoxy(32,2);printf("////////////////////");
IMPRESION
gotoxy(32,4);printf("////////////////////");
gotoxy(5,6);printf("1.- De Metros a Km - Hm - Dam");
gotoxy(5,8);printf("2.- De Kilometros a M - Hm - Dam");
gotoxy(5,10);printf("3.- De Hectometros a M - Km - Dam");
gotoxy(5,12);printf("4.- De Decametros a M - Km - Hm");
gotoxy(5,14);printf("5.- Salir");
gotoxy(5,22);printf("Que opcion desea realizar: ");scanf("%d",&op);
switch(op)
{
case 1:
clrscr();
85

borde();
gotoxy(33,3);printf("De Metros a Km - Hm - Dam");
gotoxy(5,5);printf("Ingrece la cantidad: ");scanf("%f",&nu);
km=nu*0.001;
hm=nu*0.01;
dam=nu*0.1;
gotoxy(col,8);printf("Km = %f",km);
gotoxy(col,10);printf("Hm = %f",hm);
gotoxy(col,12);printf("Dam = %f",dam);
break;
case 2:
clrscr();
borde();
gotoxy(33,3);printf("De Kilometros a M - Hm - Dam");
m=nu*1000;
hm=nu*100;
dam=nu*10;
gotoxy(col,8);printf("M = %f",m);
break;
case 3:
clrscr();
borde();
gotoxy(33,3);printf("De Hectometros a M - Km - Dam");
km=nu*0.1;
m=nu*100;
dam=nu*10;
break;
case 4:
clrscr();
borde();
gotoxy(33,3);printf("De Metros a M - Km - Hm");
km=nu*0.001;
hm=nu*0.01;
m=nu*10;
break;
case 5:
exit(0);
break;
}
86

IMPRESION

IMPRESION

IMPRESION

FIN

gotoxy(3,23);printf("1 PARA VOLVER AL MENU DE DATOS 0 PARA
FINALIZAR: ");scanf("%d",&op);
}
while(op==1);
getch();
}

87

FIN


Programa Nº23
 Diseñe un programa que me permita realizar un borde utilizaciones
funciones.
Análisis.- Utilizamos una variable de tipo enteras, sentencias for para que
cumpla la condición requerida, llamamos a la función borde y presentamos
resultados.

88

DOCUMENTACIÓN
#include<stdio.h>
#include<conio.h>
#include<stdlib.h>
int i;
void borde()
{
for(i=1;i<=80;i++)
{
}
for(i=1;i<=24;i++)
{
}
}
void main ()
{
clrscr();
borde();
getch();
}

LIBRERIAS
VARIABLES

INICIO

SENTENCIA “FOR”

FIN

89


Programa Nº24
resultados.
DOCUMENTACIÓN
LIBRERIAS

#include<stdio.h>
#include<conio.h>
int numero,i,op;
void borde()
{
for(i=1;i<=80;i++)
{
gotoxy(i,1);printf("• ");
gotoxy(i,24);printf("• ");
}
for(i=1;i<=24;i++)
{
gotoxy(1,i);printf("• ");
gotoxy(80,i);printf("• ");
}
}
void numeros(int num)
{
for(i=1;i<=numero;i++)

VARIABLES
INICIO

SENTENCIA “FOR”

90

{
gotoxy(15,4+i);printf("%d",i);
}
}
void main()
{
do
{
clrscr();
borde();
gotoxy(15,4);printf("Numero: ");scanf("%d",&numero);
numeros(numero);
}while(op==1);
getch();
}

91

FIN


Programa Nº25
 Diseñe un programa que me permita ingresar tres valores enteros
desde teclado entre 4 y 64 y presentarlos en forma ordenada
ascendentemente.
resultados.
DOCUMENTACIÓN
LIBRERIAS

#include<stdio.h>
#include<conio.h>
#include<stdlib.h>
int i,a,b,c;
void borde ()
{

VARIABLES
INICIO

92

for(i=1;i<=80;i++)
{
SENTENCIA “FOR”
}
for(i=1;i<=24;i++)
{
}
}
void nun ( )
{
if(a>b && a>c)
{
gotoxy(16,14);printf("%d",a);
}
else
{
if(b<a && b>c)
{
}
else
FUNSION
{
}
if(c<a && c>b)
{
}
else
{
}
}
}
void main()
{
clrscr();
borde ();
gotoxy(30,3);printf("ASCENDENTE");
do
{
gotoxy(12,5);printf("Ingrese el primer numero:");scanf("%d",&a);
}while(a<3||a>65);
do
{
93

gotoxy(12,7);printf("Ingrese el segundo numero:");scanf("%d",&b);
}while(b<3||b>65);
do
{
gotoxy(12,9);printf("Ingrese el tercer numero:");scanf("%d",&c);
}while(c<3||c>65);
nun ();
getch();
FIN
}

94

33.-Diseñe un programa utilizando funciones que me permita ingresar 3 valores
enteros desde teclado entre 4 y 64 y presentarlos en forma ordenada
ascendentemente.

ANALISIS
Para este programa se necesitan varias funciones de condición if para hacer la
comparación y así poder imprimir los números en forma ascendente y para
validar los números también otros if para que el número ingresado este el
rango que se pedía en el programa

DOCUMENTACION
#include<stdio.h> LIBRERIAS
#include<conio.h>
int i,a,b,c,op;

Declaración de variables

Inicio de la función borde
void borde()
{
for(i=1;i<=80;i++)
{
}
Impresión del margen
for(i=1;i<=24;i++)
{
}
}
void numero()
Inicio de la función void main
{
do
Inicio del do
{
gotoxy(24,4);printf("
");
Ingreso el primer numero
gotoxy(15,4);printf("Numero 1; ");scanf("%d",&a);
}
while(a>64 || a<4);
Si ese número cumple con la condición
empleada pide el siguiente número

do
{

Inicio del do

");

Ingreso el segundo numero
96

gotoxy(15,5);printf("Numero 2: ");scanf("%d",&b);
}
Si ese número cumple con la condición
while(b>64 || b<4);
empleada pide el siguiente numero

do
Inicio del do
{
");
gotoxy(15,6);printf("Numero 3: ");scanf("%d",&c);
Ingreso el tercer numero
}while(c>64 || c<4);
}
void orden()
Inicio de la función void orden
{
if(a<=b && a<=c)
{
if(b<=c)
{
gotoxy(15,8);printf("%d %d %d",a,b,c);
}
if(c<=b)
{
gotoxy(15,8);printf("%d %d %d",a,b,c);
}
}
Proceso para presentar
if(b<=a && b<=c)
los números ingresados
{
en forma ordenada
if(a<=c)
ascendentemente.
{
gotoxy(15,8);printf("%d %d %d",b,a,c);
}
if(c<=a)
{
gotoxy(15,8);printf("%d %d %d",b,c,a);
}
}
if(c<=a && c<=b)
{
if(a<=b)
{
gotoxy(15,8);printf("%d %d %d",c,a,b);
}
if(b<=a)
{
gotoxy(15,8);printf("%d %d %d",c,b,a);
}
97

}
gotoxy(15,7);printf("El orden es:");
}
Inicio de la función principal
void main()
{
do
{
Borrar pantalla
clrscr();
borde();
Llamar al borde
Llamar a la función
numero
Llamar a la función orden

numero();
orden();

}
while(op==1);
Si la opción ingresada por el usuario es igual a 1 el
proceso se repetirá

getch();
}

Fin del programa


98

34.- Diseñe un programa utilizando funciones que me permita generar y
visualizar los números perfectos.

ANALISIS




En este programa utilizamos la librería math porque utilizamos la función
pow
Utilizamos un do –while para que el usuario ingrese otro limite o quiera
salir del programa
Aquí también empleamos la utilización de las funciones

DOCUMENTACION
#include<stdio.h>
LIBRERIAS
#include<conio.h>
#include<math.h>
int i,r,dos=2,ex=1,ex2=2,s,v,l1,expo2=2,
expo3=3,a,b,c,f=9,i,op;
void borde()
{
for(i=1;i<=80;i++)
{
}
for(i=1;i<=24;i++)
{
}
}
void perfecto(int l)
{
r=pow(dos,ex);
s=pow(dos,ex2);
v=r*(s-1);
gotoxy(7,8);printf("%d",v);
for(i=1;i<=l-1;i++)
{
a=pow(dos,expo2);

Inicio de la función borde

Impresión del margen

Inicio de la función void
perfecto
Operaciones para sacar los
números perfectos

Operaciones para sacar los
números perfectos
99

Declaración de variables

b=pow(dos,expo3);
expo2=expo2+2;
expo3=expo3+2;
c=a*(b-1);
gotoxy(7,f);printf("%d",c);
f=f+1;
}
}//cierre del void

Impresión de los números
perfectos

Inicio de la función principal
void main()
{
do
{
f=9,dos=2,ex=1,ex2=2,expo2=2,expo3=3,f=9; Declaración de variables

clrscr();

Borrar pantalla
Llamar al borde

borde();
gotoxy(30,4);printf("SERIE DE NUMEROS PERFECTOS");
gotoxy(5,6);printf("Ingrese un limite: ");scanf("%d",&l1);
Llamo a la función perfecto

Impresión del titulo

Ingreso del limite

perfecto(l1);
");
gotoxy(4,22);printf("PRESIONE 1 PARA VOLVER AL MENU O 0 PARA
SALIR: ");scanf("%d",&op);
}
while(op==1);
Si la opción ingresada por el usuario es igual a 1 el
proceso se repetirá

getch();
}

Fin del programa


100

35.- Diseñe un programa utilizando funciones que me permita resolver un
sistema de ecuación de 2° grado.
ANÁLISIS
Partiremos escribiendo la fórmula para tener base de que nomás se va a
utilizar.

La fórmula genera dos respuestas: Una con el signo más (+) y otra con el signo
menos (−) antes de la raíz. Solucionar una ecuación de segundo grado se
limita, entonces, a identificar las letras a, b y c y sustituir sus valores en la
fórmula.
La fórmula general para resolver una ecuación de segundo grado sirve para
resolver cualquier ecuación de segundo grado, sea completa o incompleta, y
obtener buenos resultados tiene que ver con las técnicas de factorización.

CODIFICACIÓN
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#include <math.h>
int i,j,op;
void borde()
{
textcolor(BLUE);
for(i=1;i<=80;i++)
{
gotoxy(i,1);cprintf("*");
gotoxy(i,24);cprintf("*");
}
for(i=1;i<=24;i++)
{
gotoxy(1,i);cprintf("*");
gotoxy(80,i);cprintf("*");
}
}
void seg ()
{
float a, b, c;
float x1, x2;
float x1real, x2real;

Activation de Liberia

// declaración de variables globales

función del borde

// impression de *
// fin del ciclo for
// fin de la function borde
// function para la ecuacion
// inicio de la function

/* complejas
101

*/

float x1imag, x2imag;
/* Partes imaginarias soluciones complejas
*/
float discriminante;
/* Presentacion */
system ("cls");
/* Borrado de la pantalla */
borde();
gotoxy(10,3);printf("RESOLUCION DE LA ECUACION DE SEGUNDO
GRADOn");
gotoxy(2,4);printf("==============================================
================n");
gotoxy(10,5);printf("El programa soluciona la ecuación de segundo gradon");
2
n");
gotoxy(10,7);printf("ax + bx + c = 0
n");
/* Petición de datos */
printf("Introduzca los coeficientes:n");
printf(" Coeficiente a: "); scanf("%f", &a);
printf(" Coeficiente b: "); scanf("%f", &b);
printf(" Coeficiente c: "); scanf("%f", &c);
/* Cálculos y resultados */
discriminante = b*b - 4*a*c;
// calculo de discriminate
printf("n La ecuacionn");
printf(" %14dn", 2);
printf(" %12gx + %gx + %g = 0n", a, b, c); // impresiones
printf(" tiene por soluciones ");
if (discriminante == 0)
// sentencia si dis es = a 0
{
// inicio de if
printf(" una raiz real doblen"); // impresión
x1 = x2 = -b / (2*a);
// calculo
printf(" x1 = %.2fn", x1);
printf(" x2 = %.2fn", x2);
// impresión en pantalla
}
// fin de if
else if (discriminante > 0)
//si dis es mayor a cero
{
// cálculos
printf(" dos raices realesn");
x1 = (-b + sqrt(discriminante)) / (2*a);
x2 = (-b - sqrt(discriminante)) / (2*a);
// impresiones
printf("x1 = %.2fn", x1);
printf("x2 = %.2fn", x2);
}
Else
// caso contrario
{
//impresión en pantalla
printf("dos raíces complejas conjugadasn");
//cálculos
x1real = x2real = -b / (2*a);
x1imag = sqrt(-discriminante) / (2*a);
x2imag = -sqrt(-discriminante) / (2*a);
// impresiones
102

}
}
void main ()
{
Do
{

printf("x1 = ( %.2f, %.2fi)n", x1real, x1imag);
printf("x2 = ( %.2f, %.2fi)n", x2real, x2imag);
//fin del ese
// fin de la función
// inicio del programa
// llave de inicio
//ciclo do
// llave de inicio de do

borde ();
// funcion borde
seg ();
// funcion seg
gotoxy(22,22);printf("desea continuar: ");scanf("%d",&op); // impresión en
pantalla y lectura
} while(op==1);
getch(); //pausa
} // fin del programa.
Corrido del Programa

103

38.- Diseñe un programa utilizando vectores y funciones que me permita
ingresar datos a un vector y presentarlos en otro vector
ANÁLISIS
Primero ingresamos las librerías que vamos a utilizar en este programa en este
caso son las dos principales la STDIO.H Y LA CONIO.H, después como es un
programa con funciones declaramos la variable que vamos a utilizar
globalmente.
Después ingresamos una función con el nombre de borde para que nuestro
programa se visualice con un borde.
Luego realizamos el programa principal con un VOID MAIN () para que se abra
el programa principal seguido con la llave { y declaramos las demás variables a
realizar en el programa (int vector1[10],fila,op,lim;), después ponemos un
do-while para que se repita el programa n veces y llamamos las funciones
realizadas y realizamos el ingreso del límite para que podaos ingresar datos a
una función y que luego se visualice.
DOCUMENTACIÓN
#include<stdio.h>

Librerías que vamos a utilizar en el programa

#include<conio.h>
int i;

Declaramos la variable global

void borde()
{
for(i=1;i<=80;i++)
{
}

Realizamos la función para que se pueda
realizar un borde en nuestro programa

for(i=1;i<=24;i++)
{
}
}
void main()
{

Realizamos el programa principal y declaramos la
variables que vamos a utilizar en el programa principal
104

int vector1[10],fila,op,lim;
do
{
clrscr();
borde();
gotoxy(25,3); printf("**VISUALIZAR DATOS VECTOR**");

Aquí damos un limite al vector
para poder dar datos
numéricos a un limita vector

gotoxy(10,5); printf("INGRESE EL LIMITE==>");
scanf("%d",&lim);

Ingresamos el limite

fila=6;
for(i=1;i<=lim;i++)
{
do
{
gotoxy(20,fila); printf(" ");
Ingresamos los números para que se llene
el vector previamente dado un limite

gotoxy(20,fila); scanf("%d",&vector1[i]);
}
while(vector1[i]<3 || vector1[i]>23);

Damos o validamos los datos que estén entre 3 y 23

fila=fila+1;
}
fila=6;
for(i=1;i<=lim;i++)
Aquí se visualiza el vector que
ingresamos en otra posición

{
gotoxy(40,fila); printf("%d",vector1[i]);
fila=fila+1;

}
gotoxy(10,20); printf("PRESIONE 1 PARA REPETIR EL PROGRAMA CASO
CONTRARIO 0==>");
scanf("%d",&op);

Ingresamos otra opción para ver si se repite el programa n veces

}
while(op);
getch();

Visualiza la opción y da por terminado el
programa

}
105

41.- Diseñe un programa utilizando vectores y un menú de opciones que me
permita realizar las 4 operaciones básicas, estas son: suma, resta,
multiplicación y división.
ANALISIS
En este programa se realizan las operaciones básicas que son la suma, resta,
multiplicación y división utilizando un menú de opciones y con vectores, en
donde tenemos que ingresar valores en dos vectores diferentes en el vector1 y
vector2 para que vayan realizando las operaciones correspondiente teniendo
en cuenta las condiciones plantedas que se dieron en la resta y división en
donde el valor del vector1 debe ser mayor al valor del vector2 si no se cumple
la condición no se realiza las operaciones y se imprime un mensaje.
DOCUMENTACION
#include<stdio.h>
#include<conio.h>

Ingreso las
librerías

#include<stdlib.h>

int multivec[15],opc,divisionvec[15],
restavec[15],i,op,col,fila,vector1[15],vector2[15],

Declaración de
variables

sumavec[15],limite1;

void borde()

Función borde

{
for(i=1;i<=80;i++)
{
Este proceso
es para realizar
el borde

}
for(i=1;i<=24;i++)
{
}
}
void ingreso(int limite1)

Función para ingresar los valores
de los vectores
108

{
col=12;
fila=8;

Ingresamos la posición en la cual
se va a visualizar los vectores

for(i=1;i<=limite1;i++)
{

Utilizamos el for para poder
ingresar los valores del vector1 y
vector2 al final vamos sumando fila
para q vayan colocándose en las
posiciones correctas, cerramos la
laves del for y la llaves de la
función ingreso.

gotoxy(col,fila); scanf("%d",&vector1[i]);
gotoxy(col+10, fila); scanf("%d",&vector2[i]);
fila=fila+1;
}
}
void suma(int limite1)

Función para realizar la suma

{

Abrimos con una llave

fila=8;

Ingresamos el valor de la fila en la que va a
empezar a visualizarse los datos del vector.

for(i=1;i<=limite1;i++)
{
sumavec[i]=vector1[i]+vector2[i];
gotoxy(40,fila); printf("%d",sumavec[i]);
fila=fila+1;
}

Utilizamos el for para poder
ingresar los valores del vector1 y
vector2, realizamos la operación
en donde se suman los dos
vectores
e
imprimimos
el
resultado, vamos sumando fila
para las correctas posiciones
cerramos el for y la función suma.

}
void resta(int limite1)
{

fila=8;

Función para realizar la resta

Abrimos con una llave
Ingresamos el valor de la fila en la que va a
empezar a visualizarse los datos del vector.

109

Libro digital de programación

Libro digital de programación

Recomendados

Recomendados

Mais conteúdo relacionado

Mais procurados

Mais procurados (13)

Destaque

Destaque (20)

Semelhante a Libro digital de programación

Semelhante a Libro digital de programación (20)

Mais de Estefy Sanchez

Mais de Estefy Sanchez (13)

Último

Último (20)

Libro digital de programación