Lenguaje C, Manual de Programacion - M.C. Enrique Ruiz Diaz

Autor: M.C.
Enrique Ruiz Díaz Lenguaje de Programación C - (Materia: ‘Programación I’)
Manual de Lenguaje C
Cubre la Materia ‘Programación 1’
Autor: M.C. Enrique Ruiz Díaz
Visite: http://www.scribd.com/enriqueruizdiaz
Asimismo: http://sites.google.com/site/enriqueruizdiaz/
1
Autor: M.C. Enrique Ruiz Díaz Lenguaje de Programación C - (Materia: ‘Programación I’)
LENGUAJE DE PROGRAMACION C
______________________________________________________________________________________
# include <stdio.h>
# define PI 3.141596
float Area (int radio);
float Area (int radio)

{
float area;
area=PI*radio*radio;
return area;
}
void main()
{
int r = 5;
float a;
a = Area(r);
printf ("Area del circulo %f\n",a);
getch();
}
______________________________________________________________________________________
# include Declara las cabeceras del programa
# include <stdio.h> Permite incluir al programa una función de nombre <stdio.h>

Standard Input Output “funciones de entrada salida” (hace que el
programa funcione)
# include <math.h> También puede haber una línea con esta instrucción, la cual
permite usar en el programa funciones matemáticas tales como
exponenciación, seno, coseno, tangente, etc.
# include <stdio.h> Las < > quiere decir que los archivos del subdirectorio include
están en esta ruta C:\TC\INCLUDE
# include “stdio.h” Se utilizan las “ “ cuando la libreria (archivos del subdirectorio

include) este en el directorio de trabajo. C:\TC
# define PI 3.141596 Esta instrucción que se encuentra en la parte inicial del programa
permite crear una constante valida para todo el programa. En
este caso la constante se llama “PI” y toma un valor de 3.141596.
(vea que no lleva el signo de = )
float Area (int radio); Esta línea se llama “DECLARACIÓN DE PROTOTIPOS” Declara
al programa que función buscará, como se llama dicha función,
que tipo de dato va a regresar, cuantos parámetros tiene y cuales
son.
2
DECLARACIÓN DE PROTOTIPOS
float Area (int radio);

Observe que esta línea termina con un punto y coma, en la definición anterior nos dice que se
declara que función va a buscar, en este caso la función se llama “Area” (Entendamos que función
es un pequeño subprograma que realiza una tarea). Nos dice también que tipo de dato va a
regresar la función “Area”; vea que le precede la palabra “float” esto es que regresara una valor
numérico flotante o número real. En este caso la declaración del prototipo solo tiene un
parámetro que es “radio” que es una variable que se utiliza para transferir información a la
función, y el dato que se transferirá es un numero entero, esto nos lo indica la palabra “int”
float Area (int radio) En esta línea tenemos la “DEFINICIÓN DE LA FUNCIÓN” es

{ decir, cuando realmente empieza a realizar la tarea para la cual
... fue diseñada. Vea que es casi idéntica a la línea de Declaración,
... solo que esta no termina con punto y coma, y entre corchetes se
} escribe el cuerpo de esta función de nombre “Area”
void main( ) Todos los programas deben tener la función main() que es el
{ cuerpo principal del programa. Aunque en nuestro programa de
... ejemplo la función main() se encuentra después de la función
... Area, en realidad el programa siempre se dirige primero al
} cuerpo del main() y luego se ejecutara la función secundaria, en
este caso “Area” cuando esta sea llamada.
a = Area(r); Esta instrucción dentro del main() es la que
llama la ejecución de la función “Area” y de paso le transfiere el
valor que tiene “ r ” que es de 5, y este valor será recibido por el
parámetro (variable) “radio” de la función
return area; Al terminar de ejecutarse la función “Area” desaparecen todas

sus variables y sus valores. Sin embargo, esta instrucción
permite regresar el valor de la variable area y, este valor será
recibido por la variable “a” de main()
DEFINICIONES
LIBRERIA: Una Libreria contiene funciones especificas. En el programa se usa una libreria
con la linea: # include
ejemplo: Contiene seno()

LIBRERIA funciones coseno()
math.h como: sqrt()
pow()
3
TIPOS DE DATOS EN C
char Caracter
int valor númerico entero
float valor número flotante (real)
double flotante de doble presición
void Sin valor
Tipo Tamaño aproximado en bits Rango minimo
Char 8 -127 a 127

unsigned char 8 0 a 255
signed char 8 -127 a 127
Int 16 -32,767 a 32,767
unsigned int 16 0 a 65,535
signed int 16 -32,767 a 32,767
short int 16 -32,767 a 32,767
unsigned short int 16 0 a 65,535
signed short int 16 -32,767 a 32,767
long int 32 -2,147,483,647 a
2,147,483,647
unsigned long int 0 a 4,294,967,295
signed long int 32 -2,147,483,647 a
2,147,483,647
Float 32 6 dígitos de precisión
Doublé 64 10 dígitos de precisión
Nota: Como en el caso de unsigned char ya no usa el primer bit reservado al signo por lo que hay
mas capacidad de almacenamiento. Observe como en otros casos, también se elimina el signo (se
deja solo como positivo) y se aumenta la capacidad.
Ejemplo de cantidad de bytes ocupado por diferentes variables (8 bits = 1 byte)
char sexo, nombre[31]; 32 bytes

int edad; 2
float estatura 4
double masa_atomica; 8
total de bytes ocupados 46
Nota: en el caso de la variable caracter char sexo, ya sabemos que ocupa 8 bits = 1 byte, pero a la
variable char nombre se le asigna un espacio de 31, es decir, 31 bytes, de ahi la suma de 32 bytes.
4
NOMBRE DE IDENTIFICADORES
Los nombres usados para referenciar las variables, las funciones, las etiquetas y otros
objetos definidos por el usuario se conocen como identificadores. Las reglas para escribir los
nombres de los identificadores son:
1. Se pueden usar las letras del alfabeto tanto mayúsculas y minúsculas; así como también los
dígitos del 0 al 9 y el caracter de subrayado o “underline”
2. Los nombres de los identificadores deben de comenzar con una letra seguida de 1 o mas
letras ó los dígitos del 0 al 9
3. Cuando un nombre de identificador contenga mas de una palabra, entonces deberán ser
unidas por el caracter de subrayado.
4. No podrán ser usadas como identificadores las siguientes palabras reservadas:

auto for unsigned
break goto void
rase if volatile
char int while
const long struct
continue register
default return
do short
double signed
else sizcuf
enum switch
extern typedef
float union
VARIABLE : Una variable es una posición de memoria con nombre que se usa para mantener
que puede ser modificado por el programa. La característica de la variable es que tiene una
dirección en memoria y un contenido.
Su forma general es:
tipo lista_ de_variables;
donde:
tipo: Es un tipo de dato valido de C con cualquier modificador. Ejemplo de tipo: char (caracter)
int (número entero)
lista_de_variables: Puede consistir en uno o mas identificadores separados por comas:

ejemplo: nombre, domicilio, sexo, etc.
5
DIFERENTES TIPOS DE VARIABLES
VARIABLES LOCALES: Son definidas por una función y solo dentro de ella es reconocida.
Por ejemplo, en el programa siguiente:
______________________________________________________________________________________
void f (void) 1
{
int t ; 2
scanf (“%d”, &t);
if (t = = 1)
{
char s[80]; 3
printf (“Introduzca el nombre:”);
gets(s);
}
}
______________________________________________________________________________________
1 Tenemos una función de nombre ‘f ’ que no devuelve ningún valor (primer void), ni recibe
ningún valor (segundo void)
2 ´t ´ es una Variable local de tipo entero. Es variable local porque solo existe mientras se ejecuta
la función, al terminar de ejecutarse, la variable se destruye.
3 ´s ´ es una variable de tipo caracter con 80 posiciones (80 bytes), es variable local porque existe
dentro de la función ´f ´ pero a la vez solo es reconocida si se entra al ciclo if ... si no se entrara al
ciclo if entonces no se crea la variable ´s ´
PARAMETROS FORMALES: Sirven para transferir información hacia las funciones, en la

definición de la función.
______________________________________________________________________________________
esta_en 1 ( char * s, char c ) 2

{
while ( * s )
if ( *s = = c )
return 1;
else
{
s + +;
return 0;
}
}
6
______________________________________________________________________________________
1 Esta función se llama “esta_en” y vea que no tiene un tipo de dato, entonces devuelve un entero
int esta_en ...

2 ( char * s, char c ) estos son dos parametros formales los cuales han de recibir valores provenientes
de otra parte del programa. los dos parametros son de tipo char (caracter).
PARAMETROS ACTUALES: 3 Son usados en el llamado de la función, dentro de main( ).

______________________________________________________________________________________
void main( )
{
int valor;
valor = esta_en (“LA CASA BLANCA”, “B”)3 ;
if (valor = = 1)
printf (“Esta en la cadena”);
else
printf (“No esta en la cadena”);
}
______________________________________________________________________________________
VARIABLES GLOBALES: Estas variables estan fuera de main() y fuera de cualquier otra
función y son reconocida en todo el programa.
______________________________________________________________________________________
# include “stdio.h”
int cuenta; 4
void func1 (void);
void func2 (void);
void func1 (void)

{
int temp; 7
temp = cuenta; 7
func2( ); 8
printf (“La cuenta es %d”, cuenta); 1 1
}
void func2 (void)
{
int cuenta; 9
for (cuenta=1; cuenta<10; cuenta ++) 1 0
putchar(‘ . ’);
}
void main ( )
{
cuenta = 100; 5
func1 ( ); 6
}
______________________________________________________________________________________
7
4 int cuenta; en esta línea vemos una variable de tipo entero (int) que se llama “cuenta” y como
esta fuera de main ( ) y fuera de cualquier otra función es variable global, es decir, que será
reconocida en cualquier parte del programa.
5Recuerde que no importa en que parte del programa se encuentre la función main () (principal) el
programa siempre ejecuta esta función antes que otras funciones (en este caso ejecuta primero
main() antes que func1 y func2). La variable global cuenta toma un valor de 100.
6 Se hace un llamado para ejecutar la función “func1”
7Dentro de la función func1( ) se crea la variable local “temp” y vea que en la siguiente línea la
variable local “temp” toma el valor de la variable global “cuenta”. Por lo que “temp” vale 100
8 En esta línea se hace un llamado a la función “func2”
9 Se crea una variable local de nombre “cuenta” es variable local porque esta creada dentro de la
función func2() y solo tiene validez para ella.
Recuerde que tenemos también una variable global de nombre “cuenta” y que vale 100.
pero dentro la función func2 se creo una variable local del mismo nombre, entonces dentro de
esta función la variable que existe es la variable local.
10 Este es un ciclo repetitivo for en la cual la variable local “cuenta” toma un valor de 1 hasta 10.
1 1Al terminar de ejecutarse la función func2 regresamos a la función func1, y se imprime el valor
de la variable global “cuenta” que vale 100.
Cuando salimos de la función func2 todas sus variables locales se destruyeron.
OPERADORES ARITMETICOS
SUMA +
RESTA -
MULTIPLICACION *
RESIDUO ENTERO %
RAIZ CUADRADA sqrt ( )
POTENCIACION pow (base, exponente)
¿Que es el Residuo Entero? En algoritmo al residuo entero se le llama “mod ó modulo”

Por ejemplo:
5 mod 2 = 1 ó 5%2=1
porque:
2
2 5
1 Residuo o Modulo
8
PRIORIDAD DE LOS OPERADORES EN GENERAL
1. ()
2. ^
3. *, /, mod, div, NOT
4. +, -, AND
5. >, <, <=, >=, < >, =, OR
¿Cuando se usan los parentesis ? Cuando se quiere dar prioridad a cierta operación sobre
otras.
Por ejemplo:
m = y2 - y1 = Expresarlo en forma correcta para programación ...

x2 - x1
m = y2 - y1 / x2 - x1 No es correcto !!!
m = (y2 - y1) / (x2 - x1) Si es correcto
FUNCIÓN DE C PARA LA POTENCIA. pow (base, exponente)

Por ejemplo:
1. X2 =
pow (X,2)
2. h = a2 + b 2 =
h = pow (a,2) + pow (b,2)
3. (a (b + c))2 =
pow (a*(b + c), 2); porque : (a*(a + c)) es la base y 2 es el exponente
FUNCIÓN DE C PARA LA RAIZ: sqrt ( )

Por ejemplo:
1. x= a
x = sqrt (a)
2. a= a+b
a = sqrt ( a + b)
3. A = P(P - A)(P - B)(P - C)

