Guía Rápida de Lenguaje C

Lenguaje C
Caracterizado por ser de uso general, con una sintaxis sumamente compacta y de alta
portabilidad. Es un lenguaje de nivel medio con estructuras de alto nivel comparables a las que
dispone Pascal y Fortran, además de características de bajo nivel que ayuda a escribir programas
que toman ventajas de las características a nivel de maquina.

Variables Y Sentencias
Una variable no es más que un nombre para identificar una (o varias) posiciones de memoria
donde el programa guarda los distintos valores de una misma entidad.

 Los nombres de las variables deben comenzar con una letra.

 Pueden estar formados por una secuencia de letras del alfabeto y/o dígitos del 0 al
9 y/o el carácter “_” (subrayado).
 El nombre de la variable puede tener cualquier longitud.
 No se permiten comas ni espacios en blanco en el nombre de una variable.

Sentencia de Declaracion de Variables

<Tipo de Variable> <Nombre de la Variable>;

Ejemplo:

Int Num;

Int: Palabra reservada en C que indica se esta haciendo una declaración de una variable tipo
entero.
Num: nombre de la variable.

1
___________________________________________________________________________
Cuando se declaran múltiples variables de un mismo tipo no se necesita declararlas
separadamente.
Ejemplo:

Int Num, digito1, digito2;

El símbolo ; se usa como separador de sentencias, delimitador de sentencias.

Comentarios en C

C requiere que un comentario sea delimitado mediante /* y */ para comentarios de una o varias
líneas, que con frecuencia insertan los programadores al final de una línea de código.

Ejemplo
/* Esto es un comentario */
Constantes en C

Constantes enteras
Constantes de punto flotante
Constantes de carácter
Constantes de cadena

Sentencia de Declaracion de Constantes

<Tipo de Variable> <Nombre de la Variable> = <valor de asignación>

Ejemplo:

Const int Num = 5;

Int Num = 5;

2
___________________________________________________________________________
Int: Palabra reservada en C que indica se esta haciendo una declaración de una variable tipo
entero.
Num: nombre de la variable.

Tipos de datos Básicos en C

Tipo de Dato Descripción

int Entero
float Numero punto flotante
double Numero punto flotante de doble precisión
Char Carácter simple

Constantes de caracteres secuencias de escape

Código de escape Significado
„\n‟ Nueva línea
„\r‟ Retorno de carro
„\t‟ Tabulación
„\v‟ Tabulación vertical
„\a‟ Alerta (pitido sonoro)
„\b‟ Retroceso de espacio
„\f ‟ Avance de página

Operadores Aritméticos en C
Operador Acción
- Resta
+ Suma
* Multiplicación
/ División

3
___________________________________________________________________________
 % Modulo División
-- Decremento
++ Incremento

Prioridades de operadores Aritméticos

Prioridad Operador Acción
0 [],() Paréntesis y Corchetes
1 *, / , % Multiplicación., División y modulo
2 +,- Suma y Resta
3 = Asignación

Operadores Lógicos
Operador Acción
&& Y (and)
! O (or)

No(not)
Operadores Relacionales

Operador Acción
> Mayor que
< Menor que
>= Mayor o igual que
<= Menor o igual que
== Igual que
!= No igual que

4
___________________________________________________________________________
Operadores de Asignación
Símbolo Uso Descripción Equivalencia
= a=b Asigna el valor de b a la variable a a=b
*= a *= b Multiplica a por b y asigna el resultado a la variable a a = a * b
/= a /= b Divide a entre b y asigna el resultado a la variable a a=a/b
%= a %= b Fija a al resto de a/b a=a%b
+= a += b Suma b y a y asigna el resultado a la variable a a=a+b
-= a -= b Resta b de a y asigna el resultado a la variable a a=a-b

Ordenes de Formato para Printf y Scanf

Código Formato
%c Carácter
%d Enteros decimales con signo
%i Enteros decimales sin signo
%e Numero tipo coma flotante
%E Numero tipo coma flotante
%f Numero tipo coma flotante
%o Octal sin signo
%s Cadena de caracteres
%u Entero decimal sin signo
%x Numero hexadecimal
%p Puntero
%% Imprime el signo %
Estructura general de un programa en C
include <stdio.h>
main ()
{
…Sentencias
}

