Guia Lenguaje C

Fundamentos de Programación Profesor: Cristian
Millacariz
GUIA DE LENGUAJE EN C
Millacariz
Índice:
GUIA DE LENGUAJE EN C..................................................................................................................1
Índice: .................................................................................................................................................2
Lenguaje C...............................................................................................................................................3
Introducción: .......................................................................................................................................3
CAPITULO I: “Características del Lenguaje C”................................................................................4
CAPITULO II: “Variables en C”........................................................................................................6
CAPITULO III: “Operadores en C” .................................................................................................8
CAPITULO IV: “Asignaciones y Expresiones en C”.........................................................................9
CAPITULO V: “E/S por consola con Formato”...............................................................................10
CAPITULO VI: “Sentencias de Control”..........................................................................................12
CAPITULO VII: “Iteraciones en C”.................................................................................................14
CAPITULO VIII: “Arreglos en C”....................................................................................................16
CAPITULO IX: “Funciones de caracteres y strings”........................................................................17
CAPITULO X: “Funciones y Procedimientos”.................................................................................18
CAPITULO XI: “E/S en Archivos”...................................................................................................20
APENDICE A....................................................................................................................................22
FUNCIONES DE C...............................................................................................................................22
FUNCION..............................................................................................................................................22
TIPO.......................................................................................................................................................22
PROPOSITO..........................................................................................................................................22
INCLUDE..............................................................................................................................................22
FUNCION..............................................................................................................................................23
TIPO.......................................................................................................................................................23
PROPOSITO..........................................................................................................................................23
INCLUDE..............................................................................................................................................23
APENDICE B: ..................................................................................................................................24
2|Page
Millacariz
Lenguaje C
Introducción:
C es un lenguaje de programación de propósito general que ofrece como ventajas: economía
de expresión, sentencias de control y estructuras de datos modernas junto a un rico conjunto de
operadores.
C es un lenguaje de nivel medio, ya que combina elementos de lenguaje de alto nivel con la
funcionalidad del lenguaje ensamblador. El definir a C como lenguaje de nivel medio, no significa que
sea menos potente, más difícil de usar o menos evolucionado que los lenguajes de alto nivel como
PASCAL, COBOL o FORTRAN; tampoco significa que C sea similar al lenguaje ensamblador
presentando al programador todos los problemas asociados a él.
Una característica importante del lenguaje C, es que posee un código muy portable, siendo posible
adaptar el software escrito para un tipo de computador en otro.
Durante muchos años, el estándar de C fue la versión proporcionada por el Sistema Operativo Unix
(System V), pero con la popularidad de los Microcomputadores aparecieron variadas implementaciones
de C, altamente compatibles unas con otras. Debido a esto, en el año 1983 el American National
Standars Institute (ANSI), estableció un comité para producir una “definición no ambigua del lenguaje C
e independiente de la máquina”, el resultado final se obtuvo en 1990 con la definición del estándar ANSI
de C.
En resumen, podríamos decir que C ha demostrado ser un lenguaje agradable, expresivo, versátil para
una amplia variedad de programas y fácil de aprender.
3|Page
Millacariz
CAPITULO I: “Características del Lenguaje C”
La principal característica de un lenguaje estructurado, es la capacidad de seccionar y esconder del

resto del programa las instrucciones e información para llevar a cabo alguna tarea. Una forma de
lograrlo, es usando subrutinas que empleen variables locales (temporales), de manera que lo que
ocurra en su interior no provoque efectos secundarios en otras partes del programa.
En un lenguaje estructurado, el uso de GOTO puede estar prohibido o desaprobado, no siendo una
forma normal de control, tal como lo es en BASIC o FORTRAN.
En base a lo anterior, C se denomina lenguaje sencillamente estructurado, dado que no permite la

creación de funciones dentro de funciones. Además, soporta varias construcciones de bucles (while, do
while y for) que permiten al programador no usar GOTO.
Programación de Sistemas:
Los programas de sistemas más comunes son: los Sistemas Operativos, Intérpretes, Editores,
Compiladores, Programas de Ensamblado y otros.
C permite la programación de sistemas, ya que permite la manipulación directa de bits, bytes, palabras
y punteros.
Compilador versus Intérprete
Intérprete: Utilitario que toma un programa escrito en un lenguaje de alto nivel, en el cual va leyendo y
ejecutando directamente cada línea del código fuente, sin generar código de máquina. Las ventajas de
los intérpretes es que son fáciles de construir. Su problema es que son lentos y requieren la presencia
del código fuente cada vez que se desee ejecutar el programa.
Compilador: Utilitario que toma un programa escrito en un lenguaje de alto nivel y lo traduce a un
programa en lenguaje de bajo nivel o código de máquina. El proceso de una compilación puede dividirse
en dos etapas. En la primera se chequea correctitud de sintaxis y secuencia de las instrucciones,
generando un archivo de código intermedio u objeto. En la segunda se toma este código objeto y se une
a las rutinas del sistema que se haya indicado, generando el programa en su estado final de código
ejecutable.
C normalmente es compilado, sin embargo, han ganado popularidad los intérpretes de C, como ayudas
en la depuración durante las etapas de desarrollo en un programa.
TIPOS DE DATOS
Un tipo de dato define un conjunto de valores que puede tener una variable junto con un conjunto de
operaciones que se pueden realizar sobre esa variable.
C tiene cinco tipos de datos básicos incorporados, entre ellos están los enteros, los caracteres y los
reales.
Además, C no es un lenguaje fuertemente tipificado como Pascal, ya que permite casi todas las
conversiones entre tipos. Por ejemplo, los tipos entero y carácter pueden ser entremezclados en la
mayoría de las expresiones, siendo de responsabilidad del programador la comprobación de la
incompatibilidad de los tipos.
4|Page
Millacariz
Palabras Claves: Una palabra clave es aquella que tiene un significado especial dentro del lenguaje,
debido a esto, nunca deben ser usadas como nombres de variables o funciones. Las palabras claves de
C están escritas en minúsculas, siendo 32 las definidas por el estándar ANSI de C:
auto double int struct