9
A = sqrt ( P * (P - A) * (P - B) * (P - C) )
Expresar en forma correcta para programación lo siguiente
1. x = - b + - b2 - 4ac
2a
x1 = (-b + sqrt (pow(b,2) - 4*a*c)) / (2*a)
x2 = (-b - sqrt (pow(b,2) - 4*a*c)) / (2*a)
2. despejar m de : pv = m( t + 460)
pv =m
(t + 460)
m= pv =
(t + 460)
m = (p*v) / (t + 460)
3. Expresar para programación:
d = (X2 - X1)2 + (Y2 - Y1)2
d = sqrt ( pow((X2 - X1), 2 ) + pow (( Y2 - Y1), 2))
4. h2 = a2 + b 2
h= a2 + b 2
h = sqrt ( pow(a,2) + pow(b,2) )
5. d= x2 + y2
d = sqrt ( pow (x,2) + pow (y,2) )
10
OPERADORES LOGICOS
1. NOT !
2. AND &&
3. OR ||
Los operadores logicos se utilizan para establecer condiciones compuestas
TABLA DE VERDAD DE LOS OPERADORES LOGICOS
NOT
A !A Comentario
V F El NOT convierte de verdadero a

F V falso y, de falso a verdadero.
AND
A B A && B Comentario
V V V
V F F Para el AND con uno de sus dos
F V F elementos que sea falso, el resultado
F F F es falso.
OR
A B A || B Comentario
V V V
V F V Para el OR con uno de sus dos
F V V elementos que sea verdadero, el
F F F resultado es verdadero.
OPERADORES RELACIONALES: Establecen condiciones en un programa

1. Mayor que >
2. Mayor o igual que >=
3. Menor que <
4. Menor o igual que <=
5. Igual que ==
6. Diferente !=
11
El signo igual que = =
En algoritmo ponemos ...
Si a = b entonces
...
...
fin_si
En progración debemos poner ..
if (a = = b)
...
Ya que en if (a = b), para C es un error ya que a toma el valor que tenga b, no funciona.
Para C el signo de = es de Asignación, es decir, la variable toma el valor de lo que tenga enfrente,
por ejemplo:
x = a; ‘x ’ toma el valor de lo que valga ‘a’
a = b + c; ‘a ‘ toma el valor del resultado de la suma de b + c
A la utilización del signo = se le llama Asignación.
Pero ...
Si queremos Comparar dos valores, bien en un ciclo if, while, u otro entonces usaremos el
signo de Comparación o igual que ... = =
if ( c = = b ) “ Si c es igual a b entonces ... “
while ( a = = d ) “ Hacer mientras a sea igual a d “
El signo diferente !=
En algoritmo poniamos ...

Si a < > b entonces
...
...
fin_si
En programación utilizaremos ..
if ( a != b)
...
...
Es decir, “si a es diferente de b” entonces se entra al ciclo if
12
OPERADORES ESPECIALES:
Son monarios porque solo se aplican a un operando.
1. De incremento ++
2. Decremento --
Su uso:
1. Modo prefijo (pre - antes) ++a
2. Modo posfijo (pos - después)a + +
MODO PREFIJO ++a

Se incrementa ‘a’ en 1 y despues se usa.
MODO POSFIJO a++

Primero se usará ‘a’ luego su valor se incrementará en 1
Por ejemplo:
______________________________________________________________________________________
a = 5;
++a; 1
printf ( “%d”, a); 2
a ++; 3
printf (“%d”, a); 4

printf (“%d”, a); 5
______________________________________________________________________________________
1 Inmediatamente se incrementa ‘a’ en 1 (o sea, a = 6)

2 Se imprime el valor de ‘a’, se imprime 6
3 Primero debera ser usado ‘a’, luego su valor se incrementará en 1
4 Se imprime el valor de a que es 6, en ese momento se ha usado ‘a’ por lo que se incrementa ‘a’
en 1 ( a = 7)
5 Se imprime el valor actual de a que es 7
FUNCIONES BASICAS
FUNCION scanf (“ formato “, nombre_ver) ;
Especificadores de Formato
%c Caracter
%d Entero decimal
13
%i Entero decimal
%e flotante
%f flotante
%g flotante
%o octal
%s Cadena de caracteres
%x Hexadecimal
Especificamos cualquiera de los “Especificadores de formato” dependiendo de lo que se

vaya a leer (El dar un dato por teclado significa “leer” ). Ejemplos:
scanf (“ % c ”, &sexo); Nos pide que tecleemos (leamos) el sexo de la persona, el

“ %c “ significa que sexo es una variable de tipo caracter, y
vea que al utilizar el scanf, a la variable se le antepone el &, lo
cual significa que guarde en la dirección en la cual esta
almacenada la variable.
scanf (“ % d “ , &edad); Nos pide que tecleemos la edad de la persona, el “ % d “

significa que debe ser un valor numérico entero en decimal
(es decir, no octal, no hexadecimal).
scanf (“ % o “, &numero); Nos pide que leamos un número, pero en octal, por ejemplo
si capturo 10 en realidad es un 108 (diez en octal).
scanf (“ % x “, &numero); Nos pide que leamos un número, pero en hexadecimal, por
ejemplo si capturo 10 en realidad es un 1016 (diez en
hexadecimal).
scanf (“ % f ”, &estatura); Nos pide que tecleemos la estatura, el “ % f ” significa que

debe ser un valor numérico flotante ( numero real )
scanf (“ % e ”, &estatura); Nos pide que tecleemos la estatura, el “ % e ” significa que

debe ser un valor numérico en notación exponencial. Por
ejemplo para un número como 0.0325 deberé teclear 3.25 e - 2
que es igual a 3.25 x 10-2
scanf (“ % s “, nom); Nos pide que tecleemos una cadena de caracteres. Por
ejemplo “Felipe de Jesus” . El problema con esta instrucción
es que solo guardaría la palabra “Felipe” se requiere la
instrucción siguiente para guardar la siguiente palabra “de”.
(Esta instrucción no es apropiada para guardar cadena de
caracteres, se debe usar la función gets ( ) como veremos mas
adelante).
scanf (“ % i “, &peso); Toma lo que haya en el buffer de memoria ( en este caso la

palabra “de” ) y lo guarda en &peso
14
FUNCION gets ( )
Permite leer cadena de caracteres completas incluyendo espacios en blanco.
gets (nom_var_cadena);
Ejemplo:
char nom[31]
....
....
gets (nom);
FUNCIÓN printf ( )
Visualiza mensajes, así como valores de variables.
printf ( cadena_de_control );
La cadena de control esta formada por dos tipos de elementos. El primer tipo esta
compuesto por los caracteres que se mostrarán en la pantalla.
El segundo tipo contiene especificadores de formato que define la forma en que muestran
los argumentos posteriores. Un especificador de formato empieza con un signo de porcentaje y
sigue con el codigo de formato debe haber exactamente el mismo número de argumentos que de
especificadores de formato y ambos deben coincidir en su orden de aparición de izquierda a
derecha.
Especificadores de Formato
%c Caracter
%d Enteros decimales con signo
%i Enteros decimales con signo
%e Notación cientifica ( e minuscula)
%E Notación cientifica ( E mayuscula)
%f flotante (despues del punto decimal tiene 6 digitos de precisión)
%g Usar % e ó % f, el más corto (selecciona automaticamente la expresión mas corta)
%G Usar % E ó % F, el más corto
%o octal sin signo
%x Hexadecimal sin signo (letras minusculas)
%X Hexadecimal sin signo (letras mayusculas)
%s Cadena de caracteres
%U Enteros decimales sin signo
%p Muestra un puntero
15
Por ejemplo:
int numero = 25;
printf ( “ % d “, numero); imprime 25
printf ( “ % i “, numero); imprime 25
printf ( “ % o “, numero); imprime 31 (numero octal)
printf ( “ % x “, numero); imprime 19
printf (“ % u “, numero); imprime 25
printf ( “ % X “, numero + 6); imprime 1F (numero hexadecimal)
Nota: Si no hubiera avance de línea entonces imprimiria 25253119251F así pues, se requiere
especificar un “avance de Línea” con \n Por ejemplo:
printf (“ % d \n ”, numero);
Con la instrucción printf ( ) también puede imprimirse un texto y a la vez el valor de una variable,
vea como:
int num = 15;

printf (“ La variable num vale: % d “, num); se imprime en pantalla: 15
Vea como el texto: “ La variable num vale: ” esta dentro de las comillas, y también el
especificador de formato % d, y fuera de las comillas va una coma y la variable que se va a
imprimir, en este caso num. Si voy a imprimir una variable entonces necesito un especificador de
formato.
otro ejemplo:
int a = 2, b = 8, c;
c = a + b;
printf (“%d + %d = %d \n”, a, b, c);
Se imprime en pantalla: 2 + 8 = 10
Observaciones: considere los signos +, = como simple texto que se imprime, vea como
tenemos tres especificadores de formato que afectan a tres variables respectivamente.
Imprimir un número real con una cantidad determinada de decimales

Si queremos imprimir un numero real con una cierta cantidad de decimales usaremos el
siguiente formato:
16
printf (“ % 5.2 f “, numero); Se imprimaran en total 5 números dos de los cuales serán
para caracteres, así: XXX.XX
Elaborar un programa que dado un número de cuatro cifras, lo presente invertido en su orden.
Por ejemplo se le lee el numero 4895 debe imprimirse el numero 5984
______________________________________________________________________________________
# include <stdio.h>
# include <math.h>
void main()
{
int A, B, C, X1, X2, X3, Num2, Num;
printf ("Dame un numero de 4 digitos:");

scanf ("%4d", &Num);
A=Num % 1000;
X1=Num / 1000;
B=A % 100;
X2=A / 100;
C=B % 10;
X3=B / 10;
Num2 = (C*1000) + (X3*100) + (X2*10) + X1;
printf ("El resultado es: %d\n", Num2);
getch();
}
______________________________________________________________________________________
Tres personas desean establecer una empresa para la cual cada una de ellas hace una aportación
económica para integrar el capital social de dicha empresa.
Hacer un programa determina el porcentaje de participación que tendrán en la empresa.
______________________________________________________________________________________
# include <stdio.h>
void main()
{
float cap1, cap2, cap3, capsocial, part1, part2, part3;
printf ("Importe del primer inversionista:");
17
scanf ("%f", &cap1);
printf ("Importe del segundo inversionista:");

printf ("Importe del tercer inversionista:");

capsocial = cap1 + cap2 + cap3;
part1 = (100/capsocial) * cap1;

printf ("Porcentaje del primer inversionista: %3.0f \n", part1);

printf ("Porcentaje del segundo inversionista: %3.0f \n", part2);
printf ("Porcentaje del tercer inversionista: %3.0f \n", part3);
getch();
}
______________________________________________________________________________________
Hacer un programa que determine la distancia que hay entre dos puntos de una línea recta en el
plano cartesiano. Así como también la pendiente de esa línea recta. Utilizando las siguientes
fórmulas:
d= (x2 - x)2 + (y2 - y1)2
m = y2 - y1
x2 - x1
______________________________________________________________________________________
# include <stdio.h>
# include <math.h>
void main()
{
float x2, x1, y2, y1, d, m;
printf ("El valor de x2:");

scanf ("%f", &x2);
printf ("El valor de x1:");

scanf ("%f", &x1);
printf ("El valor de y2:");

scanf ("%f", &y2);
18
printf ("El valor de y1:");

scanf ("%f", &y1);
d = sqrt (pow((x2-x1),2) + pow((y2-y1),2));

m = (y2-y1) / (x2-x1);
printf ("El valor de d es: %f \n", d);

printf ("El valor de m es: %f \n", m);
getch();
}
______________________________________________________________________________________
SENTENCIAS SELECTIVAS
FUNCION if ( )
Sintaxis:
a) if (expresión)
sentencia;
b) if (expresión)
{
...
sentencias;
...
}
¿Que entendemos por “expresión” ?

En algoritmo (y en C) para entrar a un ciclo sea if u otro, utilizaremos una condición tal
como if (a > b) ... , if ( x = = 0) ... etc. Lo que hemos visto son condiciones (que si a es mayor a b,
que si x es igual a cero entonces se entra al ciclo) pero en lenguaje C no tan solo puede haber
condiciones sino expresiones tales como ...
if ( a )
En esta expresión “ ( a ) ” significa que si ‘a’ tiene un valor previo de 0 entonces la

expresión es falsa y no se entra al ciclo, si ‘a’ tiene un valor de 1 en adelante entonces la expresión
es cierta y si se entra al ciclo.
Otro ejemplo de “expresión”.
if ( a + 5)
19
En esta expresión “ (a + 5) “ si la suma de lo que vale ‘a’ mas 5 es igual a 0 entonces la

expresión es falsa y no se entra al ciclo, si la suma de ‘a’ mas cinco da 1 ó mas entonces la
expresión es verdadera y se entra al ciclo.
Otro ejemplo de “expresión”.
if ( digito(num) )
El programa se dirige a la función “dígito” si en esta función el valor de “num” es cero

entonces la expresión es falsa, si “num” vale 1 ó mas entonces la expresión es verdadera.
Observación sobre el uso del signo de comparación de igualdad en los ciclos
Recuerde que para C el signo = es de “asignación” y la comparación de igualdad se