5
___________________________________________________________________________
Declaraciones Globales
Las declaraciones globales se sitúan antes de la función main. Cualquier función de programa,
incluyendo main puede acceder a la variable.
Ejemplo:
include <stdio.h>
int Calificaciones;
main ()
{
…Sentencias
}
Flujo de entrada y de salida de datos en C
La función más utilizada para entrada formateada es scanf() y para dar salida a cualquier dato,
asociándole el código que le corresponde es printf().
Ejemplo:
include <stdio.h>
main ()
{
char primero, ultimo;
printf (“Introduzca su primera y ultima inicial:”);
scanf (“%c %c”,&primero,&ultimo);
printf(“Hola, %c .%c . \n” , primero, ultimo);
return 0;
}

Estructuras de Control
Condicional Sentencia if

La sentencia if tiene dos alternativas o formatos:

if (expresión) acción;

6
___________________________________________________________________________
if (condición) sentencia;
condición: es una expresión entera lógica
sentencia: es cualquier sentencia ejecutable, que se ejecutara solo si la condición toma un valor
distinto de cero

include <stdio.h>
main ()
{
int n1, n2 ;
printf (“Introduzca dos enteros:”);
scanf (“%d %d”,&n1,&n2);
if (n %d == 0) printf(“ %d es divisible por %d \n” , n1, n2 );
return 0;
}
Sentencia if - else
Sintaxis:
if (expresión) Accion1 else Accion2;
Ejemplo
if (salario>100000)
salario_neto = salario –impuestos;
else
salario_neto= salario;

Sentencia if – else anidadas

Sintaxis:
if (condicion1)
sentencia1
else if (condicion2)
sentencia2;
else if (condicion3) sentencia3 ….

7
___________________________________________________________________________
Ejemplo Calcular el mayor de tres números
include <stdio.h>
main ()
{
Int a , b , c , mayor;
printf (“Introduzca tres enteros:”);
scanf (“%d %d %d”,&a,&b,&c);
if (a > b)
if (a>c )
mayor = a;
else mayor=c;
else
if ( b > c) mayor = b;
else mayor = c;
printf(“El mayor es %d \n” , mayor);
return 0;
}

Sentencia de Control switch

Sintaxis
Switch (selector)
{
Case etiqueta1: sentencias1;
break;
Case etiqueta2: sentencias1;
break;
Case etiqueta…: sentencias…;
break;
default: sentencias;
}

8
___________________________________________________________________________
Ejemplo
Switch (tipo_Vehiculo)
{
Case 1:
printf (“Turismo \n”);
peaje =500;
break ;
Case 2:
printf (“autobus \n”);
peaje =3000;
break ;
default: Printf (“Vehiculo no autorizado\n”);
}

Bucles Sentencias while, for y do while

Sintaxis
while (condicion _bucle)
{
sentencia-1
sentencia-2
.
.
sentencia-N
}

Ejemplo: Visualizar 20 asteriscos

contador = 0;

9
___________________________________________________________________________
while (contador < 20)
{
printf(“ * ”);
contador + +; /* incrementa contador en 1*/
} /*fin del while*/

Sintaxis bucle For

For (var_control = valor_incial; var_control = valor_limite; exp_incremento )
sentencia;
Ejemplo
int i , j ;
for (i = 0; i< 25; i++)
{
printf(“ * ”);
}
Sintaxis bucle do while
Do
{
Sentencias ;
}
while (expresion);
Ejemplo
potencia=1;
Do
{
Printf(“%d \n”,potencia);
Potencia* = 2;
} while ( potencia < 1000);

10
___________________________________________________________________________
Funciones en C
Una función es un programa auto contenido que lleva a cabo una tarea especifica.
Estructura de una función en C con retorno de Valor
Tipo de retorno <nombre de función> (Lista de parametros)
{
Cuerpo de la función
return expresión;
}
El cuerpo de la función es el conjunto encerradas en llaves.
La sentencia return ayuda a pasar el valor del resultado único al programa que hizo la llamada.
Paso de parámetros a una función
Tipo de retorno <nombre de función> (tipo arg1 , tipo arg2 …)
{
Cuerpo de la función
return expresión;
}
Llamada a una Función
main()
{
<nombre de función> (tipo arg1 , tipo arg2 …);
}
Ejemplo: Función que suma dos números reales
#include<stdio.h>
float suma (float num1, float num2);
float suma (float num1, float num2)
{
float resul;
resul = num1 + num2;
return resul;
}