break else long switch
case enum register typedef
char extern return union
const float short unsigned
continue for signed void (sin valor)
default goto sizeof volatile
do if static while
En C, las mayúsculas son diferentes con las minúsculas, así: else es una palabra clave y ELSE no lo
es.
Forma de un Programa: Los programas en C consisten en una o más funciones. La única función que
siempre debe estar presente es la denominada main(), ya que es la primera en ser llamada cuando
comienza la ejecución del programa.
La forma general de un programa en C es la siguiente:
declaraciones globales
funcion1()
{
variables locales
sentencias
}
.
.
.
funcionn()
{
variables locales
sentencias
}
main()
{
variables locales
sentencias
}
En código C bien escrito, main() debe esbozar lo que el programa hace, utilizando los nombres de las
funciones f1(), f2(), f3(),...fn() definidas por el programador. Técnicamente main() no forma parte del
lenguaje C, pero debe tratarse como si lo fuera. Por esta razón, no debe usarse como nombre para una
variable, ya que se puede confundir al compilador.
Biblioteca y Enlazado: Una biblioteca es una colección de funciones para llevar a cabo diversas
tareas. La biblioteca estándar de C, no forma parte del lenguaje, pero sí es un entorno que proporciona
declaraciones, funciones y macrodefiniciones. C no proporciona dentro de la definición real del lenguaje,
métodos para llevar a cabo las operaciones de entrada/salida, debido a esto, la mayoría de los
programas incluyen llamadas a variadas funciones contenidas en la biblioteca estándar del lenguaje C.
Cuando se llama a una función que no es parte del programa que se ha escrito, C “recuerda” su
nombre. Más tarde, el enlazador combina el código objeto producido al compilar el programa fuente, con
5|Page
Millacariz
el código objeto de la función que se encuentra en la biblioteca estándar. Este proceso se llama
enlazamiento.
Compilación Separada: La mayoría de los programas cortos de C están enteramente contenidos en un

archivo fuente. A medida que aumenta la longitud del programa, también lo hace el tiempo de
compilación, por ello, C permite dividir un programa en varios archivos y compilar cada uno de ellos por
separado. Una vez que todos han sido compilados se enlazan entre sí junto con las rutinas de la
biblioteca para formar el código objeto completo; la ventaja de este método es que el cambio en el
código de uno de los archivos no requiere de la recompilación del programa completo.
CAPITULO II: “Variables en C”

Los números son los datos fundamentales usados en computación, estos se representan internamente
en forma binaria. Dependiendo de la cantidad de bits o bytes, es posible representar diferentes tipos de
números. La forma de almacenar números es mediante el uso de variables, que corresponden a
representaciones lógicas de un grupo de bytes. Formalmente, una variable tiene un tipo y un
identificador. El tipo corresponde a una palabra reservada que indica la cantidad de bytes que se le
asignan a la variable. El identificador es el nombre que se le asocia a la variable.
Tipos: En C existen 5 tipos de datos: carácter, entero, coma flotante, coma flotante de doble precisión y
sin valor.
Tipo Tamaño en bits Rango

Char 8 0 a 255
Int 16 -32768 a 32767
Float 32 -3.4E-38 a 3.4E+38
Double 64 -1.7E-308 a 1.7E+308
Void 0 sin valor
Los valores del tipo char se usan para guardar los valores definidos en el juego de caracteres ASCII;
las variables de tipo int se usan para guardar cantidades enteras; las variables tipo float o double se
usan para guardar números reales; el tipo void se usa para declarar explícitamente que una función no
retorna valor o para declarar una función sin parámetros. C soporta varios tipos agregados, incluyendo
las estructuras, las uniones, las enumeraciones y los tipos definidos por el programador. Los tipos de
datos básicos pueden ser alterados con el uso de modificadores, estos hacen que el tipo base se ajuste
más a las necesidades de cada momento. Los modificadores son: signed, unsigned, short y long,
produciéndose las siguientes combinaciones:
Tipo Tamaño en bits Rango

Char 8 -128 a 127
Unsigned char 8 0 a 255
Signed char 16 -128 a 127
Int 16 -32768 a 32767
Unsigned Int 16 0 a 65535
Signed Int 16 -32768 a 32767
Short Int 16 -32768 a 32767
Long Int 32 -2147783648 a 2147483647
Float 32 -3.4E-38 a 3.4E+38
Double 64 -1.7E-308 a 1.7E+308
Long Double 64 -1.7E-308 a 1.7E+308
6|Page
Millacariz
Identificadores: Corresponden a los nombres usados para referirse a las variables, funciones ,
etiquetas y otros objetos definidos por el programador. La longitud de un identificador puede variar entre
1 y 32 caracteres. Para definirlos, se deben seguir las siguientes reglas:
 Todo identificador debe empezar con una letra entre “a” y “z” o entre “A” y “Z”
 El resto del identificador pueden ser letras o dígitos del 0 al 9 o underscore (_). Otros símbolos
no pueden ser usados.
 Se consideran dígitos significativos sólo a los primeros 32.
 Los identificadores diferencian entre mayúsculas y minúsculas.
Ejemplos:
Correcto Incorrecto
inc 9inc
nota nota?
tot_ven tot..ven
Declaración de Variables: Todas las variables deben ser declaradas antes de usarlas. La sintaxis para
ello es:
 Tipo lista_de_variables
Donde tipo debe ser un tipo válido de C y lista_de_variables puede ser uno o más nombres de
identificadores separados por comas.
Ejemplos: int i,j,k;

 float impuestos, IVA, calculo;
 char opcion, letra;
Inicialización: Es muy importante en el uso de variables el realizar una adecuada inicialización de las
mismas, ya que al crearlas, éstas pueden tomar cualquier valor, lo que puede afectar el correcto
funcionamiento del programa. La forma tradicional de inicialización en los lenguajes de programación
es:
 int contador;
 Contador = 0;
Sin embargo, en C es posible realizar dicha inicialización en el momento de la declaración de la

variable:
 int contador = 0, loop = -1;
 float IVA = 0.18;
Declaración de Constantes: Para definir constantes en C, se debe seguir la siguiente sintaxis:

 #define identificador valor;
Ejemplos:
 #define maxlong 200;
 #define step 20;