efectúa con el signo = = de tal forma que si por ejemplo tengo :
1. if ( a = 0 )
2. if ( a = = 0 )
El primer ejemplo es incorrecto, ya que ‘a’ toma el valor de cero, no funciona el ciclo ya
que si ‘a’ siempre vale cero entonces la expresión siempre será falsa.
El segundo ejemplo esta bien expresado, si a es igual con 0 entonces el ciclo toma una
valor de 1, o sea es verdadero y si se entra al ciclo.
Si ‘a’ no es igual a 0 entonces el ciclo toma un valor de 0, o sea es falso y no se entra al
ciclo.
ANALISIS DE LA SINTAXIS DE LA FUNCION if ( )

Sintaxis:
a) if (expresión)
sentencia;
b) if (expresión)
{
...
sentencias;
...
}
Observe que cuando hay una sola sentencia (una sola línea de instrucción) entonces no
habrá llaves al principio y final de dicha sentencia. Y al no haber llaves el lenguaje C entiende
que solo hay una sentencia que pertenece al if.
20
Si hay mas de una sentencia (dos o más) entonces debe haber llave que abre al principio y
una llave que cierra al final de la sentencias.
Funcion if ( ) ... else

Sintaxis:
a) if (expresión)
sentencia;
else
sentencia;
b) if (expresión)
{
...
sentencias;
...
}
else
{
...
sentencias;
...
}
c) if (expresión)
{
...
sentencias;
...
}
else
sentencia;
d) if (expresión)
sentencia;
else
{
...
sentencias;
...
}
21
En la función if ( ) ... else Si para el cuerpo del if no se abre llave, el lenguaje C entiende
que solo hay una sentencia que pertenece a la parte del if, igual ocurre con la parte del else, si no
se abren llaves se entiende que solo le corresponde una sola sentencia.
Si para un bloque sea este el if o el else le corresponden dos o mas sentencias, entonces
debe haber llaves que cubran todas las sentencias que les pertenece.
Programa: En un supermercado se hace una promoción, mediante la cual el cliente obtiene

un descuento dependiendo de un numero que se escoge al azar. Si el numero escogido es menor
que 74 el descuento es del 15 % sobre el total de la compra, si es mayor o igual a 74 el descuento
es del 20%. Obtener cuanto dinero se le descuenta
______________________________________________________________________________________
# include <stdio.h>
void main()
{
int num;
float compra, desc;
printf ("Valor del numero:");

scanf ("%d", &num);
printf ("Importe de la compra:");

scanf ("%f", &compra);
if (num< 74)
desc = compra * .15;
else
desc = compra * .20;
printf ("Descuento efectuado: %5.2f ", desc);

getch();
}
______________________________________________________________________________________
22
SENTENCIA SWITCH( ) ... CASE
Es una sentencia de control selectiva, es decir, de un menú previo se elige solo una
opción, y solo se ejecutara el bloque correspondiente a la opción elegida.
Sintaxis
switch (expresion)
{
case <valor_1>:
...
sentencias;
...
break;
case <valor_2>:
...
sentencias;
...
break;
case <valor_n>:
...
sentencias;
...
}
Donde:
valor_ Es un valor constante o fijo

break Significa que no se revisen los otros casos, que una vez que el programa ha
seleccionado y ejecutado un determinado bloque, después de ello debe salirse del ciclo.
Observe que en el ultimo bloque ya no requiere un break porque si el programa entra a
este ultimo bloque, lo ejecuta y luego sigue la salida del programa.
Programa: Este permite al usuario llevar a cabo el calculo del área de cualquier de las
siguientes figuras geométricas:
1. Cuadrado
2. Rectángulo
3. Triángulo
4. Circulo
______________________________________________________________________________________
# include <stdio.h>
# define PI 3.141596
23
void main( )
{
int l, b, h, r, opc;
float a;
printf ("Menu de figuras geometricas \n");

printf ("1.- Cuadrado \n");
printf ("2.- Rectangulo \n");
printf ("3.- Triangulo \n");
printf ("4.- Circulo \n");
printf ("Opcion:");
scanf ("%d",&opc);
switch (opc)
{
case 1:
printf ("Calculo del area de un cuadrado\n");
printf ("Longitud del lado:");
scanf ("%d", &l);
a = l * l;
printf ("Area = %f \n", a);
break;
case 2:
printf ("Calculo del area del rectangulo \n");
printf ("Longitud de la base");
scanf ("%d", &b);
printf ("Longitud de la altura:");
scanf ("%d", &h);
a = b * h;
break;
case 3:
printf ("Calculo del area del triangulo:");
printf ("Longitud de la base:");
scanf ("%d", &b);
printf ("Longitud de la altura:");
scanf ("%d", &h);
a = b * h / 2;
break;
case 4:
printf ("Calculo del area del circulo:");
printf ("Valor del radio:");
scanf ("%d", &r);
a = PI * r * r;
}
getch();
}
______________________________________________________________________________________
24
SENTENCIA DE CONTROL DE CICLOS
1. SENTENCIA while ( )
Hacer mientras la condición sea cierta, en el momento que la condición sea falsa se sale. Si
la condición fuera falsa desde un principio entonces nunca entra.
V
F
Condición
Sentencias
Sintaxis:
1. while (expresión)
sentencia;
2. while (expresión)
{
...
sentencias;
...
}
25
Observe que el ciclo while al igual que el if, si solo le pertenece una sentencia, no se usan
llaves, el lenguaje C entiende que solo hay una sola sentencia para el ciclo. Si al ciclo le
corresponden dos o mas sentencias entonces estas deberán estar cubiertas con llaves que abran y
cierren, como en el segundo caso.
Programa: Se desea obtener cual fue la mayor, la menor y el promedio de calificaciones

obtenido por un grupo de 20 alumnos.
______________________________________________________________________________________
# include <stdio.h>
# define max 20
void main()
{
int ca=1, scal=0, cal, may, men;
float prom;
while (ca <= max)

{
printf ("Introduzca la calificacion del %d alumno:", ca);
scanf ("%d", &cal);
if (ca == 1)
{
may = cal;
men = cal;
}
else
if (cal > may)
may = cal;
else
if (cal < men)
men = cal;
scal+ = cal;
++ca;
prom = scal / max;

printf ("Promedio: %5.2f \n", prom);
printf ("Calificacion mayor: %d \n", may);
printf ("Calificacion menor: %d \n", men);
getch( );
}
______________________________________________________________________________________
26
Programa: Una persona debe realizar un muestreo con 50 personas para determinar el
promedio de peso de los niños, jóvenes, adultos y viejos que existen en una zona habitacional. Se
determina la categoría con base en la siguiente tabla.
Categoría Edades
Niños 0 - 12
Jóvenes 13 - 29
Adultos 30 - 59
Viejos 60 ...
______________________________________________________________________________________
# include <stdio.h>
void main( )
{
float edad, ninos=0, suma1=0, joven=0, suma2=0, adultos=0;
float suma3=0, viejos=0, suma4=0;
float prom_n, prom_j, prom_a, prom_v;
int c = 0;
while (c < 50)

{
printf ("Edad de la persona:");
scanf ("%f", &edad);
if (edad <=12)
{
suma1+=edad;
ninos+=1;
}
else
if (edad <=29)
{
suma2+=edad;
joven+=1;
}
else
if (edad <=59)
{
suma3+=edad;
adultos+=1;
}
else
{
suma4+=edad;
viejos+=1;
}
c+=1;
}
27
prom_n=suma1/ninos;
prom_j=suma2/joven;
prom_a=suma3/adultos;
prom_v=suma4/viejos;
printf ("Promedio de peso de los niños %5.2f \n", prom_n);

printf ("Promedio de peso de los jovenes %5.2f \n", prom_j);
printf ("Promedio de peso de los adultos %5.2f \n", prom_a);
printf ("Promedio de peso de los viejos %5.2f \n", prom_v);
getch();
}
______________________________________________________________________________________
Observaciones:
1. En este programa vea que en los ciclos if ... else las instrucciones que
corresponden a cada if están cubiertas por llaves, pero cuando a un else le sigue un if no se usan
llaves para cubrir a este if, dado que no es necesario, ya que se toma por una sola instrucción,
independientemente de todas las instrucciones que dentro de ese if estén, pero esas instrucciones
ya corresponden al if interno y no al else
2. El programa funciona, pero si por ejemplo no hubiera niños, entonces niños=0, y
suma1=0, y 0/0 es un error para C.
Programa: Un entrenador le ha propuesto a un atleta recorrer una ruta de 5 km. durante 10

días, para determinar si es apto para la prueba de 5 km. o debe buscar otra especialidad. Para
considerarlo apto debe cumplir por lo menos una de las siguientes condiciones.
1. Que en ninguna prueba haga un tiempo mayor a 16 minutos.
2. Que al menos en una prueba realice un tiempo mayor de 16 minutos.
3. Que su promedio de tiempo sea menor o igual a 15 minutos.
______________________________________________________________________________________
# include <stdio.h>
void main()
{
int c=0, x=0, r1=1, r2=1, r3=1;
float suma=0, tiempo=0, prom;
while (c<10)
{
printf ("Tiempo hecho:");
scanf ("%f", &tiempo);
if (tiempo <=16 && r1==1)

r1=1;
else
r1=0;
28
if (tiempo>16 && x<1)

{
r2=1;
x+=1;
}
else
if (tiempo <=16 && r2==1)
r2=1;
else
r2=0;
suma+=tiempo;
c+=1;
}
prom=suma/10;
if (prom<=15)
r3=1;
else
r3=0;
printf ("Prom. es: %f, prueba1= %d, prueba2 = %d, prueba3 = %d \n", prom, r1,r2, r3 );
if (r1==1 || r2==1 || r3==1)

printf ("El deportista es APTO");
else
printf ("El deportista NO es Apto");
getch();
}
______________________________________________________________________________________
Programa: El mismo problema anterior se resuelve con el siguiente programa de una forma
mas sencilla. Analícelo.
______________________________________________________________________________________
# include <stdio.h>
void main()
{
float tiempo, prom, capto=0, cnapto=0, c=0, total=0;
29
while (c<10)
{
printf ("Cual es el tiempo:");
scanf ("%f", &tiempo);
if (tiempo<=16)
capto=capto + 1;
else
cnapto=cnapto + 1;
total=total + tiempo;
c+=1;
}
prom=total/10;
printf ("Su promedio es %f ", prom);
printf ("Contador de apto %f, Contador no apto %f\n ", capto, cnapto);
if ( capto==10 || cnapto==1 || prom<=15)

printf ("El deportista es APTO");
else
printf ("El deportista NO es Apto");
getch();
}
______________________________________________________________________________________
Programa: El gobierno del estado de México desea reforestar un bosque que mide
determinado número de hectáreas.
Si la superficie del terreno excede un millón de m2 entonces decidirá sembrar de la
siguiente manera:
1. 70 % de arboles de pino
2. 20 % de arboles de hóyameles
3. 10 % de arboles de cedro
Si la superficie del terreno es menor o igual a 1 millón de m2 entonces decidirá sembrar

de la siguiente manera:
1. 50 % de arboles de pino
2. 30 % de arboles de hóyameles
3. 20 % de arboles de cedro
El gobierno desea saber el numero de pinos, hóyameles y cedros que tendrá que sembrar
en el bosque, si se sabe que en 10 m2 cabe 8 pinos, en 15 m2 cabe 15 hóyameles y en 18 m2 cabe 10
cedros. También se sabe que una hectárea equivale a 10,000 m2
______________________________________________________________________________________
# include <stdio.h>
30
void main()
{
float superf, b, pinos, hoya, ced;
printf ("Programa que determina la cantidad de arboles a sembrar\n");

printf ("Cual es la superficie del terreno:?");
scanf ("%f", &superf);
if (superf>1000000)
{
b=((1.25/1)*7) + ((1/1)*2) + ((1.8/1)*1);
pinos=(7/b)*superf;
hoya=(2/b)*superf;
ced=(1/b)*superf;
}
else
{
b=((1.25/1)*5) + ((1/1)*3) + ((1.8/1)*2);
pinos=(5/b)*superf;
hoya=(3/b)*superf;
ced=(2/b)*superf;
}
printf ("Cantidad de pinos a sembrar: %8.2f \n", pinos);

printf ("Cantidad de hoyameles a sembrar: %8.2f \n", hoya);
printf ("Cantidad de cedros a sembrar: %8.2f \n", ced);
getch();
}
______________________________________________________________________________________
Nota: La constante ‘b’ de la formula: b=((1.25/1)*7) + ((1/1)*2) + ((1.8/1)*1)

Donde: b= ((10 m /8 pinos * 1 pino)* 7) + (( 15 m2 / 15 hoya * 1 hoya)* 2) +
2
((18 m2/ 10 ced * 1 ced)* 1) =
b= 12.55 m2
Vea que dentro de los paréntesis internos lo que ocurre son simples conversiones y nos
queda un resultado en metros cuadrados, dichos resultados en m2 son multiplicados por 7, 2, y 1
que equivalen al porcentaje de 70%, 20% y 10% respectivamente. De esta forma se crean las
constantes: 7/b, 2/b, 1/b para pinos, hoya y cedros, respectivamente. Donde podemos despejar
para una determinada superficie.
pinos= (7/b)*superf;
hoya= (2/b)*superf;
ced= (1/b)*superf;
31
2. SENTENCIA do ... while ( )
sentencias
F V
expresion
Sintaxis:
1) do
sentencia;
while (expresión);
2) do
{
...
sentencias;
...
}
while (expresión);
En el ciclo do ... while ( ) las sentencias se realizan cuando menos una vez, ya que la
evaluación de la expresión se da hasta el final del ciclo. El ciclo continua mientras la expresión
sea verdadera.
32
Con una sola sentencia no se usan llaves, con dos o mas sentencias estas deben ser
cubiertas por llaves. Observe que el último renglón del ciclo while (expresión); termina con un
punto y coma.
Programa: Leer 12 calificaciones de un grupo de alumnos e imprima el porcentaje de