11
___________________________________________________________________________
main ( )
{
int i , j , resultado ;
printf( “Introduzca dos números reales \n” );
scanf ( “%f %f ”, Valor1,Valor2);
resultado= suma(Valor1, Valor2 );
printf( “La suma de los números es \n”, resultado );
}

Estructura de una función en C sin retorno de Valor

void <nombre de función> (tipo arg1 , tipo arg2 …);
{
Sentencias;
return;
}
Las funciones void no necesitan tener la función return y pueden o no recibir parámetros o
argumentos.
Ejemplo:
Void func (int i)
{
printf( “%d \n” , i );
i++;
}
main ( )
{
int i = 6 ;
func(i);
}

12
___________________________________________________________________________
Manejo de Arreglos:
 Declaración:
Tipo nombrearreglo[numerodeelementos];
Int numeros[10];
 Carga:
for (k=0; k<10; k++) {
printf ("Introduzca un numero: ");
scanf ("%d",&numeros[k]);
}
 Visualización de un arreglo:
for (k=0; k<10; k++) {
printf("%d",numeros[k]);
}
Nota: todo arreglo en C comienza desde la posición 0.
 Inicialización de un arreglo:
Precio[0]=15000;
Int n[]={2,3,5}; /*declarando un array de 3 elementos*/
n[]:
2 3 5

Indice 0 1 2

Int n[]={„a‟,‟b‟,‟c‟,‟d‟}; /*declarando un array de 4 elementos*/

 Matrices:
 Declaración:
Tipodedatoselemento nombrearreglo[numerodefilas][numerodecolumnas];
Int equipos[4][3];
 Carga:
for (i=0; i<4; i++) {
for (k=0,l=0; k<3; k++) {

13
___________________________________________________________________________
 printf ("Introduzca un numero: ");
scanf ("%d",&equipos[i][k]);
}
}
 Visualización:
for (i=0; i<4; i++) {
for (k=0; k<3; k++) {
printf("%d",equipos[i][k]);
}
}
 Inicialización:
Int tabla[2][3]={{51,25,40},{54,55,56}};
Tabla[2][3]:

Fila
0 51 25 40

1 54 55 56
0 1 2 columnas

14
___________________________________________________________________________
Estructuras

Un registro o estructura es una estructura heterogénea de datos, denominados miembro y a los

que accedemos por nombre. Al igual que cualquier otro dato, el tipo estructura (struct) antes de
poder se utilizado debe ser declarado.
La única operación (a parte de la lectura) que se puede realizar con una estructura es la
asignación. Además una estructura puede ser pasada como parámetro a una función o
procedimiento.

Se puede definir una estructura en C como sigue:

struct <nombre de la estructura> {
Mienbro1;
Mienbro2;
…
Mienbron;
};
Ejemplo:
struct fecha{
int dia;
int mes;
int anio;
};
Declarar variables
Struct fecha nacimiento, ingreso_trabajo, jubilacion;
Si se desea hacer referencia a los miembros individuales de la estructura en cada
variable, se hace lo siguiente:
nacimiento.dia
Esto implica que el acceso se hace: variable.mienbro
La siguiente es otra forma de definirlas:
struct fecha{
int dia;
int mes;
int anio;
} nacimiento, ingreso_trabajo, jubilacion;

15
___________________________________________________________________________
 static struct fecha{
int dia;
int mes;
int anio;
} nacimiento, ingreso_trabajo, jubilacion;
Se puede asignar valor a la variable en la declaración misma como se muestra a
continuación:
struct fecha f={2,5,1976}
Ejemplo:
struct nombre{
char primer[20];
char segundo[20];
char apellido[45];
}minombre={”ana”,”maria”,”perez”};
struct estudiante{
struct nombre nombreestudiante;
char num_id[9];
struct fecha nacimiento;
float peso;
float altura;
int iq;
}programacion[100];
programacion[0].nacimiento.anio=1989;
 Acceso a una estructura:
1. utilizando el operador punto (.)
2. utilizando el operador puntero (->)

16
___________________________________________________________________________
 Puntero:
Es una variable en c que representa una dirección de un elemento de datos en la memoria. Un
puntero apunta a una dirección en la memoria donde un elemento float, int, char, un arreglo o
una estructura se pueden encontrar.
Para entender el concepto veamos int x = 4;
Nombre de x
la variable Valor en la posición
4 (contenido de la
variable)

Dirección de 43658
la variable
Considere lo siguiente:
printf("%d\n",x);
se imprime el valor de 4
printf("%u\n",&x);
se imprime el valor de 43658, (se uso el especificador %u que significa un entero sin
signo) el operador & es el operador de referencia o dirección de
var_nombre=&x; se asigna &x a otra variable:

Dirección valor de x, que es, 4

de x

Var_nombre x

acceder a valores usando punteros:

var_nombre=&x; /*coloca el puntero de la posición de x en la variable*/
y = *var_nombre; /*busca el valor de x, el cual es 4 y lo asigna a y*/
Declaración:
tipo_de_dato *variable_puntero;
ejemplo:
int *p;
char *palabra;
int i; /* define la variable i*/

17
___________________________________________________________________________
 int *p; /* define un puntero a un entero p*/
p=&i; /*asigna la dirección de I a p*/
Aun cuando las declaraciones anteriores apuntan a diferentes tipos de datos, las variables
puntero sólo pueden contener direcciones.
Un sistema de inicializar una variable a un puntero nulo es:
#define null 0;
Char *p=null;
Puntero como argumento de funciones
Void incremento(int *i)
{
*i +=5;/*incrementa un entero en 5
}
La llamada
int i;
i=10;
incremento(&i);
Void funcion(int *s,int t)
{
*s =6;
T =25;
}
La llamada
int i,j;
i=5;j=7;
funcion(&I,j);
struct temperature{
float alta;
float baja,
};
Void registro(struct temperatura *t)

18
___________________________________________________________________________
 {
float actual;
leer(actual);
if (actual > t->alta)
t->alta= actual;
else if (actual<t ->baja)
t->baja= actual;
}
La llamada puede ser:
struct temperatura tmp;
registro(&tmp);
Errores comunes:
float* px; float px;
*px=23.5; /* error px no contiene float* px;
dirección*/ px=&px;
Forma correcta: *px=23.5;

Archivos:
Un archivo de datos, es una colección registros (líneas), que constan a su vez de varios elementos
denominados campos, relacionados entre si con aspectos en común y organizados para un
propósito específico. Se emplean para manejar grandes cantidades de datos, y representan una
ventaja sustancial cuando se debe ejecutar un programa con la misma entrada de datos, ya que se
almacenan en el computador o en unidades auxiliares (disquetes, CD-ROM y otros).
Como ya se dijo, cada línea de un archivo de datos representa un registro o colección de
información o un conjunto de campos lógicamente relacionados, por ejemplo un archivo de datos
que contiene el nombre, cédula y fecha de nacimiento (dn,mn,an), tendría la siguiente forma:

El archivo contiene exclusivamente datos, sin títulos ni líneas en blanco o vacías. Los archivos
secuenciales son aquellos que implican el acceso a sus datos en el orden en que se almacenaron,
uno tras otro, es decir, que para acceder a determinado registro n se debe pasar por los n - 1

19
___________________________________________________________________________
registros anteriores, por ejemplo del archivo presentado, para poder procesar la fecha de
nacimiento de Ana María, previamente se debió leer el nombre y la cédula hasta llegar a la fecha
de nacimiento. Por último para procesar a Daniel se debió leer previamente la información de
Ana María y José Luis respectivamente.

Para el manejo datos contenidos en archivos a través de un programa se deben realizar las
siguientes operaciones:
1. Creación: Es la operación mediante el cual se introduce la información correspondiente al
archivo y se guarda en algún dispositivo de almacenamiento, generalmente el disco duro. Antes
de que cualquier usuario pueda procesar un archivo es preciso que este haya sido creado
previamente. Esta operación será necesario si el archivo se va a leer o se le va a agregar
información.
2. Declaración: El primer paso para gestionar ó utilizar un archivo mediante un programa es
declarar un identificador que se asocie al nombre externo del archivo, para permitir su
manipulación.
3. Apertura: La acción abrir un archivo es permitir al usuario localizar y acceder a los archivos,
creando un canal de comunicación entre el CPU y el dispositivo donde se encuentra el archivo,
haciendo de esta manera accesible los registros o contenido del archivo.
Si el archivo no se encuentra en el directorio donde está el programa, se debe colocar la
dirección completa en la jerarquía de directorios.

Sintaxis:
FILE *buff_ptr; /* Crear un archivo*/
Buff_ptr = open(“mydata.dat”,”r”); /* Abrir un archivo*/

Fclose(buff_ptr); /* Cerrar el archivo*/

El uso de archivos tipo Text como dispositivo de lectura es fundamental dentro de la

Programación de computadoras, es por eso que es importante conocer con profundidad como lee
un archivo de datos el lenguaje de programación con el que esta elaborado un programa, es decir,
cuales son las reglas que sigue la operación de lectura.

 Se pueden usar la siguientes funciones de librería: getchar y putc para introducir

datos desde el teclado y escribirlos en el archivo. La función putc es análoga a la
función putchar y getchar es análoga a la función getc.

 Se lee el texto carácter a carácter usando getchar( ) o getc( ) y después se escribe

en el archivo usando putchar( ) o putc( ).

20
___________________________________________________________________________
  Para leer cadenas de caracteres desde el teclado y escribir cadenas de caracteres
en el archivo se usan las funciones gets y puts ; mientras que para intercambian
cadenas con archivos fgets y fputs .

Tipos de archivos definidos

Tipo de archivo Significado

“r” Abre un archivo que existe de solo lectura
“w” Abre un nuevo archivo solo para escritura. Si un archivo del mismo nombre
existe, este será borrado y un nuevo archivo será creado
“a” Abre un archivo que existe para agregar al final del archivo. Si el archivo no
existe, un nuevo archivo será creado
“r +” Abre un nuevo archivo existente para lectura y escritura.
“w +” Abre un nuevo archivo para lectura/escritura. Si el archivo del mismo nombre
existe, este será borrado y un nuevo archivo será creado
“a+” Abre un archivo para lectura/escritura. Si el archivo del mismo nombre existe,
este será borrado y un nuevo archivo será creado

Manejar un fopen (apertura )no exitoso

Cuando se intenta abrir un archivo y el fopen resulta no exitoso debe darse un mensaje de error
apropiado al usuario. Se verifica si el valor retornado por la función fopen es un valor NULL
Ejemplo

#define NULL 0
main( )
{
FILE *fpt ;
if ( ( fpt = fopen(“mydata.dat” , “r +”) ) = = NULL )
printf(“Error abriendo el archivo \n”);
else
{
…
fclose(fpt);
}
}

Leer un archivo de texto y mostrarlo

21
___________________________________________________________________________
Se abre el archivo y se verifica si fue abierto exitosamente o no. Se lee desde el archivo hasta que
se encuentre el carácter EOF que indica fin del archivo.

Ejemplo

#include <stdio.h>
#include <conio.h>
#define NULL 0
main( )
{
FILE *mytext ;
char ch;

/*Abrir Archivo*/

if ( (mytext = fopen(“mydata.dat” , “r ”) ) = = NULL )

printf(“Error abriendo el archivo \n”);
else
{
ch=getc(mytext) ; /* para leer el carácter desde el archivo de texto */
while ( ch != EOF)
{
putc(ch) ; /* para mostrar el carácter leído*/
ch=getc(mytext) ;

}
fclose(mytext);
}
}

Escribir en un archivo de texto caracteres leidos del teclado

Ejemplo

#include <stdio.h>
#include <conio.h>
#include <ctype.h>
#define NULL 0
main( )
{

22
___________________________________________________________________________
 FILE *mytext ;
char ch;

/*Abrir Archivo*/

if ( (mytext = fopen(“mydata.dat” , “w”) ) = = NULL )

printf(“Error en creación del archivo \n”);
else
{
ch=getchar() ; /* para leer el carácter desde el teclado */
while ( ch != „\n‟)
{
ch=toupper(ch) ; /* Cambiar a mayuscula el character*/
putc(ch , mytext) ; /* para escribir el carácter leído en el archivo*/
ch=getchar() ;

}
fclose(mytext);
}
}

Muchos archivos de datos contienen estructuras de datos más complicadas, tales como registros,
tales archivos se pueden procesar usando las funciones fscanf y fprintf,
 fscanf: permite leer un dato con formato desde un archivo de datos asociado con
un archivo secuencial.
 fprintf: permite escribir un dato con formato desde un archivo de datos.

Archivos sin formato:

Es posible hacer fluir cualquier tipo de dato en C (arreglos, uniones o estructuras) a un archivo de
datos y recuperar los datos de vuelta a variables del mismo tipo de datos, usando las funciones
fread y fwrite las cuales son llamadas funciones de lectura/escritura sin formato
La funciones fread y fwrite requieren 4 argumentos:
1. un apuntador a bloque de datos
2. el tamaño del bloque de datos
3. el numero de bloques de datos que estan siendo manipulados en la tranferencia
4. un puntero de flujo

23
___________________________________________________________________________