Comentarios: Tal como en la mayoría de los lenguajes de programación, en C es posible indicar ciertas
zonas como lugares donde no hay código y que es usado para realizar acotaciones sobre él. La práctica
de comentar el código es muy útil, sobre todo si existe la posibilidad de futuras revisiones a los
programas realizados. En C, las formas de indicar que cierto texto es comentario es encerrándolo
entre /* y */ o comenzando la línea con //.
7|Page
Millacariz
Ejemplos:
a) /* Esta línea es comentario y no afecta la ejecución del programa */
int x=0; /* declaración e inicialización de la variable x */
b) // Este comentario sólo es válido hasta fin de línea
CAPITULO III: “Operadores en C”

Definición: Un operador es un símbolo que le indica al compilador que lleve a cabo ciertas
manipulaciones matemáticas o lógicas. En C, hay 3 clases generales de operadores: aritméticos,
relacionales y lógicos.
Operadores Aritméticos:
Acción Operador
Resta -
Suma +
Multiplicación *
División /
División en módulo %
Decremento --
Incremento ++
Ejemplos:
10/3 =3
10%3 =1
x++ x = x+1
y-- y = y-1
si x = 10
y = ++x x=11; y = 11(incrementa y asigna)
y = x ++ y = 10; x = 11(asigna e incrementa)
Operadores Relacionales:
Acción Operador
Mayor >
Mayor o igual >=
Menor <
Menor o igual <=
igual ==
Distinto !=
8|Page
Millacariz
Operadores Lógicos:
Acción Operador
And &&
Or ||
Not !
Precedencia: Es el orden en que se evalúan las expresiones.
1 ++ --
2 */%
3 + -
4 !
5 > >= < >=
6 = = !=
7 &&
8 ||
Los operadores del mismo nivel de precedencia, son evaluados por el compilador de izquierda a
derecha. Al utilizar paréntesis, se altera el orden de las evaluaciones, ejecutándose primero las
operaciones que se encuentran dentro de ellos.
Ejemplos:
10 > 1 +12 10 > (1+12)
En ambos casos el resultado es falso (0)
10 > 5 && !(10 < 9) || 3 <= 4

Da como resultado Verdadero (1)
CAPITULO IV: “Asignaciones y Expresiones en C”
Asignación: La asignación de valores a las variables definidas y el cómputo de operaciones aritméticas

y/o lógicas, son las instrucciones básicas en C.
variable = expresión ;
Cada cómputo debe realizarse en una línea y al finalizar se debe colocar el carácter “;” lo que indica fin
de la operación.
Ejemplos:
x = 200;
y = x + 7;
balance = (8 * x) + (4 / y);
También es posible realizar operaciones lógicas y/o de comparación, teniendo presente que la variable
de asignación toma valores de verdad. En C, los valores de verdad se representan como números
enteros, cuyo valor es: 0 (FALSE), 1 (TRUE).
Ejemplos:
9|Page
Millacariz
es_mayor = (x > y);
(Si x=5 e y=2 entonces es_mayor toma el valor 1
pare = (i == 2) && (!ultimo)

(notar que en esta expresión, la variable pare toma un valor de verdad,
dependiendo de la evaluación de la expresión).
Abreviaturas: C permite abreviaturas que simplifican la escritura de ciertos tipos de sentencias de

asignación. La sintaxis es:
Expresión operador = expresión;

Ejemplos:
x = x +10; x + = 10;
x = x – 2; x - = 2;
x = x * (y + 1); x * = y + 1;
En programas profesionales de C, la notación abreviada es muy usada, así que conviene familiarizarse
con ella.
Operador Coma: Produce una secuencia de operaciones, la parte izquierda del operador siempre se
evalúa como void, y el valor asignado, es el valor de la última expresión de la lista separada por comas.
La sintaxis es:
Variable = (lista_de_expresiones);
Ejemplos:
y = 10;
x = (y = y – 5, 25/y);
Después de la ejecución x toma el valor 5.
CAPITULO V: “E/S por consola con Formato”

Biblioteca Estándar: Las funciones de E/S por consola, se encuentran declaradas en el header
<stdio.h> de la biblioteca estándar de C. Los header deben ser declarados antes de usar las funciones
contenidas en él, la sintaxis para ello es:
#include <header>
printf() : Es una función que permite enviar a la pantalla (output estándar), caracteres con algún
formato. Una orden de formato comienza con un signo de porcentaje y va seguido por el código del
formato. Algunas órdenes de formato son:
Codigo Operación
%c carácter único
%d decimal (entero)
%ld decimal (entero largo)
%f decimal (punto flotante)
%s cadena de caracteres
%x dirección de memoria
10 | P a g e
Millacariz
Sintaxis: printf(“formato”, lista_variables);
Ejemplos:
Printf(“Hola %c %d %s”, ‘c’,10 , “qué tal!”);
Imprime en pantalla Hola c 10 qué tal!
Printf(“%6.2f”, 228.3415);
Imprime 228.34
printf(“%10s”, “hola”);
Imprime 6 blancos y hola
printf(“%-10s”, “hola”);
Imprime hola y 6 blancos
En ambos casos se imprime el string hola, con la diferencia que el signo “-“ hace que se ajuste de
izquierda a derecha.
Printf(“%5.7s”, “1234567890”);
Imprime 1234567
(Imprime el string 1234567, bajo el concepto de al menos 5 caracteres con un máximo de 7).
Barra Invertida: Algunos códigos de barra invertida son:
Código Operación
\b Espacio atrás
\f Salto pagina
\n Salto línea
\t Tabulación horizontal
\v Tabulación vertical
\r Retorno de Carro
scanf() : Es una función que permite leer la entrada de caracteres desde el teclado (input estándar),
siguiendo algún formato. Los códigos de los formatos son similares al de la función printf().
Ejemplos:
scanf(“%d”,&numero);
(Lee el entero ingresado asignándolo a la variable numero)
scanf(“Sr. %s %s”, nombre, apellido);

(Descarta la entrada Sr. y asigna los caracteres correspondientes a las variables nombre y
apellido).
scanf(“%[A-Z]”,s1);
(Acepta sólo caracteres entre “A” y la “Z”, y se lo asigna a la variable s1).
11 | P a g e
Millacariz
CAPITULO VI: “Sentencias de Control”

Sentencia: Es una asignación o expresión, pero, terminadas con un “;”
Ejemplos: x = 1;
y = (y-3,4*4);
--j;
Bloque: Es un grupo de sentencias que se encuentran entre “{“ y “}”.
Ejemplos: {
int x;
x = 0;
x + = 3;
}
Después de la llave que termina un bloque ”}” no se debe colocar “;” , a menos que vaya otra instrucción
a continuación.
Sentencia if-else : En C, la forma general de la sentencia if es:
if expresión_logica
bloque_de_sentencias
[else
bloque_de_sentencias ]
y donde se tiene que:

bloque_de_sentencias = sentencia;
bloque_de_sentencias = {sentencia;
[sentencia;
]}
Ejemplos: if (a > b)
a = a +1;
else
b = b*10;
Programa ejemplo:
#include <stdio.h>
/*Programa del número Mágico*/
main()
{
int magico = 50;
int intento;
printf(“Adivina un número: “);
scanf(“%d”, &intento);
if (intento == magico)
printf(“¡¡¡¡¡Adivinaste!!!!!!”);
else
printf(“ Trata de nuevo........”); getch();
}
Operador ? : Es una alternativa a la sentencia if/else en la forma general. La sintaxis de este

operador es:
Exp1 ? exp2 : exp3
12 | P a g e
Millacariz
Donde exp1, exp2 y exp3 son expresiones.
Ejemplo:
x = 10;
y = x>9 ? 100 : 200
(Asigna a y el valor 100).
La sentencia if/else equivalente es:
x = 10;
if (x>9)
y = 100;
else
y = 200;
Sentencia switch: En caso de tener una variable que puede tener múltiples valores, la forma cómo
operar con cada uno de ellos puede ser mediante if anidados, o bien con la sentencia switch.
switch(variable)
{
case valor1: bloque_de_sentencias;
case valor2: bloque_de_sentencias;
…….
default : bloque_de_sentencias;
Donde se entiende a un bloque de sentencias como a un grupo de una o más instrucciones. Se

recomienda que si es más de una sentencia, las instrucciones se agrupan entre llaves. Una de las
características de la instrucción switch de C, es su comportamiento en cascada, es decir, al encontrar
una sección en que el valor de la variable calze, entra al bloque de instrucciones y las ejecuta todas de
ahí hacia abajo, hasta el final del switch. Para evitar este comportamiento, a veces no deseado, se
acostumbra a poner como última instrucción de un bloque a la instrucción break; la cual indica que
termina la ejecución del bloque y se sale del switch. La sentencia default, se ejecuta si no se encuentra
ninguna correspondencia. Colocar default es opcional.
Ejemplo: switch(numero)
{
case 1: a= a+1;
break;
case 2: a = a+2;
b = b-1;
break;
case 3: c = c+2;
d = d-1;
break;}
case 4 : x = 1;
y = y+2;
break;
case 5 : y = y+3
break;
default : y = 0;
}
13 | P a g e
Millacariz
CAPITULO VII: “Iteraciones en C”

Iteraciones Fijas : Es una estructura de control, que define un número fijo de iteraciones sobre un
grupo de expresiones. En C, la sentencia es for y su sintaxis es:
for (inicialización; condición; incremento)

{
grupo_de_instrucciones;
}
Ejemplo:
a=1 ;
b = 5;
for (i = 1; i <= b; i++)
a = a * i;
Iteración while: Es una estructura de control, que realiza una iteración con ingreso condicionado sobre
un grupo de expresiones. En C su sintaxis es:
while (condición)
{
sentencias;
}
Mientras la evaluación de la condición sea verdadera, se ejecutarán las sentencias del bloque.
Ejemplo:
Loop = 10;
While (loop >= 1)
{
loop = loop – 1;
}
Iteración do-while: Es una estructura de control, que realiza una iteración con salida condicionada. (Se
ejecuta al menos una vez, sirve para validaciones). En C, su sintaxis es:
do
{
sentencias;
}
while (condición);
Ejemplo: loop=10;
do
{
loop = loop –1;
}
while (loop >=1)
Importante: ¿Cuál es la diferencia entre una sentencia while y una do-while?

La sentencia while realiza la evaluación de la expresión y, sólo si ella es verdadera, ejecuta la acción.
La sentencia do-while ejecuta las sentencias y luego evalúa la expresión. Siempre las sentencias se
realizan al menos una vez.
Saltos Incondicionados: Existen dos instrucciones en C que permiten saltos incondicionados dentro
de las sentencias de una iteración. Estas, algunas veces, son necesarias, ante la detección de una
14 | P a g e
Millacariz
condición anómala, necesidad de rechequear la condición de iteración o, aún peor, salir de la iteración
en forma abrupta. Para las situaciones anteriores, C provee las siguientes instrucciones:
break;
1. Usada para finalizar un case en una sentencia switch.

2. Se puede usar para forzar una salida inmediata dentro de una iteración (for, while, do while).
Ejemplos:
for (t =0; t < 100; t ++)
{
cont = 1;
for ( ; ; )
{
printf(“%d”, cont);
cont ++;
if (cont = = 10)
break;
}
}
Este programa imprime los números del 1 al 9, cien veces. Cada vez que el compilador encuentre
break; el control vuelve a la iteración externa.
continue;
Realiza un salto hasta la condición de chequeo de la iteración.
do
{ scanf(“%d”,&x);
if (x < 0)
continue;
printf(“%5d”,x);
} while (x != 100);
Este programa muestra sólo números positivos. Se sale cuando se ingresa el número 100.
Uso apropiado de una iteración: Dadas las tres formas de estructuras de control que provee C, cabe
realizar la siguiente pregunta: ¿Cuándo usar cada una?
a) Si usted no quiere que el cuerpo de la iteración sea realizado cuando la condición empieza
con valor falso, usar while.
b)Si usted quiere que las sentencias siempre sean ejecutadas, al menos una vez, use do-while.
c) Si el número de iteraciones que se va a realizar está determinado por una constante, o una
variable que no va a modificarse en el cuerpo del bloque, utilice for.
15 | P a g e
Millacariz
CAPITULO VIII: “Arreglos en C”