aprobados. La calificación mínima aprobatoria es de 70. Utilizar el ciclo do ... while().
______________________________________________________________________________________
# include <stdio.h>
void main()
{
int ca=0, capro=0, cal;
float pa;
do
{
++ca;
printf ("Calificacion del %d alumno:", ca);
scanf ("%d", &cal);
if (cal>=70)
capro=capro+1;
}
while (ca<12);
printf ("capro vale: %d ", capro);
pa=capro*100/12;
printf ("Porcentaje de aprobados: %f\n", pa);
getch();
}
______________________________________________________________________________________
Observaciones: El ciclo do ... while () se realiza mientras sea verdadero, y se ejecuta cuando menos
una vez.
33
3. SENTENCIA for ( )
V=Vi
V<=Vf
F
V=V+1
Sentencias
Donde:
V Es una variable que actúa como contador
Vi Valor inicial (constante o variable)
Vf Valor final (constante o variable)
Sintaxis:
a) for ( expresión1; expresión2; expresión3)

sentencia;
b) for ( expresión1; expresión2; expresión3)

{
...
sentencias;
...
}
Donde:
expresión1; Es generalmente una expresión de inicialización

expresión2; Es generalmente una expresión condicional
expresión3; Es generalmente una expresión de incremento
34
Ejemplos:
1) for (i = 1; i<=20; i ++) 1
sn+ = i;
2) i = 1; 2
for ( ; i<=20; i ++)

sn+ =i;
3) i = 1; 3
for ( ; i<=20; )
{
sn+=i;
i++;
}
4) i = 1; 4
for ( ; ; )
{
ns+=i;
if (i<=20)
i++;
else
break; 5
35
1En el ejemplo No. 1, supongamos que la variable ‘sn’ tiene un valor inicial de 0, de tal forma
que al ejecutarse este ciclo for la variable ‘sn’ primero vale 1, luego vale la suma de 1 mas 2, luego
vale la suma de 3 mas 3 y así sucesivamente hasta que ‘i ’ vale 19 se termina el ciclo.
sn+=i; es lo mismo que sn = sn + i El ciclo for le da un valor inicial de 1 a ‘i ‘ y se incrementa su
valor de 1 en 1
2Vea que antes de iniciar el ciclo for tenemos la expresión de inicialización (i = 1), de tal forma
que esta ya no aparece como primera expresión del for, quedando en su lugar solo el punto y
coma (;)
El programador puede quitar de la sentencia for esta expresión de inicialización o
cualquier otra, o las tres, pero queda a su responsabilidad anotarlas en el lugar correcto
3En el tercer caso, no tan solo queda fuera la expresión de inicialización, sino también la tercera
expresión que es la de incremento del ciclo (i ++) - Cuando la variable ‘i ‘ incrementa su valor de
1 en 1 con cada vuelta del ciclo - . Observe que aunque se han quitado dos expresiones, estas
quedan representadas por puntos y comas.
Y como ya se había mencionado en estos casos queda bajo responsabilidad del
programador poner dichas expresiones en el lugar adecuado.
4 En el cuarto caso se han quitado de la sentencia for las tres expresiones, quedando en la
sentencia dos puntos y comas - for (; ;) - y expresándose fuera de dicha sentencias las expresiones
del ciclo.
5 La palabra “break” permite salir del ciclo
NOTA: Al igual que con otros ciclos, si al ciclo for le corresponde una sola sentencia
entonces no se usan llaves, si le corresponden dos o mas sentencias entonces el cuerpo del ciclo
va cubierto por llaves.
Programa: Se crea un ciclo for, para ejecutarse diez veces (x=0; x<10) y los incrementos son de uno
en uno ( x++) Se va a imprimir “valor de x:” en varias ocasiones donde x toma un valor desde 0
hasta 7 y no llega a 10 dado que la instrucción (x == 7) “si x es igual a 7 ” entonces x=10 y cuando
el programa regresa a la sentencia for, ya x no es menor a 10 y se sale del ciclo
______________________________________________________________________________________
# include <stdio.h>
void main()
{
int x;
for (x=0; x<10; x++)
{
printf ("valor de x: %d \n", x);
if (x==7)
x=10;
}
getch();
}
______________________________________________________________________________________
36
En la parte del programa: if (x==7)

x=10;
Cuando x toma valor de 10 y por lo tanto se sale del ciclo, pudimos haber salida con la
instrucción break, así.
if (x==7)
break;
Programa: Realizar un programa que permite calcular una elevación a una potencia, por
ejemplo si dada una base de 2 y dado un exponente de 3 el resultado debe ser 8 porque 23 =8
______________________________________________________________________________________
# include <stdio.h>
void main()
{
int a,n,i;
long int pot=1; 1
printf ("Valor de la base:");

scanf ("%d",&a);
printf ("Valor de la potencia:");

scanf ("%d",&n);
for (i=1;i<=n;i++)
pot*=a; 2
printf ("%d elevado a la %d es: %d \n",a,n,pot);

getch();
}
______________________________________________________________________________________
1 La palabra long int significa que la variable “pot” no este limitada a un rango de -32,767 a 32,767
ya que long int asigna a “pot” la capacidad de tomar un valor de
-2,147,483,647 a 2,147,483,647
2 La sentencia pot*=a; es lo mismo que pot=pot * a, es decir, conforme el ciclo for se ejecuta una y
otra vez pot vale primeramente el resultado de multiplicar 1 por la base que se por ejemplo: base
=2, exponente =3 entonces mientras se ejecuta el ciclo for ocurre que:
(pot=pot*a)
pot a (base) n (exponente) i (del ciclo for: i<=n) por * = a
1 2 3 1 1*2=2
2
2 2*2=4
4
3 4*2=8
8 Resultado final de “pot”
37
Programa: Dada una determinada cantidad de materias, obtener el promedio.

______________________________________________________________________________________
# include <stdio.h>
void main()
{
int suma=0, cal, prom, c, i;
printf ("dame la cantidad de materias a las que sacara promedio:");

scanf ("%d", &c);
for (i=0; i<c; i++)

{
printf ("Dame la calificacion de la %d materia:", i +1); 1
scanf ("%d", &cal);
suma+=cal; 2
}
prom=suma/c; 3
printf ("Promedio obtenido: %d ", prom);
getch();
}
______________________________________________________________________________________
1 Cuando dice “Dame la calificación de la ... materia” lo que aparece en pantalla es: “Dame la
calificación de la 1 materia, de la 2 materia, de la 3 materia, etc. la expresión i +1 no altera el valor
de ‘ i ‘ solo que para efectos de presentación en pantalla no conviene que aparezcan “Dame la
calificación de la 0 materia, sino de la 1 materia y así sucesivamente conforme ‘i ‘ incrementa su
valor.
2 Recuerde que suma+=cal es lo mismo que decir suma=suma + cal, es decir, la variable ‘suma’
que tiene una valor inicial de cero, funciona como variable acumulador (o sumador) sumando
todas las calificaciones.
3Un promedio siempre se obtendrá dividiendo la suma acumulada entre la cantidad de materias,
en este caso. De tal forma que prom=suma/c; el promedio es igual a la suma acumulada entre ‘c‘
que es la cantidad de materias.
38
Programa: Se tiene un grupo de n alumnos en donde cada uno de ellos cursa un cierto
número de materias. Hacer un programa que determine.
a) El promedio por alumno
b) El alumno que obtuvo el mayor promedio
c) El alumno que obtuvo el menor promedio
d) El promedio del grupo
c) Por cada alumno obtener en que materia obtuvo la menor calificación
______________________________________________________________________________________
# include <stdio.h>
void main()
{
int na,ca,nm,cm,alumay,alumen,matmen;
float cal, calmen, calmay,scal=0,prom, promay, promen;
float promgpo, sprom=0;
printf ("Numero de alumnos:");

scanf ("%d", &na);
for (ca=1; ca<=na; ca++)

{
float scal=0;
printf ("Cantidad de materias a las que sacara promedio?:");

scanf ("%d", &nm);
for (cm=1;cm<=nm;cm++)
{
printf ("Dame la calificacion de la %d materia:", cm);
scanf ("%f", &cal);
scal+=cal;
if (cm==1)
{
calmen=cal;
matmen=cm;
}
else
if (cal<calmen)
{
calmen=cal;
matmen=cm;
}
39
prom=scal/nm;
printf ("Promedio obtenido del %d alumno: %5.2f\n",ca, prom);

printf ("Materia en la que obtuvo la menor calificacion %d\n",matmen);
if (ca==1)
{
promay=promen=prom;
alumay=alumen=ca;
}
else
if (prom>promay)
{
promay=prom;
alumay=ca;
}
else
if (prom<promen)
{
promen=prom;
alumen=ca;
}
sprom+=prom;
}
printf ("Promedio mayor %5.2f del alumno %d \n", promay, alumay);

printf ("Promedio menor %5.2f del alumno %d \n", promen, alumen);
promgpo=sprom/na;
printf ("Promedio del grupo %5.2f\n:", promgpo);

getch();
}
______________________________________________________________________________________
40
ARREGLOS (ARRAYS)
Un arreglo es una colección de variables del mismo tipo que se referencian utilizando un
nombre común. En turbo C, un arreglo o array consta de posiciones de memoria contiguas. La
dirección más baja corresponde al primer elemento y la más alta al último. Un arreglo puede
tener una o varias dimensiones. Para acceder a un elemento especifico de un arreglo se usa un
índice.
En resumen, un Arreglo es un conjunto de posiciones contiguas, que tienen un nombre. Donde
cada elemento del arreglo es de un mismo tipo (char, int, float, etc.).
Una Variable almacena un solo valor, un Arreglo almacena un conjunto de valores.
Arreglos unidimensionales
El formato general para la declaración de un arreglo unidimensional es
tipo nombre_var[tam];
Aquí tipo declara el tipo base del arreglo. El tipo base determina el tipo de datos de cada
elemento del arreglo. El tam define cuántos elementos guardará. Por ejemplo, lo siguiente declara
un arreglo de enteros llamado “ejemplo” de diez elementos:
int ejemplo[10];
En C, todos los arreglos usan cero como índice del primer elemento. Por tanto, el ejemplo
anterior declara un arreglo de enteros - int - de diez elementos: ejemplo[0] a ejemplo[9].
Arreglo “ejemplo” con 10 posiciones
0
1
2 Observe que el arreglo
3 contiene 10 posiciones, y la
primera posicion del arrego
4
es 0
5
6
7
8
9
En C, la primera posición no es 1, sino 0, y termina en n - 1.
0
1
2
3 Arreglo
.
.
.
n-1
41
Por ejemplo, el programa siguiente carga un arreglo de enteros con los numeros del del 0
al 9:
______________________________________________________________________________________
main ()
{
int x[10];
int i
for (i=0; i<10; i++)

x[i] = i;
}
______________________________________________________________________________________
Advertencia: Lenguaje C no da la comprobación de contornos
El lenguaje C no realiza comprobación de contornos en los arreglos: así no detiene la

escritura fuera del final del arreglo. Si se sobrepasa el final durante una operación de asignación,
entonces se asignarán valores a otra variable o a un trozo del código del programa. Hay otra
manera de ver este problema: se puede indexar un arreglo de tamaño N por encima de N sin
provocar ningún mensaje de error en tiempo de compilación o ejecución, incluso aunque
probablementese provoque el fallo del programa. Como programador, se es responsable de
asegurar que todos los arreglos sean lo suficientemente grandes para guardar lo que pondrá en
ellos el programa y de proporcionar las comprobaciones de contorno cuando sea necesario. Por
ejemplo, C compilará y ejecutará este programa incluso aunque se sobrepase el arreglo.
(No intentar este ejemplo; puede dañar el sistema.)

______________________________________________________________________________________
main()
{
int crash[10], i;
for (i=0; i<100; i++)

crash[i]=i;
}
______________________________________________________________________________________
Observe que el arreglo “crash” fue declarado para almacenar solo 10 elementos - int crash[10] -,
sin embargo, el ciclo for le introduce 100 elementos !!, es decir, se desborda el arreglo “crash”.
Esto hace que se sobreescriba información importante, ocasionando un fallo en el programa.
42
Representación en memoria
Variable: Tiene una posición

(dirección) y un contenido.
Arreglo: Conocemos la dirección de

inicio. El arreglo tiene contenidos en
posiciones contiguas de memoria
Como conocer la dirección de una determinada posición en un arreglo
Suponga que tiene una Arreglo con números enteros que empiezan a partir de la
dirección @ 142 ¿Cual seria la dirección de la posición 5?
Dirección = Dirección de inicio + Tamaño de dato en bytes * (posición - 1)
Donde: Tamaño de dato en este caso es 2 (bytes) por ser de tipo int - entero - .
142 + 2 * ( 5 - 1 ) = 142 + 2 * (5 - 1) =
= 142 + 2 * 4 = 142 + 8 =@150
0 @142
1 @144
2 @146
3 @148
4 @150 La Dirección de la quinta posicion es @150. Recuerde que C
5 empieza en 0 y la quinta posición realmente sera en n - 1 = 4
6
7
8
9
CLASIFICACIÓN DE LOS ARREGLOS
Según las dimensiones que tengan se clasifican en:
1. Unidimensionales, listas o vectores

2. Bidimensionales, también llamados tablas o matrices [Renglón, Columna]
3. Tridimensionales o cubos
(Se puede ver como un arreglo de matrices)
4. Multidimensionales: de mas de tres dimensiones
43
Vector Matriz Cubo
DECLARACIÓN DE UN ARREGLO
tipo nom_arreglo [n]
donde:
n Número máximo de elementos que puede tener el arreglo y es un valor constante.
Ejemplos:
int edad [30];

char cadena[81]; Aquí tenemos la Declaración de los arreglos
float produccion[12]:
0 0 0
1 1 1
2 2 2
. . .
. . .
. . .
28 79 10
29 80 11
edad cadena produccion

Como es de tipo entero, Como es de tipo char, cada Como es de tipo
cada posicion ocupa 2 posicion ocupa un solo flotante, cada posicion
bytes. Total 60 bytes byte. Total 81 bytes ocupa 4 bytes. Total 48
bytes
44
Observaciones: En el caso del vector “edad” puede ser un grupo de edades de 30

alumnos. En el vector “cadena” dado que es tipo char, no es mas que precisamente una cadena de
caracteres cualquier tal como “Tuxtepec, Oax. “ que no necesariamente debe ocupar las 80
posiciones, de hecho el último byte de una cadena de caracteres, se reserva para un caracter nulo.
En el caso del vector “producción” puede ser cantidades que se refieran a la producción de los 12
meses del año.
Decíamos que un arreglo de caracteres requiere la última posición del arreglo para una
caracter nulo. Así que si en el vector cadena introducimos la expresión:
T u x t e p e c , O a x . \0
14 posiciones realmente ocupadas + una posición para

un caracter nulo
Y dado que nuestro vector “cadena” tiene una capacidad de 81 posiciones, en este caso
todo las demás posiciones fueron desaprovechadas.
Programa: Crear un vector con 10 elementos, y una vez hecho que este vector genere otro
automáticamente con los elementos capturados en forma inversa al primer vector. Y visualizar
ambos vectores.
______________________________________________________________________________________
# include <stdio.h>
void main()
{
int vect1[10], vect2[10], i,x;
for (i=0; i<10; i++) /*En este ciclo nosotros capturamos el vector con 10 elem*/
{
printf ("Introduzca el %d valor:", i+1);
scanf ("%d", &vect1[i]);
}
i = 9;
for (x=0; x<10; x++) /*Este ciclo genera automaticamente el otro vector, inversamen*/
{
vect2[x]=vect1[i];
i = i - 1;
}
for (i=0; i<10; i++) /* Este ciclo visualiza el primer vector */

printf ("Vector 1: %d \n", vect1[i]);
for (i=0; i<10; i++) /* Este ciclo visualiza el segundo vector */

printf ("Vector 2: %d \n", vect2[i]);
getch();
}
______________________________________________________________________________________
45
PROGRAMAS CON VECTORES
Programa: Hacer un programa que determine si un vector a de 20 posiciones que esta

almacenado en memoria se encuentra ordenado ascendentemente.
______________________________________________________________________________________
# include <stdio.h>
void main()
{
int a[20], i, ordenado=1;
for (i=1; i<20 && ordenado==1; i++)

if (a[i - 1] > a[i]) 1
ordenado=0;
if (ordenado) 2
printf ("Esta ordenado \n");
else
printf ("No esta ordenado");
getch();
}
______________________________________________________________________________________
1La sentencia if compara el valor que se encuentra en el vector ‘a’ en la posición de i - 1 con el
valor que se encuentra en el mismo vector ‘a’ en la posición siguiente, es decir, la posición i. Si el
primer valor es mayor al segundo entonces la variable bandera “ordenado” toma un valor de 0 lo
que origina la salida del ciclo for.
2Esta sentencia if tiene una expresión - ordenado - si ésta tiene un valor de 1 entonces el if es
verdadero y se imprime “Esta ordenado”. De lo contrario si “ordenado” tiene un valor de 0 se
imprime “No esta ordenado”
Programa: Calcular el promedio de 50 valores almacenados en un vector. Determinar además

cuantos son mayores que el promedio, imprimir el promedio y una lista de los valores mayores
que el promedio.
______________________________________________________________________________________
# include <stdio.h>
void main()
{
int vect[50], i, cmay=0, suma=0, prom;
46
for (i=0; i<50; i++)

suma+=vect[i];
prom=suma/50;
printf ("El promedio es: %d\n", prom);
for (i=0; i<50; i++)

if (vect[i] > prom)
{
cmay+=1;
printf ( " Valor mayor al promedio %d, en posicion %d\n", vect[i], i+1);
}
printf ("Cantidad de valores mayores al promedio: %d", cmay);

getch();
}
______________________________________________________________________________________
Programa: Llenar 2 vectores A y B de 45 elementos cada uno, sumar el elemento uno del
vector A con el elemento uno del vector B y así sucesivamente hasta 45, almacenar el resultado en
un vector C, e imprimir el vector resultante.
______________________________________________________________________________________
#include <stdio.h>
void main()
{
int a[45], b[45], c[45], i;
for (i=0; i<45; i++)

{
printf ("Introduzca el %d elemento del vector 'a':\n",i+1);
scanf ("%d", &a[i]);
printf ("Introduzca el %d elemento del vector 'b':\n",i+1);

scanf ("%d", &b[i]);
c[i] = a[i] + b[i];

}
printf ("Vector resultante: \n");
for (i=0; i<45; i++)

printf ("%d\n", c[i]);
getch();
}
______________________________________________________________________________________
47
Programa: Llenar un vector con 20 elementos, imprimir la posición y el valor del elemento
mayor almacenado en el vector, suponga que todos los elementos del vector son diferentes.
______________________________________________________________________________________
# include <stdio.h>
void main()
{
int vect[20], i, mayor, pos;
for (i=0; i<20; i++)

{
printf ("Valor del %d elemento del vector:", i+1);
scanf ("%d", &vect[i]);
}
for (i=0; i<20; i++) 1

if (i==0)
{
mayor=vect[i];
pos=i+1;
}
else
if (vect[i] > mayor)
{
mayor=vect[i];
pos=i+1;
}
printf ("Valor mayor: %d, en posicion %d", mayor, pos);

getch();
}
______________________________________________________________________________________
Observaciones:
1 Para este ciclo for solo hay una sentencia o instruccion que le pertenece; la cual es la linea del if
siguiente. Por lo mismo, no hay llaves que cubran a todo este bloque del if. Recuerde todo lo que
esta dentro del if, incluyendo al mismo else es parte interno del if, o sea, ya no pertenece al ciclo
for.
En otras palabras, pudimos haber hecho esto:
48
for (i=0; i<20; i++) 1

Usar esta llaves, no afecta, pero no
{
es necesario dado si existe un solo
if (i==0)
if se toma como una sola
{ instrucción. Lo que este dentro del
mayor=vect[i]; if (incluyendo al else ) pertenece al
pos=i+1; if ya no son sentencias del for.
}
else
if (vect[i] > mayor)
{
mayor=vect[i];
pos=i+1;
}
Programa: Almacenar 500 números en un vector, elevar al cuadrado cada valor almacenado
en el vector, almacenar el resultado en otro vector. Imprimir el vector original y el vector
resultante.
______________________________________________________________________________________
# include <stdio.h>
# include <math.h>
void main()
{
int vec1[500], vec2[500], i;
for (i=0; i<500; i++)

{
scanf ("%d", &vec1[i]);
vec2[i] = pow(vec1[i], 2);

}
printf ("Valores del primer vector: \n");
for (i=0; i<500; i++)

printf ("%d\n", vec1[i]);
printf ("Valores del vector resultante: \n");
for (i=0; i<500; i++)

printf ("%d\n", vec2[i]);
getch();
}
49
______________________________________________________________________________________
Programa: Almacenar 300 números en un vector, imprimir cuantos son ceros, cuantos son
negativos, cuantos positivos. Imprimir además la suma de los positivos y la suma de los
negativos.
______________________________________________________________________________________
# include <stdio.h>
void main()
{
int vec[300], i, cc=0, cp=0, cn=0, sumpos=0, sumneg=0;
for (i=0; i<300; i++)

{
scanf ("%d", &vec[i]);
}
for (i=0; i<300; i++)

if (vec[i] == 0)
cc+=1;
else
if (vec[i]>0)
{
sumpos+=vec[i];
cp+=1;
}
else
{
sumneg+=vec[i];
cn+=1;
}
printf ("Cantidad de ceros: %d\n", cc);

printf ("Cantidad y suma de negativos: %d, %d \n", cn,sumneg);
printf ("Cantidad y suma de positivos: %d, %d \n", cp, sumpos);
getch();
}
______________________________________________________________________________________
Donde:
cc .- Es el contador de ceros. cp.- Es el contador números de positivos. cn.- Es el
contador de números negativos. sumpos.- Suma valores positivos. sumneg.- Suma
valores negativos.
50
Programa: Almacenar 150 números en un vector, almacenarlos en otro vector en orden

inverso al vector original e imprimir el vector resultante.
______________________________________________________________________________________
# include <stdio.h>
void main()
{
int vect1[150], vect2[150], i, x;
for (i=0; i<150; i++)

{
scanf ("%d", &vect1[i]);
}
x = 149;
for (i=0; i<150; i++)
{
vect2[i] = vect1[x];
x = x - 1;
}
for (i=0; i<150; i++)

printf ("Vector 1: %d\n", vect1[i]);
for (i=0; i<150; i++)

printf ("Vector 2: %d\n", vect2[i]);
getch();
}
______________________________________________________________________________________
Programa: Se tienen almacenados en la memoria1 2 vectores M y N de 100 elementos cada

uno. Hacer un algoritmo que escriba la palabra “iguales” si ambos vectores son iguales y
“Diferentes” si no lo son.
______________________________________________________________________________________
# include <stdio.h>
void main()
{
int m[100], n[100], i, r=1;
for (i=0; i<100 && r==1; i++) 2

if (m[i] == n[i])
r = 1;
else
r = 0;
51
if (r) 3
printf ("Vectores iguales");
else
printf ("Vectores diferentes");
getch();
}
______________________________________________________________________________________
Observaciones:
1 El problema nos dice que se tienen ya previamente almacenado en memoria dos

vectores de 100 elementos, así pues damos por hecho que ya existen.
2 El ciclo for se ejecutará mientras i sea menor a 100 y (&&) ‘r ‘ sea igual con 1. así ‘r ’ será
igual a 1 mientras los elementos de ambos vectores sean iguales, de caso contrario ‘ r ‘ será igual
con 0 y se sale del ciclo for.
3 Aquí tenemos una expresión - if (r) - que dice “si r tiene un valor de 1 ... entonces” de lo
contrario si ‘r ‘ vale 0 entonces se ejecuta el else
Programa: Se tiene el vector A con 100 elementos almacenados. Diseñe un algoritmo que
escriba “Si” si el vector esta ordenado ascendentemente o “No” si el vector no esta ordenado.
______________________________________________________________________________________
# include <stdio.h>
void main()
{
int a[100], i, r = 1;
for (i=0; i<100 && r==1; i++)

if (i > 0)
if (a[i] > a[i-1])
r = 1;
else
r = 0;
if (r)
printf ("Si");
else
printf ("No");
getch();
}
______________________________________________________________________________________
52
Programa: Diseñe un algoritmo que lea un número cualquiera y lo busque en el vector X, el

cual tiene almacenados 80 elementos. Escribir la posición donde se encuentra almacenado el
número en el vector o el mensaje “No” si no lo encuentra. Búsqueda secuencial.
______________________________________________________________________________________
# include <stdio.h>
void main()
{
int vecx[80], i, r = 0, pos, num;
printf ("Dame un numero:");

scanf ("%d", &num);
for (i=0; i<80 && r==0; i++)

if (num == vecx[i])
{
pos = i;
r = 1;
}
else
r = 0;
if (r)
printf ("Posicion donde se encuentra %d:", pos);
else
printf ("NO encontrado");
getch();
}
______________________________________________________________________________________
Programa: Almacena en un vector llamado FIB los primeros 100 números de la serie
FIBONACI: 0, 1, 1, 2, 3, 5, 8, 13, ...
______________________________________________________________________________________
# include <stdio.h>
void main()
{
int i;
long fib[100], a=0, b=1, c;
fib[0] = a;
fib[1] = b;
53
for (i=2; i<100; i++)

{
c = a + b;
fib[i] = c;
a = b;
b = c;
}
printf ("Impresión de la serie fibonaci: \n");

for (i=0; i<100; i++)
printf ("%d, ", fib[i]);
getch();
}
______________________________________________________________________________________
Observación (solo para el programador). El programa funciona bien, hasta los primeros 24
números, siendo el ultimo valor correcto 28,657 después arroja incorrectamente valores
negativos, como si la capacidad numérica fuera insuficiente (a pesar de que el vector fib[100] y
sus variables: a, b, c fueron declarados como enteros de capacidad superior a 32,767 con long).
Nota: Asunto pendiente para investigar.
54
MATRICES
Matriz Cuadrada
Aquella que tiene el mismo número de renglones y columnas: 3x3, 4x4, 2x2
Representación en memoria
La Matriz en Memoria: Toma la

forma de un vector, es decir en
posiciones contiguas de memoria.
Declaración de una Matriz
Tipo nom_matriz[n][m]
donde:
n No. de Renglones (Constante)
m No. de Columnas (Constante)
Ejemplos de declaración de Matrices.
Vea las palabras en negrillas, este es el tipo de Matriz que se declara, es decir, si
almacenará numeros enteros - int -, letras - char - , o numeros reales - float -
int calificacion [30][5]; 1

char sexo[20][5]2 , nombre[10][31]; 3
float cosecha[12][3]; 4
Posibles usos:
1 Esta matriz nos puede servir para guardar calificaciones de 30 alumnos cada uno con 5 materias
2 Podemos almacenar el sexo (M ó F) de 20 personas en 5 deptos. diferentes.
3 Para almacenar 10 nombres de 30 caracteres cada uno.
4 Para almacenar las cosechas de los 12 meses del año en 3 años diferentes
En una Matriz siempre se expresa primero el numero de renglones, y en segundo termino

el numero de Columnas. Nunca al revés: Matriz [R][C]
55
PROGRAMAS CON MATRICES
Programa: Genera una Matriz Unidad de 5x5. La Matriz Unidad es aquella que su diagonal
principal esta compuesta por 1’s y por arriba y debajo de ella 0’s.
______________________________________________________________________________________
# include <stdio.h>
# define R 5
# define C 5
void main()
{
int a[R][C], i, j; 1
for (i=0; i<R; i++)

for (j=0; j<C; j++)
if (i == j) 2
a[i][j] = 1;
else
a[i][j] = 0;
printf ("Matriz generada: \n");
for (i=0; i<R; i++) /* Ciclo for para imprimir la matriz */

{
for (j=0; j<C; j++)
printf ("%d", a[i][j]);
printf ("\n");
}
getch();
}
______________________________________________________________________________________
1 Para las Matrices la variable ‘i ‘ será la que controle la posición en los renglones y la
variable ‘j ‘ será la que controle la posición en las columnas.
56
2 Para este problema cuando i es igual a j, es decir, el número de renglón es el mismo al
número de columna, entonces estamos en la Diagonal principal ponemos 1’s en caso contrario -
else- ponemos 0’s.
Programa: Crear una matriz cuadrada de 4x4, En la diagonal principal unos, en la parte
superior ceros, y en la inferior llenar con 2’s
______________________________________________________________________________________
# include <stdio.h>
# define R 4
# define C 4
void main()
{
int mat[R][C], i, j;
for (i=0; i<R; i++)

for (j=0; j<C; j++)
{
if (i == j)
mat[i][j] = 1;
else
{
if (i > j) 1
mat[i][j] = 2;
if (j > i) 2
mat[i][j] = 0;
}
}
for (i=0; i<R; i++) /* Se imprime la Matriz generada */

{
for (j=0; j<C; j++)
printf ("%d", mat[i][j]);
printf ("\n");
}
getch();
}
______________________________________________________________________________________
1Si i es mayor que j entonces estamos en la parte inferior de la diagonal principal y

llenamos con 2’s
57
2 Si j es mayor que i entonces estamos en la parte superior de la diagonal principal y
llenamos con 0’s
Programa: Que permite capturar una matriz de 9x5, obtiene el promedio de los números
capturados, el número mayor, y el menor.
______________________________________________________________________________________
# include <stdio.h>
# define R 9
# define C 5
void main()
{
int matriz[R][C], i, j, mayor, menor;
long int suma=0;
float prom;
for (i=0; i<R; i++)

for (j=0; j<C; j++)
{
printf ("Introduzca valor para matriz en posicion:%d, %d,", i+1, j+1);
scanf ("%d", &matriz[i][j]);
suma = suma + matriz[i][j];
if (i==0 && j==0) 1

{
mayor = matriz[i][j];
menor = matriz[i][j];
}
else 2
{
if (matriz[i][j] > mayor)
mayor = matriz[i][j];
if (matriz[i][j] < menor)

menor = matriz[i][j];
}
}
printf ("la suma es: %d\n", suma);
prom=suma/45;
printf ("el promedio es: %f\n", prom);

printf ("el numero mayor es: %d\n", mayor);
printf ("El numero menor es: %d\n", menor);
getch();
}
______________________________________________________________________________________
58
1 Cuando i=0 y j=0 quiere decir que estamos en el primer renglón y en la primer columna.
Recordar que para C la primera posición es 0 y no 1. Así pues estamos en el primer cuadro de la
matriz. Por eso, las variables “mayor” y “menor” se cargan con ese primer valor que fue
capturado.
2 Después de que las variables “mayor” y “menor” tomaron el primer valor capturado, se
establecen comparaciones con los nuevos valores capturados para cambiar los valores de estas
variables cuando los nuevos valores capturados sean mas grande a lo que tiene “mayor” o mas
pequeño a lo que tienen “menor”
Programa: Se debe llenar una matriz de 7x7 calcular la suma de cada renglón y almacenarla
en un vector, la suma de cada columna y almacenarla en otro vector.
______________________________________________________________________________________
# include <stdio.h>
# define R 7
# define C 7
void main()
{
int mat[R][C], vect1[7], vect2[7], i, j, suma;
for (i=0; i<R; i++)

for (j=0; j<C; j++)
{
printf ("Dame valor para la posicion %d,%d: ", i+1, j+1);
scanf ("%d", &mat[i][j]);
}
for (i=0; i<R; i++) /*La suma de cada renglon se guarda en el vector 1 */
{
suma=0;
for (j=0; j<C; j++)
suma=suma + mat[i][j];
vect1[i]=suma;
}
for (j=0; j<C; j++) /* La suma de cada columna se guarda en vector 2 */

{
suma=0;
for (i=0; i<R; i++)

suma=suma + mat[i][j];
vect2[j]=suma;
}
59
printf ("Valores del vector 1 con la suma de cada renglon:\n");
for (i=0; i<5; i++)
printf ("%d \n", vect1[i]);
printf ("Valores del vector 2 con la suma de cada columna:\n");

for (i=0; i<5; i++)
printf ("%d \n", vect2[i]);
getch();
}
______________________________________________________________________________________
Programa: Se debe llenar una matriz de 20x20. Sumar las columnas e imprimir que columna
obtuvo la máxima suma y la suma de esa columna.
______________________________________________________________________________________
# include <stdio.h>
# define R 20
# define C 20
void main()
{
int matriz[R][C], i, j, suma, colmayor, sumayor;
for (i=0; i<R; i++)
for (j=0; j<C; j++)
{
printf ("Dame valor para posicion %d,%d: ", i+1, j+1);
}
for (j=0; j<C; j++)
{
suma=0;
for (i=0; i<R; i++)

suma=suma + matriz[i][j];
if (j == 0)
{
sumayor=suma;
colmayor=j+1;
}
else
if (suma > sumayor)
{
sumayor=suma;
colmayor=j+1;
}
}
printf ("La %d Columna tiene la maxima suma, con: %d ", colmayor, sumayor);
getch();
}
______________________________________________________________________________________
60
Programa: Se debe llenar una matriz de 5x5 y que almacena la diagonal principal en un
vector. Imprimir el vector resultante.
______________________________________________________________________________________
# include <stdio.h>
# define R 5
# define C 5
void main()
{
int mat[R][C], i, j, vec[5];
for (i=0; i<R; i++)

for (j=0; j<C; j++)
{
printf ("Dame valor para la posicion: %d,%d", i+1, j+1);
if (i == j)
vec[i]=mat[i][j];

for (i=0; i<5; i++)
printf ("%d\n",vec[i]);
getch();
}
______________________________________________________________________________________
Programa: Que permita capturar una matriz de 6x8 y que almacene toda la matriz en un
vector. Imprimir vector resultante.
______________________________________________________________________________________
# include <stdio.h>
# define R 6
# define C 8
void main()
{
int mat[R][C], i, j, vec[48], x=0;
for (i=0; i<R; i++)

for (j=0; j<C; j++)
{
printf ("Dame valor para posicion %d,%d: ", i+1, j+1);
61
vec[x] = mat[i][j];
x = x + 1;
}
for (i=0; i<48; i++)

printf ("%d\n",vec[i]);
getch();
}
______________________________________________________________________________________
Programa: Que llene una matriz de 5x4, y se almacenara la suma de los renglones y la suma
de las columnas en un vector, que se imprime el vector resultante.
______________________________________________________________________________________
# include <stdio.h>
# define R 5
# define C 4
void main()
{
int mat[R][C], i, j, vec[9], x=0, suma;
for (i=0; i<R; i++) /* Captura de la matriz */

for (j=0; j<C; j++)
{
printf ("Dame cantidad para posicion %d,%d:",i+1,j+1);
}
for (i=0; i<R; i++) /* Se suma cada renglon y las sumas se guardan en vec*/
{
suma=0;
for (j=0; j<C; j++)

suma=suma+mat[i][j];
vec[x]=suma;
x=x+1;
}
for (j=0; j<C; j++) /*Se suma cada columna y se agrega cada suma al vector */
{
suma=0;
for (i=0; i<R; i++)
62
suma=suma+mat[i][j];
vec[x]=suma;
x=x+1;
}
printf ("Vector resultante \n:");
for (i=0; i<9; i++)

printf ("%d\n", vec[i]);
getch();
}
______________________________________________________________________________________
Programa: Que llena una matriz de 5x6, y que imprima cuantos de los números almacenados
son 0, cuantos positivos y cuantos negativos
______________________________________________________________________________________
# include <stdio.h>
# define R 5
# define C 6
void main()
{
int matriz[R][C], i, j, cceros=0, cpos=0, cneg=0;
for (i=0; i<R; i++)

for (j=0; j<C; j++)
{
printf ("Dame cantidad para posicion %d,%d:",i+1,j+1);
if (matriz[i][j] == 0)
cceros = cceros+1;
else
if (matriz[i][j] > 0)
cpos = cpos + 1;
else
cneg = cneg + 1;
}
printf ("Cantidad de ceros: %d, positivos: %d, negativos: %d", cceros, cpos, cneg);
getch();
}
63
______________________________________________________________________________________
Programa: Se debe generar un arreglo almacenando las calificaciones de 6 alumnos
en 5 materias diferentes. Determinar: a) Promedio por alumno, b) Promedio por
materia c) Guardar estos resultados en dos vectores diferente e imprimirlos
______________________________________________________________________________________
# include <stdio.h>
# define R 6
# define C 5
void main()
{
int i, j;
float matriz[R][C], promalum[R], promat[C], suma;
for (i=0; i<R; i++) /*Captura de las calificaciones */

for (j=0; j<C; j++)
{
printf ("Cal. del %d alumno, en la %d materia: ",i+1,j+1);
scanf ("%f", &matriz[i][j]);
}
for (i=0; i<R; i++) /* Calculo del promedio por alumno */
{
suma=0;
for (j=0; j<C; j++)

suma=suma+matriz[i][j];
promalum[i]=suma/C;
}
for (j=0; j<C; j++) /* Calculo del promedio por materia */

{
suma=0;
for (i=0; i<R; i++)

suma=suma+matriz[i][j];
promat[j]=suma/R;
}
printf ("Promedios de los alumnos:\n");

for (i=0; i<R; i++)
printf ("Promedio del %d alumno: %5.2f \n",i+1, promalum[i]);
printf ("Promedios por materias:\n");

for (i=0; i<C; i++)
printf ("Promedio de la %d materia: %5.2f\n",i+1, promat[i]);
getch();
}
______________________________________________________________________________________
64
PROGRAMAS CON CADENAS DE CARACTERES
Programa: Hacer un programa que lea una cadena de caracteres y lo imprima en forma
inversa a como se introdujo.
______________________________________________________________________________________
# include <stdio.h>
# include <string.h>
void main()
{
char cadena[81]; 1
int i;
printf ("Introduce una cadena de caracteres:");

gets (cadena);
for (i=strlen(cadena) -1; i>=0; i--) 2

printf ("%c", cadena[i]); 3
getch();
}
______________________________________________________________________________________
1 En esta línea tenemos la declaración del arreglo que guardara la cadena de caracteres - char -
donde se dispondrá de un total de 80 posiciones. Recordar que el la última posición de la cadena
la utiliza C para un caracter nulo.
2La variable ‘i ‘ toma un valor inicial igual a la longitud de la cadena de caracteres (cada espacio
en blanco cuenta como un caracter). Se le resta 1 para que no se incluya al caracter nulo.
Por ejemplo para una cadena de caracteres que tenga 18 caracteres, la variable ‘i ’ toma
ese valor inicial de 18.
3 A partir de esa posición ultima de la cadena, se empieza a imprimir la cadena, y por cada
caracter impreso ‘i ‘ disminuye en 1. ( i--).
Programa: Hacer un programa que lea una cadena de caracteres que este integrada por puras
letras e imprima la frecuencia con la cual aparece cada letra
______________________________________________________________________________________
# include <stdio.h>
# include <ctype.h>
65
void main()
{
char cadena[81];
int frecuencia[26], i;
printf ("Introduce cadena de caracteres (letras) :");

gets (cadena);
for (i=0; i<26; i++) /* Inicializacion vector de frecuen*/

frecuencia[i]=0;
for (i=0; cadena[i]; i++) 1 /*Determinacion de la frecuencia */

if (!isspace(cadena[i])) 2
++frecuencia [toupper(cadena[i]) - 65]; 3
for (i=0; i<26; i++) /*Imprime la frecuencia de las letras */

if (frecuencia[i]!=0)
printf ("%c = %d \n", i+65, frecuencia[i]); 4
getch();
}
______________________________________________________________________________________
1 Vea en el ciclo for, i se iniciala con 1, como se hace generalmente. La segunda expresión del
ciclo for es precisamente una “expresión”: cadena[i]; Significa que se va a ejecutar el ciclo mientras
no se llegue al caracter nulo - \0 -.
Se pudo haber expresado de esta manera cadena for (i=0; cadena[i] != \0; i++)
2 La sentencia if tiene una expresión que dice “Si NO es espacio en la posición actual de la cadena
- if (!isspace(cadena[i])) - De No ser espacio entonces se entra al if.
3 Para empezar a analizar esta sentencia: ++frecuencia[toupper(cadena[i]) - 65]; Observar que