Definición: Un arreglo es una colección de variables del mismo tipo, denominados por un nombre en
común. En C, todos los elementos de un Array constan de espacios de memoria contigua.
Al especificar un arreglo se deben indicar: el tipo de los datos que serán almacenados, el nombre del
arreglo y el número de elementos que tendrá el Array, encerrado entre paréntesis cuadrados:
tipo nombre_de_variable [tamaño];
Ejemplos:
int numeros[10];
char sexo[25];
float ing[20], egr[20], saldo[20];
Acceso: La forma de accesar los elementos del arreglo es mediante el manejo de un subíndice, que
corresponde al número entre paréntesis. El subíndice, puede ser cualquier variable o constante entera.
Ejemplo:
i = 3;
saldo[i] = ing[i] – egr[i] + saldo[i-1];
Elementos: En C, todos los arreglos tienen el 0 como subíndice, y comienzan siempre desde él. Así, al
definir un arreglo de N elementos, los subíndices varían entre el 0 y (N – 1).
Ejemplo: char sex[10];
Declara un array de caracteres de 10 elementos, desde sex[0] hasta sex[9].
Inicialización: Tal como en otras variables, los arreglos deben ser inicializados adecuadamente. Esta
inicialización puede realizarse al momento de la declaración o después de ella.
Ejemplos: int lista[4] = {10,38,5,20};
int x[10];
for (i = 0; i < 10; i++)
x[i] = i;
(Nota: Ver programas de Arreglos en el Apéndice)
Arreglos Multidimensionales.
El lenguaje C, permite definir arreglos multidimensionales. Estos permiten el manejo de matrices u otros
elementos de múltiples dimensiones. La sintaxis de un arreglo multidimensional es:
tipo nombre[tamaño] [tamaño] ... [tamaño];
Ejemplo: int ventas_anuales[12][31];
Este es un arreglo bidimensional, que contiene las ventas diarias de los 12 meses del año.
Acceso: La forma de accesar los elementos del arreglo es mediante el manejo de sus subíndices.
Ejemplo:
int a[10][20];
16 | P a g e
Millacariz
Define un arreglo cuyo primer índice varía entre 0 y 9, y el segundo entre 0 y 19.
El primer elemento se encuentra en: a[0][0].
Para referirse al elemento en la posición 8,15, se debe usar: a[7][14];
Para accesar el punto 8,15 del array, se debe usar: a[8][15];
(Nota: Ver programas de Matrices en el Apéndice)
Arreglos y Strings: Un string es simplemente un arreglo de char con carácter nulo que indica el fin del
string. Así, la declaración:
char nombre[30];
Tiene 29 elementos usables.
Todo array de caracteres en C, debe finalizar con el carácter nulo, usted debe asegurarse de definir un
tamaño suficiente para incluirlo.
Ejemplos:
char letras[5] = ‘ABCD’;
char letras[5] = {‘A’, ‘B’, ‘C’, ‘D’, ‘\0’};
Observe que en la última declaración de letras, se debe incluir explícitamente el carácter nulo.
CAPITULO IX: “Funciones de caracteres y strings”

Definición: Un string es un array de caracteres que finaliza con el carácter nulo, y un carácter es el
valor de un byte. Las funciones de manipulación de strings usan el header <string.h> y las que
manipulan caracteres, el header <ctype.h>. Ambos se encuentran en la biblioteca estándar definida
por el ANSI C.
<string.h> : Algunas de las funciones definidas en este header son:
a) strcpy(S1,S2): Copia el string S2 en S1, incluyendo el carácter nulo; regresa a S1.
b) Strcat(S1,S2): Concatena el string S2 al final del string S1; regresa a S1.
c) Strcmp(S1,S2): Compara el string S1 con el string S2; regresa un número entero: < 0 si S1
>S2; 0 si S1 = S2; >0 si S1 >S2.
d) Strlen(S1) : Regresa la longitud del string S1.
<ctype.h> : Las funciones definidas en este header, regresan un entero distinto de cero(0); si el
carácter c que tiene como argumento satisface a la condición descrita. Algunas funciones son:
a) isalnum(c): Chequea que el carácter c sea una letra (mayúscula o minúscula) o un dígito.
b) isalpha(c): Chequea que c sea una letra (mayúscula o minúscula).
c) iscntrl(c): Chequea que c sea un carácter de control.
d) isdigit(c): Chequea que c sea un dígito.
17 | P a g e
Millacariz
e) islower(c): Chequea que c sea una letra minúscula.

f) isupper(c): Chequea que c sea una letra mayúscula.
g) isspace(c): Chequea que c sea un espacio, retorno, tabulador, avance de página o nueva línea.
CAPITULO X: “Funciones y Procedimientos”

Introducción: Una de las ideas más importantes en la codificación de un programa, es la de dividir un
programa complejo en subtareas menos difíciles, con el fin de atacar el problema desde sus aspectos
más generales a los más particulares (Diseño TOP-DOWN). También es importante distinguir que
muchas de estas subtareas en que se divide nuestro problema, presentan estructuras similares con
variación de algunos parámetros. Otro aspecto que cabe señalar, es el uso de las librerías de funciones.
Por ejemplo, cada vez que necesitamos realizar operaciones de E/S, utilizamos una librería de
funciones. Es decir, estamos aprovechando la codificación que otra persona realizó, simplificando en
gran medida nuestra codificación. Los procedimientos y las funciones son los elementos de
programación que ponen en práctica las tres ideas anteriores:
a) Descomposición de un gran problema en subtareas.