previamente se inicializo el vector “frecuencia” con 26 posiciones, en todo el vector se almaceno
0’s. ++frecuencia nos dice que una determinada posición de este vector, se incrementará el
valor almacenado en 1. ( y solo existen 26 posiciones). toupper(cadena[i]) La palabra “toupper”
convierte la letra a mayúscula, la que se encuentre en ese momento en la posición actual -
cadena[i] - . Dado que toda letra será convertida a mayúscula, y estas dentro del código ASCII
tienen un valor desde el 65 al 90 es necesario restar 65 para se de un incremento en 1 en la
posicion que resulte para el vector frecuencia[26]. Porque éste vector solo tiene 26 posiciones.
Por ejemplo: si cadena[i] = ‘e ’ La ‘e ‘ tiene un valor en ASCII de 101, pero ...
toupper cadena[i] Convierte la ‘e ‘ en ‘ E ’ que tiene una valor en ASCII de 69 y ha este valor
se le restan 65, tal que 69 - 65 = 4
++frecuencia significa que el valor actual de la posición 4 del vector frecuencia se incrementa en 1.
Y esta posición 4 del vector frecuencia incrementará su valor en 1 cada que se encuentre en
cadena[i] una ’ e ’ ó ‘ E ‘.
66
Ilustración a la explicaciones anteriores:
Vector “frecuencia”
0 0
1 0
2 0
3 0
4 1 La posición 4 del vector frecuencia se ha incrementado en 1
5 0 (++frecuencia) Representando a la primera ‘E’ encontrada.
. 0 Así pues cada casilla representa a una letra, y solo hay
. 0 incremento en 1 sí se encuentra su respectiva letra.
. 0
25 0
4 La línea printf ("%c = %d \n", i+65, frecuencia[i]); Nos dice que se imprime el valor actual de ‘i ’
incrementándosele previamente 65, lo que resulte se imprime pero en %c, es decir, el valor
numérico se convierte en letra. También se imprime el valor almacenado en la posición
frecuencia[i] que representa la cantidad de veces que fue encontrada la letra. Por ejemplo:
Tomando la ilustración anterior, se imprimiría: E 1
CONCEPTOS UTILIZADOS EN EL MANEJO DE CADENA DE CARACTERES
Nos permite usar funciones como strlen que nos permite saber cuantos caracteres tiene
una cadena
i = strlen(var_de_caracteres)
La variable i que es de tipo numerico recibe como valor el total de caracteres de una
variable de caracteres. Esta cantidad numerica incluye al caracter nulo. Por lo que hay que restar
1 para obtener el valor neto de la cadena.
# include <ctype.h>
Incluye funciones de conversion para cadena de caracteres.
if (!isspace(cad_caract[i]))
!isspace significa “Si no es espacio”. De tal forma que si en la posición actual de la cadena
de caracteres no es espacio, entonces la sentencia if toma un valor de 1 o verdadero y se entra al
mismo.
toupper (cad_caract[i])
El caracter que se encuentre en la posicion actual de la cadena de caracteres se convierte a
mayuscula.
67
PUNTEROS
El correcto entendimiento y uso de los punteros es critico para una fructífera