b) Tareas similares con sólo parámetros de entrada diferentes.
c) Reutilización del código.
Funciones: La idea de función, está generalmente asociada a una idea matemática, es decir, a una
expresión matemática que, dados unos parámetros, nos entrega un valor. En C, una función es mucho
más que una expresión matemática. Podríamos decir que se trata de un trozo de código independiente
de nuestro programa, que puede tener o no parámetros, que dados los valores de entrada ejecuta una
serie de acciones que finalmente se expresan en el valor de la función.
Procedimientos: Un procedimiento es similar a una función a excepción de que no retorna valor. Sin
embargo, contiene un cuerpo con cierta funcionalidad, pudiendo retornar los valores en sus argumentos.
Sintaxis en C: Las funciones en C, presentan la siguiente forma:
tipo_función nombre(lista_parámetros)
{
cuerpo_de_la_función
return (valor);
}
Donde, tipo_función, corresponde al tipo de valor que devuelve la función, pudiendo ser cualquier tipo
válido (int,float, char, etc.). Si se trata de un procedimiento, existe un tipo especial que define el no
retornar nada: void.
La sentencia return, tiene dos usos importantes. Primero, fuerza una salida inmediata de la función en
que se encuentra, siguiendo la ejecución en el código que llamó a la función. El otro uso, es para
devolver un valor.
En C, todas las funciones, excepto las de tipo void, devuelven un valor. Este valor, se especifica
explícitamente en la sentencia return. Cuando una función no se define de tipo void y además no se
especifica un valor de vuelta, entonces el valor devuelto por la función queda técnicamente indefinido.
Toda función que no se declare como void, puede ser usada como operando en cualquier expresión
válida de C. Por ejemplo:
if (max(x,y) > 100) printf(“Mayor:”,max);
18 | P a g e
Millacariz
No es necesario asignar siempre el valor devuelto por alguna función. Cuando esto ocurre, el valor
devuelto simplemente se ignora.
En C, es fundamental colocar el tipo de la función, pues de lo contrario, se interpretará que la función

retorna un entero.
En main(), la sentencia return devuelve un código de terminación al proceso de llamada, un valor 0

(cero) indica que el programa ha terminado normalmente. Todos los demás valores indican que se ha
producido algún tipo de error.
Declarar una sentencia return en main(), es opcional. Pero, es una buena costumbre hacerlo.
Argumentos de funciones: Cada función que use argumentos, debe declarar variables que acepten
los valores de los argumentos. Estas variables se llaman parámetros formales de la función.
Ejemplos:
mul(int a, int b)
{
return a*b;
}
La función mul, tiene dos parámetros: a y b
Al igual que, como en otro tipo de variables, se pueden hacer asignaciones a los parámetros formales
de una función o usarlos en cualquier expresión válida en C.
Llamada por Valor: En esta forma de pasar argumentos, se copia el valor del argumento en el
parámetro formal de la sub-rutina. De esta manera, los cambios producidos en los parámetros de la
sub-rutina no afectan a las variables que se usan en la llamada.
Ejemplo: #include <stdio.h>

void cambiar(int x, int y);
main()
{
int a,b;
a = 5;
b = 8;
cambiar(a,b);
printf(“%d”,a);
return 0;
}
/* Coloca el valor del segundo parámetro en el primero y viceversa */
void cambiar(int x, int y)
{
int temp;
temp = x;
x = y;
y = temp;
}
Llamada por Referencia: Es otra forma de pasar argumentos a una sub-rutina. En este método, se
copia la dirección del argumento en el parámetro formal, cualquier cambio producido en los parámetros
de la sub-rutina, modifican a la variable usada en la llamada.
19 | P a g e
Millacariz
Para causar una llamada por referencia se debe pasar un puntero al argumento, esto se hace
incorporando un amppersand (&) delante de él. Además, se debe declarar el respectivo parámetro
formal de tipo puntero.
Ejemplo:
#include <stdio.h>
void cambiar(int *x, int *y);
main()
{
int a,b;
a = 5;
b = 8;
cambiar(&a,&b);
printf(“%d”,a);
return 0;
}
/* Coloca el valor del segundo parámetro en el primero y viceversa */
void cambiar(int *x, int *y)
{
int temp;
temp = *x;
*x = *y;
*y = temp;
}
Cuerpo de una función: El cuerpo de una función corresponde al código de implementación de la

función. Este código, al igual que cuando es implementado en el main(), puede contener variables de
uso auxiliar en sus primeras líneas. Sin embargo, a diferencia del main(), estas variables serán locales
a esta función, vale decir sólo pertenecen a la función, no pudiendo ser accesada desde otra función o
desde el main().
CAPITULO XI: “E/S en Archivos”

El sistema de archivos en ANSI C, se compone de varias funciones que se encuentran en el header
<stdio.h>.
Puntero a Archivo: Se debe indicar sobre qué archivo se desea realizar la lectura o escritura. Para
esto, hay que emplear una variable de tipo puntero que representará al archivo. Un puntero a un archivo
es un puntero a una información que define varias cosas sobre él, incluyendo su nombre, su estado y su
posición actual. La variable de tipo puntero se declara bajo la siguiente sintaxis:
FILE *nombre;
Abrir un Archivo: Consiste en asociar un archivo externo (desde un directorio de nuestro sistema), con
la variable de tipo puntero que lo referencia en el programa. Para esto, se utiliza la función fopen() que
devuelve un puntero de tipo FILE. La asociación se logra a través de la siguiente declaración:
fp = fopen (nombre_archivo, tipo_acceso);
Donde fp corresponde a la variable de tipo FILE ya declarada, y a la que se le asociará el puntero que
retorna fopen().
El nombre del archivo se especifica en nombre_archivo y el tipo_acceso corresponde al modo en que

se trabajará sobre el archivo.
20 | P a g e
Millacariz
Se puede abrir un archivo en modo texto o en modo binario. En modo texto, las secuencias de salto de
línea se convierten a caracteres de salto de línea en la lectura. En la escritura ocurre lo contrario, los
caracteres de salto de línea se convierten en saltos de línea. Estas conversiones no ocurren en archivos
binarios.
A continuación, se indicarán los distintos tipos_acceso :
Archivos de Texto
“r” Abre para lectura.

“w” Crea para escritura
“a” Abre para añadir
“r+” Abre para lectura/escritura
“w+” Crea para lectura/escritura
“a+” Abre o crea para lectura/escritura
Para archivos binarios se debe agregar una letra b al final.
Ejemplo:
fp = fopen(“prueba”, “w”)
Se crea el archivo prueba para escritura. Si el archivo existe se borra y se crea uno nuevo, si no existe,
simplemente se crea. Para abrir archivos de lectura estos deben existir, de lo contrario devuelve un
error.
Validación: Si por alguna razón la función fopen() fallara, retornará una referencia nula NULL. Por
esto, es conveniente al abrir un archivo, usar la siguiente operación:
if (( fp = fopen(“prueba”,”w”)) = = NULL)
printf(“Error: Al abrir el archivo prueba”);
Escritura de archivos: Se utiliza la función fprintf(), su sintaxis es similar a printf() salvo que como
primer argumento debe llevar la variable de tipo FILE que se asoció al archivo:
fprintf(var_FILE,str_control, arg1, arg2, ...);
Lectura de Archivos: Se utiliza la función fscanf() que es similar a scanf(). También, se debe incluir la
variable de tipo FILE a la que se asoció el archivo:
fscanf(var_FILE, s_control, &arg1, &arg2, ...);
Cerrar un Archivo: Se utiliza la función fclose(), que elimina la referencia al archivo abierto con fopen()
y realiza un cierre formal del archivo. La sintaxis es la siguiente:
fclose(var_FILE);
Cuando fclose() tiene éxito, se devuelve un 0 y si ocurre un error se devuelve EOF. Generalmente,
fclose() falla cuando se ha retirado antes de tiempo un diskette o cuando no queda espacio libre en él.
21 | P a g e
Millacariz
APENDICE A
FUNCIONES DE C
FUNCION TIPO PROPOSITO INCLUDE

abs(i) int Retorna el valor absoluto de i stdlib.h
atof(s) double Convierte la cadena a una cantidad en doble precisión stdlib.h
atoi(s) int Convierte la cadena a un entero stdlib.h
atol(s) long Convierte la cadena s en un entero largo stdlib.h
exit(u) void Cerrar todos los archivos y buffers y terminar el programa stdlib.h
rand(void) int Retorna un valor aleatorio positivo stdlib.h
acos(d) double Retorna el arcoseno de d math.h
asin(d) double Retorna el arco seno de d math.h
atan(d) double Retorna el arco tangente de d math.h
atand2(d1,d2) double Retorna el arco tangente de d1/d2 math.h
cos(d) double Retorna el coseno de d math.h
cosh(d) double Retorna el coseno hiperbólico de d math.h
exp(d) double Elevar d a la potencia de e=2.711182818 es la base de los math.h
logaritmos naturales
fabs(d) double Retorna el valor absoluto de d math.h
floor(d) double Retorna el valor redondeado por defecto al entero menor math.h
más cercano
fmod(d1/d2) double Retorna el resto de d1/d2 con el mismo signo que d1 math.h
labs(l) long int Retorna el valor absoluto de l math.h
log(d) double Retorna el logaritmo natural de d math.h
log10(d) double Retorna el logaritmo (en base 10) math.h
pow(d1,d2) double Retorna d1 elevado a d2 math.h
sin(d) double Retorna el seno de d math.h
sinh(d) double Retorna el seno hiperbólico de d math.h
sqrt(d) double Retorna la raíz cuadrada de d math.h
tan(d) double Retorna la tangente de d math.h
fclose(f) int Cierra el archivo f. Retorna un 0 si el archivo se ha cerrado stdio.h
con éxito
feof(f) int Determina si se ha encontrado un fin de archivo. Si es así, stdio.h
devuelve un valor distinto de 0
fopen(s1,s2) file* Abre un archivo llamado s1, del tipo s2. Retorna un puntero stdio.h
al archivo
fread(s,i1,i2,,f) int Leer i2 elementos, cada uno de tamaño i1 bytes, desde el stdio.h
archivo f hasta la cadena s
22 | P a g e
Millacariz
FUNCION TIPO PROPOSITO INCLUDE

fwrite(s,i11,i2,f) int Escribir i2 elementos, cada uno de i1 byte desde la cadena s stdio.h
hasta el archivo f
getchar(void) int Lee un carácter desde dispositivo estándar stdio.h
gets(s) char* Lee una cadena desde dispositivo estándar stdio.h
printf(...) int Escribe datos en el dispositivo de salida estándar stdio.h
putchar(s) int Escribe un carácter en el dispositivo de salida estándar stdio.h
puts(s) int Escribe una cadena en el dispositivo estándar stdio.h
rewind(f) void Mueve el puntero al principio del archivo f stdio.h
scanf(...) int Lee datos desde el dispositivo de entrada estándar stdio.h
getch() int Espera que se le ingrese un carácter y devuelve el valor, conio.h
pero no lo muestra en pantalla
getche() int Espera que se le ingrese un carácter y de vuelve el valor, conio.h
mostrándolo en pantalla
isalnum( c) int Determina si el argumento es alfanumérico. Retorna un valor ctype.h
distinto de 0 si es cierto; en otro caso, devuelve 0
isalpha( c) int Determina si el argumento es alfabético. Retorna un valor ctype.h
distinto de 0 si es cierto en otro caso, devuelve 0.
isdigit( c) int Determina si el argumento es un dígito decimal. Retorna un ctype.h
valor distinto de 0 si es cierto; en otro caso devuelve 0
islower( c) int Determina si el argumento es una minúscula .Retorna un ctype.h
valor distinto de 0 si es cierto; en otro caso devuelve 0
isspace( c) int Determina si el argumento es un espacio en blanco. Retorna ctype.h
un valor distinto de 0 si es cierto; en otro caso devuelve 0
isupper(c ) int Determina si el argumento es una mayúscula. Retorna un ctype.h
valor distinto de 0 si es cierto, en otro caso devuelve 0
tolower int Convierte una letra a minúscula ctype.h
stdlib.h
toupper int Convierte una letra a mayúscula ctype.h
stdlib.h
strcmp(s1,s2) int Compara dos cadenas lexicográficamente Retorna un valor string.h
negativo si s1<s2; un 0 si s1=s2; y un valor positivo si s1>s2
Esta sentencia considera las mayúsculas y las minúsculas
strcmpi(s1,s2) int Compara dos cadenas lexicográficamente. Retorna un valor string.h
negativo si s1<s2; un 0 si s1=s2 y un valor positivo si s1>s2
Compara sin considerar las mayúsculas y las minúsculas
strcpy(s1,s2) char* Copia la cadena s2 en s1 string.h
strlen(s,c) int Retorna el número de caracteres de la cadena string.h
strset(s,c) char* Pone todos los caracteres de s en c, (excluyendo el carácter string.h
nulo del final \0)
NOTAS:
Tipo se refiere al tipo de la cantidad devuelta por la función.