programación en C y C++. La razón es triple:
1. Primero, los punteros proporcionan los medios con los cuales las funciones pueden
modificar sus argumentos de llamada.
2. Segundo, se utilizan como soporte de las rutinas de asignación dinámica de C.
3. Tercero, el uso de punteros puede mejorar la eficiencia de ciertas rutinas.
Los punteros son una de las características mas poderosas de C, aunque también una de
las más peligrosas, por ejemplo, los punteros no inicializados pueden provocar el fallo del
sistema, quizás pero, es fácil utilizar punteros de forma incorrecta, y el uso incorrecto puede
causar fallos muy difíciles de encontrar.
¿QUE SON LOS PUNTEROS?
Un puntero es una variable que contiene una dirección de memoria. Esa dirección es la
posición de otro objeto. (Normalmente otra variable) en memoria. Por ejemplo, si una variable
contiene la dirección de otra variable entonces se dice que la primera variable apunta a la
segunda.
@148
@150
@152 20 La Variable.- Tiene una Dirección (@152) Asignada por la
@154 PC, y un contenido (20) asignado por el usuario.
.
.
.
@160 @152 El puntero.- Tiene una Dirección propia (@160) y un
contenido el cual es una dirección de una variable (@152)
que se va a buscar.
Advertencia: No es lo mismo que el puntero almacene la dirección de memoria de una variable,

a que almacene por error su contenido. En el ejemplo anterior, si por error el puntero almacena
20 lo que hace es apuntar a una dirección desconocida @20 !! error !!
Entonces el contenido del puntero es siempre una dirección @xxx. Sea que se le asigne
voluntaria o involuntariamente.
68
VARIABLES Y PUNTEROS
Si una variable va a contener un puntero, entonces tiene que declararse como tal. Una
declaración de puntero consiste en un tipo base y un nombre de variable. La forma general de
declaración de una variable puntero es:
tipo *nombre;
donde tipo es el tipo base de puntero y puede ser cualquier tipo valido de C ( int, char,
float, etc.). El nombre de la variable puntero se especifica con nombre. Ejemplo.
int edad, *p;

char sexo, *q;
*p El puntero “ *p “ tiene la capacidad de apuntar a variables de 2 bytes o menos

bytes, porque es de tipo int.
*q Este puntero tiene la capacidad de apuntar solo a variables de 1 byte, porque es de
tipo char.
Por ejemplo, el puntero *p (capacidad 2 bytes) puede apuntar a la variable sexo (de 1
byte), pero *q (capacidad 1 byte) no puede apuntar a la variable edad (2 bytes).
OPERADORES CON DIRECCIONES
1) & Dirección
2) * Contenido
Ejemplo:
______________________________________________________________________________________
int num=201 , *p2 ;
p = &num;3
*p = 40; 4
printf (¨” %d \n”, *p); 5

printf (“%d \n”, num);6
printf (“%p \n”, p); 7

printf (“%p \n”, &p); 8
______________________________________________________________________________________
69
@150
@152
@154 20 1 Se crea la variable ‘num’ , la PC le asigna la dirección
@156
@154 y el usuario le asigna a ‘num’ un contenido de 20
@158
@160
@162
@164 @154
2 Se crea el puntero *p el cual no tiene en ese momento
relación alguna con la variable ‘num’.
@166 3 En la segunda línea del programa p=&num; En ese
@168 momento se relaciona el puntero con la variable. el puntero toma
como contenido la dirección de ‘num’ (@154).
El & permite dar como contenido al puntero la dirección
de la variable, y no el contenido de esta, es decir, p=num,
entonces p=20. error!! (@20 Dirección desconocida !!)
4 *p = 40; En la dirección a la que apunta el puntero ‘p’ se asigna el valor de 40, es decir,
‘num’ ya no vale 20, sino 40.
5 printf (¨” %d \n”, *p); Esta línea visualiza el contenido de la dirección a la que apunta
‘p’, es decir, visualiza el valor de ‘num’ que es 40.
6 printf (“%d \n”, num); Esta línea visualiza el contenido de la variable ‘num’ que es 40.
7 printf (“%p \n”, p); Esta línea imprime el contenido del puntero ‘p ’ que es la dirección
de la variable ‘num’; @154
8 printf (“%p \n”, &p); Esta línea imprime la dirección del puntero ‘p ‘ que es @164
PROGRAMAS CON ACCESO A UN ARREGLO USANDO UN PUNTERO
Programa: Que permite capturar un vector con 10 elementos y usando un puntero visualiza
los elementos en forma inversa a como fueron capturados.
______________________________________________________________________________________
# include <stdio.h>
void main()
{
int num[10], i, *p;
for (i=0; i<10; i++)

{
printf ("Introduce el %d numero:", i+1);
scanf ("%d", &num[i]);
}
70
p=&num[9]; 1
for (i=0; i<10; i++)

{
printf ("%d \n", *p); 2
--p;
}
getch();
}
______________________________________________________________________________________
Supongamos que nuestro vector ‘num’ fue llenado con las siguientes cantidades, y con una
dirección inicial supuesta.
Direccion Elems. Posicion

@150 8 0
@152 10 1
@154 60 2
@156 5 3
@158 45 4
Vector ‘num’
@160 18 5
@162 35 6
@164 20 7
@166 90 8
@168 2 9
.
.
.
@184 @168 Puntero ‘p ‘ con direccion
supuesta @184
1 p = &num[9]; Esta línea asigna al puntero la dirección de memoria de la posición 9 del vector.
2printf ("%d \n", *p); Imprime el contenido de la dirección a la que primeramente apunta el
puntero (@168). Imprime 2.
3- -p; El puntero tiene un decremento en su contenido (@168 - decremento). Este decremento no

es en 1 sino en 2 porque el puntero ‘p’ es de tipo int (2 bytes). Entonces en su primer decremento
p vale @166.
Regla sobre punteros: La aritmética de los punteros esta en función de su tamaño.

o sea:
- -puntero Afecta al contenido del puntero, el contenido de un puntero siempre es
una dirección de alguna variable. El decremento será en 1 si el puntero es de tipo char, será en 2 si
el puntero es de tipo int.
71
Programa: Hacer un programa que reciba una cadena de caracteres, y determine si es un

“palíndromo”, es decir, si se lee igual al revés y al derecho como ‘oso’, ‘ala’, etc.
______________________________________________________________________________________
# include <stdio.h>
# define MAX 81
void main()
{
char cadena[MAX], *apun; 1
int band=1, i;
printf ("Introduce cadena de caracteres:");

gets (cadena);
apun = &cadena[strlen(cadena)-1]; 2
for (i=0; i<=strlen(cadena)/2 && band; i++)

if (cadena[i] != *apun)
band = 0;
else
--apun; 3
if (band)
printf ("Es un PALINDROMO");
else
printf ("NO es PALINDROMO");
getch();
}
______________________________________________________________________________________
1 Si un determinado puntero va ser usado para manejar una cadena de caracteres - char -
entonces el puntero debe ser declarado del mismo tipo - char - como en este programa. De lo
contrario no da resultado.
2 apun = &cadena[strlen(cadena)-1]; Vea que el puntero ‘apun’ va a tomar como
contenido la dirección de una posición de la variable cadena. Esa posición será dada por el total
de caracteres realmente capturados, incluyendo espacios en blanco - strlen - y se resta 1 para no
considerar el caracter nulo. Así pues, ‘apun’ tendrá la dirección del ultimo caracter introducido.
3 --apun; La dirección que tiene como contenido ‘apun’ disminuye en 1, es decir, la
primera vez que ‘apun’ tenga un decremento apuntará al penúltimo caracter.
NOTA: Cuando queramos apuntar a la dirección de inicio de un arreglo usaremos:

puntero = &vector[0] ó puntero = vector (siempre que estemos hablando de un vector).
72
Programa: (Como ejemplo de lo último explicado).

______________________________________________________________________________________
# include <stdio.h>
void main()
{
char cadena[81], *p;
printf ("Introduce cadena:");

gets (cadena);
/* Primera opcion */
p = &cadena[0];
printf (" Direccion contenido del puntero: %p\n", p);

printf ("Contenido de la direccion a la que se apunta: %c\n",*p);
/* Segunda opcion */
p = cadena;
printf ("- B - Direccion contenido del puntero: %p\n", p);

printf ("Contenido de la direccion a la que se apunta: %c\n",*p);
getch();
}
______________________________________________________________________________________
Si por ejemplo se introduce “ala” tanto en la primera como segunda opción arroja los
mismos resultados: se imprime primeramente una dirección (la que tiene como contenido el
puntero) y luego se imprime la letra ‘a’ (el contenido de la dirección hacia la que apunta el
puntero).
Ilustracion:
Direccion Elems. Posicion

En este supuesto como contenido del puntero - (“%p\n", p); - se
imprime @150
@150 a 0 Como contenido de la dirección hacia la que apunta el puntero
@152 l 1 - (“%c\n", *p) - se imprime la letra ‘a’.
@154 a 2
. .
. .
73
FUNCIONES
Las funciones son los bloques constructores de C y el lugar donde se produce toda la
actividad del programa. Son unas de las características más importantes de C.
formato general:
tipo nom_funcion (lista de parámetros)

{
.
.
cuerpo de la función
.
}
El tipo.- Especifica el tipo de valor que devuelve la función. Una función puede devolver
cualquier tipo de dato excepto un arreglo. Si no se especifica ningún tipo, el compilador asume
que la función devuelve como resultado un entero.
La lista de parámetros.- Es la lista de nombres de variables separados por comas con sus
tipos asociados que reciben los valores de los argumentos cuando se llama a la función. Una
función puede no tener parámetros, en cuyo caso la lista de parámetros esta vacía. Sin embargo,
incluso cuando no hay parámetros se requieren los paréntesis.
Ejemplo:
______________________________________________________________________________________
int1 suma2 (int x, int y)3

{
int z; 4
z = x + y;
return z; 5
}
void main()
{
printf (“%d \n”, suma(10, 20)); 6
getch();
}
______________________________________________________________________________________
1 El tipo de dato que devuelve la función es entero - int -.

2 Nombre de la función ”suma” su lista de parámetros: x, y
3 Observe que cada parámetro tiene su tipo de dato asociado. Es decir, no puede hacerse esto:
(int x, y) sino (int x, int y)

4 La variable ‘z’ es una variable local porque solo la reconoce la función ‘suma’
5 return z; Esta línea retorna el valor de ‘z’, es decir, se transporta su valor a main()
6 Dentro del main() la línea suma( ); hace un llamado a la función ‘suma’ para que ésta se ejecute.
74
Ejemplo de función sin parametros

______________________________________________________________________________________
int suma (void)
{
int x, y, z;
printf (”valor de x:”);

scanf (”%d”, &x);
printf (“Valor de y:”);

scanf (“%d”, &y);
z = x + y;
return z;
}
______________________________________________________________________________________
Ejemplo de función que no devuelve ningún valor (void)
______________________________________________________________________________________
void suma (void)
{
int x, y, z;
printf (“valor de x:”);

scanf (“%d”, &x);
printf (“Valor de y:”);

scanf (“%d”, &y);
z = x + y;
printf (“%d + %d = %d \n”, x, y, z);

getch();
}
______________________________________________________________________________________
La función anterior cuando deje de ejecutarse, las variables x, y, z ya no existirán, la
función no devuelve ningún valor; No hay una sentencia return.
Si no devuelve un valor - void - aunque para C es una función más bien es solo un
“Procedimiento”.
En las declaraciones de variables se pueden declarar múltiples variables del mismo tipo
mediante una lista con los nombres de las variables separados por comas, en cambio, en las
funciones todos los parámetros deben declararse individualmente incluyendo para cada uno
tanto el tipo como el nombre, es decir, la lista de declaración de parámetros de una función tiene
la siguiente forma general:
funcion (tipo var1, tipo var2, ... tipo varN)
75
Observe 2 formas diferentes de Hacer el llamado de una función dentro de main()
1)
______________________________________________________________________________________
# include <stdio.h>
void main()
{
printf ("%d \n", suma(10, 20));
getch();
}
int suma (int x, int y)

{
int z;
z = x + y;
return z;
}
______________________________________________________________________________________
2)
______________________________________________________________________________________
# include <stdio.h>
void main()
{
int a;
a = suma(10,20);
printf ("%d \n", a);
getch();
}
int suma (int x, int y)

{
int z;
z = x + y;
return z;
}
______________________________________________________________________________________
Definición de Función
La función hace algo y puede devolver un valor.
También son funciones:
strlen() Que devuelve la longitud de la cadena de caracteres

isspace() Determina si en determinada posición de una cadena es un espacio en blanco.
pow() Eleva al cuadrado
sqrt() Raíz cuadrada
etc., etc., ...
76
ÍNDICE
CONCEPTO BÁSICOS DEL LENGUAJE C ...................................................................... 1
TIPOS DE DATOS EN C ...................................................................................................... 3
NOMBRE DE IDENTIFICADORES .................................................................................... 4
DIFERENTES TIPOS DE VARIABLES ............................................................................... 5

Variables Locales .................................................................................................................. 5
Parametros Formales ............................................................................................................ 5
Parametros Actuales ............................................................................................................. 6
Variables Globales ................................................................................................................ 6
OPERADORES ARITMETICOS .......................................................................................... 7

Prioridad de los operadores en general .............................................................................. 8
Función de c para la potencia ............................................................................................ 8
Función de c para la raiz ...................................................................................................... 8
Diferentes formulas expresadas para programacion ........................................................ 9
OPERADORES LOGICOS ................................................................................................... 10

Tabla de Verdad de los operadores logicos ........................................................................ 10
OPERADORES RELACIONALES ...................................................................................... 10

OPERADORES ESPECIALES .............................................................................................. 12
Modo prefijo .......................................................................................................................... 12
Modo posfijo ......................................................................................................................... 12
FUNCIONES BASICAS ....................................................................................................... 12

Funcion scanf ........................................................................................................................ 12
Funcion gets ( ) ..................................................................................................................... 14
Función printf ( ) ................................................................................................................... 14
SENTENCIAS SELECTIVAS ............................................................................................... 18

Funcion if ( ) .......................................................................................................................... 18
¿Que entendemos por “expresión” ? .................................................................................. 18
Analisis de la sintaxis de la funcion if ( ) ............................................................................ 19
Sentencia switch( ) ... case .................................................................................................. 22
SENTENCIA DE CONTROL DE CICLOS ......................................................................... 24

Sentencia while ( ) ................................................................................................................. 24
Sentencia do ... while ( ) ................................................................................................ 31
Sentencia for ( ) .............................................................................................................. 33
77
ARREGLOS (ARRAYS) ....................................................................................................... 40

Advertencia: Lenguaje C no da la comprobación de contornos ....................................... 41
Clasificación de los Arreglos ............................................................................................... 42
Declaración de un Arreglo ................................................................................................... 43
Programas con Vectores ....................................................................................................... 45
MATRICES ............................................................................................................................ 53
Declaración de una Matriz ................................................................................................... 53
Programas con Matrices ....................................................................................................... 54
PROGRAMAS CON CADENAS DE CARACTERES ....................................................... 64

Conceptos utilizados en el manejo de cadena de caracteres ............................................. 66
PUNTEROS ........................................................................................................................... 67
¿Que son los Punteros? ........................................................................................................ 67
Variables y Punteros ............................................................................................................ 68
Operadores con direcciones ................................................................................................. 68
Programas con acceso a un Arreglo usando un Puntero .................................................. 69
Regla sobre punteros ............................................................................................................ 70
FUNCIONES ......................................................................................................................... 73
Definición de Función .......................................................................................................... 75
78

Lenguaje C, Manual de Programacion - M.C. Enrique Ruiz Diaz

Hochgeladen von

Dokumentinformationen

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

Lenguaje C, Manual de Programacion - M.C. Enrique Ruiz Diaz

Hochgeladen von

Copyright:

Verfügbare Formate

Autor: M.C.

Enrique Ruiz Díaz Lenguaje de Programación C - (Materia: ‘Programación I’)

Autor: M.C. Enrique Ruiz Díaz

float Area (int radio);

float Area (int radio)

# include <stdio.h> Permite incluir al programa una función de nombre <stdio.h>

# include “stdio.h” Se utilizan las “ “ cuando la libreria (archivos del subdirectorio

float Area (int radio);

float Area (int radio) En esta línea tenemos la “DEFINICIÓN DE LA FUNCIÓN” es

return area; Al terminar de ejecutarse la función “Area” desaparecen todas

ejemplo: Contiene seno()

Tipo Tamaño aproximado en bits Rango minimo

Char 8 -127 a 127

Ejemplo de cantidad de bytes ocupado por diferentes variables (8 bits = 1 byte)

char sexo, nombre[31]; 32 bytes

4. No podrán ser usadas como identificadores las siguientes palabras reservadas:

lista_de_variables: Puede consistir en uno o mas identificadores separados por comas:

DIFERENTES TIPOS DE VARIABLES

PARAMETROS FORMALES: Sirven para transferir información hacia las funciones, en la

esta_en 1 ( char * s, char c ) 2

int esta_en ...

PARAMETROS ACTUALES: 3 Son usados en el llamado de la función, dentro de main( ).

void func1 (void)

6 Se hace un llamado para ejecutar la función “func1”

8 En esta línea se hace un llamado a la función “func2”

¿Que es el Residuo Entero? En algoritmo al residuo entero se le llama “mod ó modulo”

PRIORIDAD DE LOS OPERADORES EN GENERAL

m = y2 - y1 = Expresarlo en forma correcta para programación ...

m = (y2 - y1) / (x2 - x1) Si es correcto

FUNCIÓN DE C PARA LA POTENCIA. pow (base, exponente)

FUNCIÓN DE C PARA LA RAIZ: sqrt ( )

3. A = P(P - A)(P - B)(P - C)

Expresar en forma correcta para programación lo siguiente

x1 = (-b + sqrt (pow(b,2) - 4*a*c)) / (2*a)

x2 = (-b - sqrt (pow(b,2) - 4*a*c)) / (2*a)

3. Expresar para programación:

d = (X2 - X1)2 + (Y2 - Y1)2

d = sqrt ( pow((X2 - X1), 2 ) + pow (( Y2 - Y1), 2))

h = sqrt ( pow(a,2) + pow(b,2) )

d = sqrt ( pow (x,2) + pow (y,2) )

Los operadores logicos se utilizan para establecer condiciones compuestas

TABLA DE VERDAD DE LOS OPERADORES LOGICOS

V F El NOT convierte de verdadero a

OPERADORES RELACIONALES: Establecen condiciones en un programa

El signo igual que = =

En algoritmo ponemos ...

En progración debemos poner ..

if ( c = = b ) “ Si c es igual a b entonces ... “

while ( a = = d ) “ Hacer mientras a sea igual a d “

En algoritmo poniamos ...

Es decir, “si a es diferente de b” entonces se entra al ciclo if

Son monarios porque solo se aplican a un operando.

MODO PREFIJO ++a

MODO POSFIJO a++

printf ( “%d”, a); 2

printf (“%d”, a); 4

1 Inmediatamente se incrementa ‘a’ en 1 (o sea, a = 6)

FUNCION scanf (“ formato “, nombre_ver) ;

Especificamos cualquiera de los “Especificadores de formato” dependiendo de lo que se

scanf (“ % c ”, &sexo); Nos pide que tecleemos (leamos) el sexo de la persona, el

scanf (“ % d “ , &edad); Nos pide que tecleemos la edad de la persona, el “ % d “

scanf (“ % f ”, &estatura); Nos pide que tecleemos la estatura, el “ % f ” significa que

scanf (“ % e ”, &estatura); Nos pide que tecleemos la estatura, el “ % e ” significa que

scanf (“ % i “, &peso); Toma lo que haya en el buffer de memoria ( en este caso la

x1 = (-b + sqrt (pow(b,2) - 4ac)) / (2*a)

x2 = (-b - sqrt (pow(b,2) - 4ac)) / (2*a)

Num2 = (C1000) + (X3100) + (X2*10) + X1;

Nota: La constante ‘b’ de la formula: b=((1.25/1)7) + ((1/1)2) + ((1.8/1)*1)