Un asterisco (*) denota un puntero.
c denota un argumento de tipo carácter

d denota un argumento de doble precisión
f denota un argumento archivo
i denota un argumento entero
l denota un argumento entero largo
p denota un argumento puntero
s denota un argumento cadena o string
u denota un argumento entero sin signo
23 | P a g e
Millacariz
APENDICE B:
A continuación un programa sin procedimientos ni funciones que incluye algunos comandos:
/* MENU-NUM.C*/
# include <stdio.h>
#include <conio.h>
int n1,n2,n3,may,prom,suma,m1,m2,m3;
char op1;
main()
{
do
{
clrscr();
gotoxy(30,2);printf("Menú Principal");
gotoxy(30,3);printf("==============");
gotoxy(30,4);printf("1....Encontrar el mayor");
gotoxy(30,5);printf("2....Calcular el Promedio");
gotoxy(30,7);printf("3....Salida");
gotoxy(30,9);printf("Opción [ ]\b\b");op1=getch();
switch(op1)
{
case '1':
clrscr();
gotoxy(30,1); printf("Ingresar 3 Números y encontrar el Mayor");
gotoxy(30,2); printf(“---------------------------------------“);
gotoxy(10,5); printf("Primer Número : ");
gotoxy(10,7); printf("Segundo Número: ");
gotoxy(10,9); printf("Tercer Número : ");
gotoxy(26,5);scanf("%d",&n1);
may=n1;
if (n2>may)
may=n2;
if (n3>may)
may=n3;
gotoxy(10,12);printf("El número Mayor es: %d",may);getch();
break;
case '2':
clrscr();
n1=0;n2=0;n3=0;prom=0;suma=0;
gotoxy(30,1);printf("Ingresar 3 Números y Calcular el Promedio");
gotoxy(30,2);printf("=========================================");
gotoxy(10,5);printf("Primer Número: ");
gotoxy(10,7);printf("Segundo Número: ");
gotoxy(10,9);printf("Tercer Número: ");
suma=n1+n2+n3;
prom=suma/3;
gotoxy(10,12);printf("El Promedio es : %d",prom);
getch();
break;
}
24 | P a g e
Millacariz
}
while (op1!='3');
}
25 | P a g e

Guia Lenguaje C

Uploaded by

Document Information

Original Description:

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Guia Lenguaje C

Uploaded by

Copyright:

Available Formats

Fundamentos de Programación Profesor: Cristian

CAPITULO I: “Características del Lenguaje C”

La principal característica de un lenguaje estructurado, es la capacidad de seccionar y esconder del

En base a lo anterior, C se denomina lenguaje sencillamente estructurado, dado que no permite la

Compilador versus Intérprete

auto double int struct

La forma general de un programa en C es la siguiente:

Compilación Separada: La mayoría de los programas cortos de C están enteramente contenidos en un

CAPITULO II: “Variables en C”

Tipo Tamaño en bits Rango

Tipo Tamaño en bits Rango

Ejemplos: int i,j,k;

Sin embargo, en C es posible realizar dicha inicialización en el momento de la declaración de la

Declaración de Constantes: Para definir constantes en C, se debe seguir la siguiente sintaxis:

b) // Este comentario sólo es válido hasta fin de línea

CAPITULO III: “Operadores en C”

10 > 5 && !(10 < 9) || 3 <= 4

CAPITULO IV: “Asignaciones y Expresiones en C”

Asignación: La asignación de valores a las variables definidas y el cómputo de operaciones aritméticas

pare = (i == 2) && (!ultimo)

Abreviaturas: C permite abreviaturas que simplifican la escritura de ciertos tipos de sentencias de

Expresión operador = expresión;

Después de la ejecución x toma el valor 5.

CAPITULO V: “E/S por consola con Formato”

Sintaxis: printf(“formato”, lista_variables);

Barra Invertida: Algunos códigos de barra invertida son:

scanf(“Sr. %s %s”, nombre, apellido);

CAPITULO VI: “Sentencias de Control”

Sentencia if-else : En C, la forma general de la sentencia if es:

y donde se tiene que:

Operador ? : Es una alternativa a la sentencia if/else en la forma general. La sintaxis de este

Exp1 ? exp2 : exp3

Donde exp1, exp2 y exp3 son expresiones.

La sentencia if/else equivalente es:

Donde se entiende a un bloque de sentencias como a un grupo de una o más instrucciones. Se

CAPITULO VII: “Iteraciones en C”

for (inicialización; condición; incremento)

Importante: ¿Cuál es la diferencia entre una sentencia while y una do-while?

1. Usada para finalizar un case en una sentencia switch.

CAPITULO VIII: “Arreglos en C”

tipo nombre_de_variable [tamaño];

Ejemplo: char sex[10];

Declara un array de caracteres de 10 elementos, desde sex[0] hasta sex[9].

tipo nombre[tamaño] [tamaño] ... [tamaño];

Ejemplo: int ventas_anuales[12][31];

El primer elemento se encuentra en: a[0][0].

Para referirse al elemento en la posición 8,15, se debe usar: a[7][14];

Para accesar el punto 8,15 del array, se debe usar: a[8][15];

(Nota: Ver programas de Matrices en el Apéndice)

Tiene 29 elementos usables.

CAPITULO IX: “Funciones de caracteres y strings”

<string.h> : Algunas de las funciones definidas en este header son:

a) strcpy(S1,S2): Copia el string S2 en S1, incluyendo el carácter nulo; regresa a S1.

b) Strcat(S1,S2): Concatena el string S2 al final del string S1; regresa a S1.

d) Strlen(S1) : Regresa la longitud del string S1.

e) islower(c): Chequea que c sea una letra minúscula.

CAPITULO X: “Funciones y Procedimientos”

a) Descomposición de un gran problema en subtareas.

Sintaxis en C: Las funciones en C, presentan la siguiente forma:

En C, es fundamental colocar el tipo de la función, pues de lo contrario, se interpretará que la función

En main(), la sentencia return devuelve un código de terminación al proceso de llamada, un valor 0

La función mul, tiene dos parámetros: a y b

Ejemplo: #include <stdio.h>