Introducción al Lenguaje C (ANSI)

Un poco de Historia

 Fue inventado por Dennis Ritchie en un DEC-PDP-11 en

los Laboratorios BELL, basándose en el lenguaje B,
creado por Ken Thompson.
 En 1983 el Instituto de Estándares Americanos
estableció un estándar que definiera al lenguaje C,
conocido como ANSI C.
 Los principales compiladores de C llevan implementado
el estándar ANSI C.

Características del Lenguaje C

 Se cataloga como un lenguaje de nivel medio, puesto

que combina elementos de lenguajes de alto nivel
(Fortran, Pascal, Basic, etc.) con la funcionalidad
del lenguaje ensamblador.
 Permite el manejo de bits, bytes y direcciones de
memoria.
 Posee sólo 32 palabras clave, definidas por el comité
ANSI.

32 Palabras Reservadas

char void default return

int if break auto

float else continue extern

double do goto register

long while struct const

short for union static

signed switch enum volatile

unsigned case typedef sizeof

Autor: ycarruido 1 20/08/yyyy

 Elementos de un Programa en C ANSI

 Comentarios.
 Identificadores.
 Constantes.
 Variables.
 Operadores.
 Sentencias o instrucciones.
 Macros del pre-procesador.

Comentarios

Comentarios multi-línea
Comienzan con /* y terminan con */

No puede anidarse un comentario dentro de otro.

Comentarios de una sola línea (C++, Java, Delphi).

Comienzan al principio de la línea con //

Ejemplo:

//Esto es un comentario
/* Esto también es
un comentario */

Identificadores

Se utilizan para nombrar variables, funciones, etiquetas y

elementos definidos por el usuario.

Los primeros seis caracteres deben ser significativos

(distinguirse de otro similar) y máximo puede tener hasta
31 caracteres.

El primer carácter debe de ser una letra o subguión.

Posteriormente pueden ser letras, números, signos de

subrayado.

Existe diferencia entre mayúsculas y minúsculas.

No pueden emplearse palabras reservadas como
identificadores.

No pueden emplearse nombres de funciones que ya existan en

el programa o en la librería de funciones de C.

No puede llamarse main

Autor: ycarruido 2 20/08/yyyy

 Convenciones
Empezar los nombres de funciones y de variables con una
letra minúscula.

Las constantes escritas con #define van con mayúsculas como

#define PI 3.1416
Las palabras intermedias comienzan con mayúsculas.

sumaMatrices
Utilizar el subguión para separar palabras intermedias.

suma_Matrices
Emplear nombres cortos para optimizar. (i, j, k, cont)

Constantes
Constantes de carácter.

Ej. ‘a’, ‘0’, ‘\0x5’, ‘\0’, ‘\n’, ‘\t’, ‘$’, ’\\’, NULL

Constantes enteras.
Ej. 5, +5, -5, \05, \0x5, 5L, 5U, 5lu, etc.

Constantes reales.
Ej. 0.5f, 0.5, 5e-01f, 5.0e-01, (float)5, etc.

Constantes de texto (Cadenas o “Strings”)

“Esto es una cadena…”

#define
Se utiliza para asignar un identificador a una constante.
#define PI 3.1416
#define NCOLS 20

El pre-procesador de C, sustituye la ocurrencia de PI por

el valor 3.1416 en todo el programa antes de efectuar la
compilación, del mismo modo se sustituye NCOLS por 2.

Variables
Una variable es una localidad de memoria cuyo valor puede
ser cambiado durante la ejecución del programa.

Todas las variables deben de ser declaradas para se

utilizadas.

<tipo de dato> espacio(s) <identificador>;

Autor: ycarruido 3 20/08/yyyy

Ejemplo:
int a;
float area, radio, volumen;

const

Es un modificador de acceso que me permite asignar a una

variable un valor constante, es decir que una vez asignado
a dicha variable su valor no podrá ser modificado durante
el programa.

const <tipo dato> esp <identificador> = valor;

Ejemplo:
const int a=10;
const char pais[]=“MÉXICO”;
const char *nombre=“VLADIMIR”;

Operadores

Son palabras o símbolos que implican una acción sobre

ciertas variables. Pueden ser unarios (1 variable),
binarios (2 variables) o ternarios (3 variables).

 Operadores Aritméticos
 Operadores Relacionales
 Operadores Lógicos
 Operadores de Asignación
 Operadores de Dirección
 Operadores de Bits

Operadores Aritméticos
Operador Nombre Descripción
+ Suma 5+2 → 7
- Resta 5-2 → 3
* Multiplicación 5*2 → 10
/ División 5/2 → 2
% Módulo 5%2 → 1
(tipo de dato) “Cast” forzado (double)5 →
5.0

Autor: ycarruido 4 20/08/yyyy

 Operadores Relacionales
Operador Nombre Descripción

== Igual a if (a==‘s’)

!= Diferente de if (a!=null)

> Mayor que if (a>0.5)

< Menor que if (a<2l)

>= Mayor o igual que if (a>=2f)

<= Menor o igual que if (a<=3)

Operadores Lógicos
Operador Nombre Descripción

&& Y (AND) if ((a>3) && (a<9))

|| O (OR) if ((a==2) || (a==3))

! NEGADO (NOT) if (!(a==3)) es igual a

if (a!=3)

 Importante:
FALSO es igual a cero.
VERDADERO es diferente de cero

Autor: ycarruido 5 20/08/yyyy

 Operadores de Asignación

Operador Abreviado No Abreviado

= a=2; a=2;

++ n++; n=n+1;

-- n--; n=n-1;

+= n+=2; n=n+2;

-= n-=2; n=n-2;

*= n*=2; n=n*2;

/= n/=2; n=n/2;

%= n%=2; n=n%2;

Operadores de Bits
Operador Nombre Descripción

<< Corrimiento a la b=a>>2;

izquierda

>> Corrimiento a la b=a<<3;

derecha

& Y (AND) entre c=a&128;

bits
| O (OR) entre bits c=a|0x0a;

~ Complemento A1 c=~a;

^ O exclusivo (XOR) c=^a;

Autor: ycarruido 6 20/08/yyyy

 Operadores de Asignación
para bits

Operador Abreviado No Abreviado

<<= n<<=2; n=n<<2;

>>= n>>=2; n=n>>2;

&= n&=0x0a; n=n&0x0a;

|= n|=7; n=n|7;

^= n^=0x03; n=^0x03;

= n=0x7f; n=0x7f;

Operadores De Dirección
Operador Nombre Descripción
* Operador Me da el valor que
indirecció está almacenado en una
n dirección de memoria.
También sirve para
declarar una variable
apuntador.

& Operador Me da la dirección de

dirección memoria de una
variable.

Variables Apuntador
Sirven para almacenar una dirección de memoria.
Utilizan el operador & para obtener la dirección.
Se deben inicializar con NULL (equivale a cero).
Se declaran como:

<tipo de dato><*> espacio(s) <identificador>;

Ejemplo:
int *a=NULL;
int b=2,c=1;
a=&b; /*Guarda la direc. de b en a */
c=*a; /*c vale 2 */

Precedencia de Operadores

Autor: ycarruido 7 20/08/yyyy

 ( ) [ ] -> Alta prioridad
! ~ + - ++ -- & * Unarios
sizeof
* / % + - Aritméticos
<< >> Corrimiento de bits
< <= > >= == != Relacionales
& ^ | && || ?: Bits / Lógicos /
Condicional
= *= /= %= += -= &= Asignación
^= |= <<= >>=

, Evaluación

Sentencias (Instrucciones)

Una sentencia es una instrucción o expresión en C que

tiene una consecuencia. Pueden ser asignaciones,
operaciones, llamadas a funciones.

Todas las sentencias terminan con el signo de punto y

coma ;
Pueden ser simples o compuestas. Las compuestas van
entre llaves:

{
sentencia1;
sentencia2;
:
sentencian;
}

Sentencias de Selección.
if – else, switch – case, ?:

Sentencias de Repetición.
do – while, while, for

Sentencias de Salto.
return, break, continue

Estructura de un programa en C

Autor: ycarruido 8 20/08/yyyy

 I. Directivas del pre-procesador
#include y #define

II. Declaración de Prototipos

(Declaración de funciones)

III. Declaración de variables globales

IV. Funciones definidas por el usuario

V. Función Principal main( )

Ejemplos de un Programa en C

#include <stdio.h> // Librería: printf, getchar

main() // Función Principal

{
printf("Hola mundo!"); // Imprime en pantalla
getchar(); // Pausa: espera tecla ENTER
return 0; // Termina con éxito
}

-----------------------------------------------------------

#include <stdio.h>
#include <math.h>
#define VALOR 5.7

double modulo3D( double x, double y, double z );

double mod3; /* Variable global */

double modulo3D( double x, double y, double z ){

return(sqrt(x*x+y*y+z*z);
}

int main( void ){

int x, y, z;
x=y=z=VALOR;
mod3=modulo3D(x,y,z);
printf(“\nEl módulo es: %lf”,mod3);
return(0);
}

Autor: ycarruido 9 20/08/yyyy

-----------------------------------------------------------

#include <stdio.h>
#define FACTOR 2
int doble(int valor);
int main()
{
int indice = 2;
printf(“El doble de %d es %d\n”, indice, doble(indice));
return 0;
}
int doble(int valor)
{
return (valor * FACTOR);
}

Sentencia if-else

if (expresión)
sentencia;
else
sentencia;

Nota: una expresión en C es todo aquello que regresa un

valor. Como por ejemplo una condición lógica, operaciones
aritméticas, llamadas a funciones, una variable, una
constante (númérica, carácter, etc.).

if (expresión)
{
sentencia1;
sentencia2;
}
else
{
sentencia1;
sentencia2;
}

Sentencia switch-case

Autor: ycarruido 10 20/08/yyyy

switch(expresión)
{
case 1: sentencias;
break;
case 2: sentencias;
break;
:
case n: sentencias;
break;
default: sentencias_default;
break;
}

Arreglos Unidimensionales

Los arreglos unidimensionales son secuencias de valores del

mismo tipo que se almacenan en localidades contiguas de
memoria, según el orden del índice.
<tipo dato> esp <identificador>[tamaño];

Ejemplo:

int valores[10];
float datos[5]={1.3,2.8,4.89,0.0,5.7};
char pais[]=“MÉXICO”;
char *nombre=“VLADIMIR”;

Un arreglo se identifica por su nombre, pero para el

compilador este equivale a la dirección del primer elemento
del arreglo, es decir:

Ejemplo:
int num[50];

Para el compilador:
num es igual a &num[0]
/* La dirección del elemento 0 */

Los índices son necesarios para desplazarse a través del

arreglo. El primer elemento tiene el índice cero y el
último el índice (tamaño-1).
Se deben utilizar variables enteras y para agilizar el
acceso a memoria se pueden declarar con el modificador
register.
Ejemplo:

int register i, j, k;

Autor: ycarruido 11 20/08/yyyy

Para guardar o leer los elemento en un arreglo es muy
frecuente utilizar la sentencia for.

Ejemplo:

int register i;
int num[50];

/* Asigno al arreglo valores del 0 al

500 */
for (i=0; i<50; i++)
num[i]= i*10;

Para introducir los elemento en un arreglo con la función

scanf se recomienda utilizar una variable auxiliar dentro
de un ciclo for.

Ejemplo:

int register i;
double datos[100];
double temp;
for (i=0; i<100; i++)
{
scanf(“%lf”,&temp);
fflush(stdin); /* stdin=entrada estándar */
num[i]= temp;
}

Un arreglo puede tener N dimensiones, dependiendo de las

limitaciones de la memoria y su declaración es la
siguiente:

<tipo dato> esp <identificador>[dim1] [dim2]…[dimN];

 Ejemplo:
double cubo[3][3][3];

Arreglos de Caracteres

Una cadena o “String” se manipula en lenguaje C, mediante

arreglos de caracteres. Los arreglos de caracteres
terminan con el carácter nulo ‘\0’ que en realidad es el
valor cero.

Autor: ycarruido 12 20/08/yyyy

La única diferencia con los arreglos numéricos es que se
requiere un carácter adicional para indicar cuando el final
del arreglo.

Ejemplo:
char nombre[31]; /* Uso sólo 30 */

LA FUNCIÓN printf

Sintaxis:
printf ("formato", var1, var2, ..., varN)

"formato": serie de caracteres.

Secuencias especiales:

• %d: escribir un entero;

• %o: escribir en octal;
• %x: escribir en hexadecimal;
• %u: escribir en entero sin signo;
• %ld, %lo, %lx: lo mismo solo que para un long;
• %hd, %ho, %hx: lo mismo solo que para un short;
• %c: hace referencia a un caracter;
• %f, %lf: escribir un flotante o doble;
• %%: escribir caracter '%';

LA FUNCIÓN scanf

Sintaxis:
scanf("formato", &var1, &var2, ..., &varN)

"formato": debe contener una las secuencias siguientes:

• %d, %o, %x: se refiere a un decimal, octal o

hexadecimal;
• %ld, %lo, %lx: lo mismo solo que para un long;
• %hd, %ho, %hx: lo mismo solo que para un short;
• %c: hace referencia a un caracter;
• %f, %lf: referencia a un float o double

Autor: ycarruido 13 20/08/yyyy

 Ejercicios

Programa que convierte de metros a pies y pulgadas.

#include stdio.h

main(){
float metros,resul,pulg;
int resul2,pulg2;
clrscr();

printf("\nValor en metros: ");

scanf("%f",&metros);
resul=metros*(1/.3048);
resul2=resul;
pulg=resul-resul2;
pulg=pulg*12;
pulg2=pulg;
printf("El resultado es: %d pies %d
pulgadas",resul2,pulg2);

getch();
}

Programa que realiza las cuatro operaciones aritméticas

fundamentales

#include stdio.h
#include conio.h

void main(){
int prim,seg,resul;
char oper;

clrscr();

printf("\nPrimer numero: ");

scanf("%d",&prim);
printf("\nOperacion a realizar (+,-,*,/): ");
oper=getche();
printf("\nSegundo numero: ");
scanf("%d",&seg);

if(oper=='+')
resul=prim+seg;
if(oper=='-')
resul=prim-seg;
if(oper=='*')
resul=prim*seg;
if(oper=='/')

Autor: ycarruido 14 20/08/yyyy

resul=prim/seg;

printf("\nEl resultado de la operacion %d %c %d es

%d",prim,oper,seg,resul);
getch();
}

Programa que lee los tres lados de un triángulo y detecta

el tipo.
#include stdio.h

main(){

float uno,dos,tres;
clrscr();

printf("\nValor del primer lado: ");

scanf("%f",&uno);

printf("\nValor del segundo lado: ");

scanf("%f",&dos);

printf("\nValor del tercer lado: ");

scanf("%f",&tres);

if((uno==dos) && (dos==tres) && (uno==tres))

printf("\nEl triangulo es equilatero");

else if((uno!=dos) && (dos!=tres) && (uno!=tres))

printf("\nEl triangulo es escaleno");

else
printf("\nEl triangulo es isoceles");

getch();
}

Autor: ycarruido 15 20/08/yyyy

Programa que lee las edades de un grupo de alumnos y
encuentra el promedio.

#include stdio.h

main(){
int alumnos,edad,counter=1;
float promedio,sumaedad=0;
clrscr();

printf("\nNumero de alumnos: ");

scanf("%d",&alumnos);

while(1){

printf("\nEdad alumno %d: ",counter);

scanf("%d",&edad);

sumaedad=sumaedad+edad;
if(counter==alumnos){
break;
}
counter++;
}
promedio=sumaedad/counter;
printf("\nLa edad promedio de %d alumno(s) es %.1f
años",counter,promedio);

getch();
}

Autor: ycarruido 16 20/08/yyyy

Función que lee calificaciones (0-10) de alumnos y cuente
el número de alumnos reprobados, (calif<7) de un conjunto
de notas. La función recibe como parámetro el número de
notas a leer y deberá regresar el número de alumnos
reprobados. Crear un programa que llame a la función
anterior y que despliegue el número de alumnos reprobados.

#include stdio.h

int numreprob(int not);

void main(void){
int notas,reprobados;
clrscr();

printf("\nNumero de notas a leer: ");

scanf("%d",& notas);
reprobados=numreprob(notas);
printf("\nExiste un total de %d alumnos
reprobados",reprobados);
getch();
}

int numreprob(int not){

int c=1,calif,rep=0;

while(c<=not){

printf("\nCalificacion de la nota %d: ",c);

scanf("%d",&calif);

if(calif<7){
rep++;}

c++;
}
return(rep);
}

Autor: ycarruido 17 20/08/yyyy

Función que lee las matrículas (números enteros) y las
calificaciones (tipo char) de los alumnos de un grupo y las
almacene en dos arreglos unidimensionales. La función
deberá leer los datos hasta que se de una matrícula cero la
cual indica el fin de captura. La función regresa el número
de alumnos por el mecanismo de return. Después debe de
imprimir el contenido de los arreglos.

#include stdio.h

void despliega(int *mats,char *califs,int numcap);

int leedato(int *mats,char *califs,int maximo);

void main(void){
int max=30,matr[29],numalumn;
char calif[29];

clrscr();

numalumn=leedato(matr,calif,max);
printf("\nEl numero de alumnos capturados es %d",numalumn);
despliega(matr,calif,numalumn);

}
int leedato(int *mats,char *califs,int maximo){

int n=0;

printf("\n *** Introduce la matricula y su calificacion.

***");
printf("\n *** Para terminar dale un cero a la matricula.
***");

while(1){

if(n>=maximo){
printf("\nEl arreglo se encuentra lleno");
getch();
break;
}
printf("\n\nMatricula del alumno %d: ",n+1);
scanf("%d",mats);

if(*mats==0){
break;
}
printf("\nCalificacion del alumno %d: ",n+1);
scanf("%d",califs);

mats++;
califs++;

Autor: ycarruido 18 20/08/yyyy

n++;
}
return n;
}

void despliega(int *mats,char *califs,int numcap){

int i=1;

while(1){

if(i>numcap){
break;
}
printf("\nLa calificacion del alumno %d es
%d",*mats,*califs);
i++;
mats++;
califs++;
}
getch();
}

Programa que despliega una tabla de conversión de ºC a ºF y

viceversa. El programa debe tener una función que pregunte
el tipo de conversión deseada. El usuario tecleará "c" o
"C" si la conversión va a ser de ºC a ºF y "f" o "F" si la
conversión es de ºF a ºC, regresando el caracter leído por
medio de return. Otra función preguntará el rango de
valores de la tabla y el incremento, recibiendo como
parámetros las direcciones de las variables donde se
almacenarán esos datos. Otras dos funciones serán para
desplegar cada tipo de tabla de conversión.

#include stdio.h
#include ctype.h

void despliegaFC(int *ran1,int *ran2,int *inc);

void despliegaCF(int *ran1,int *ran2,int *inc);
void leeDatos(int *ran1,int *ran2,int *inc);
char tipoConv(void);

void main(void){

int rango1,rango2,incremento;
char tipo;
clrscr();
tipo=tipoConv();
leeDatos(&rango1,&rango2,&incremento);

Autor: ycarruido 19 20/08/yyyy

if(tipo=='C'){
despliegaCF(&rango1,&rango2,&incremento);
}
else{
despliegaFC(&rango1,&rango2,&incremento);
}
}
char tipoConv(void){
char caract;

printf(" TABLA DE CONVERSION DE GRADOS CENTIGRADOS A

GRADOS FARENHEIT");
printf("\n Y DE GRADOS FARENHEIT A GRADOS
CENTIGRADOS");
printf("\n\nPara convertir de Centigrados a Farenheit
oprime 'C'");
printf("\npara convertir de Farenheit a Centigrados oprime
'F'");

printf("\n\nTipo de Conversion (C o F): ");

caract=toupper(getch());

return caract;
}

void leeDatos(int *ran1,int *ran2,int *inc){

printf("\n\nValor inicial de la tabla: ");

scanf("%d",ran1);
printf("\nValor final de la tabla: ");
scanf("%d",ran2);

printf("\n\nIncremento de los valores de la tabla: ");

scanf("%d",inc);
}

void despliegaCF(int *ran1,int *ran2,int *inc){

int suma=*ran1,incremento=*inc,rango2=*ran2;
float conversion;

while(suma<=rango2){

conversion=(((suma)*9)/5)+32;
printf("\n%d §C ----------------------------- %.1f
§F",suma,conversion);

suma=suma+incremento;
}
getch();
}

Autor: ycarruido 20 20/08/yyyy

void despliegaFC(int *ran1,int *ran2,int *inc){

int suma=*ran1,incremento=*inc,rango2=*ran2;
int conversion;

while(suma<=rango2){

conversion=((suma-32)*5)/9;
printf("\n%d §F ----------------------------- %d
§C",suma,conversion);

suma=suma+incremento;
}
getch();
}

Ejemplos de cadenas. Función que realiza la misma operación

que la función atoi, que convierte una cadena en un entero.
La función regresa el entero representado por la cadena s
si se pudo convertir, en caso contrario regresa 0. Si la
función encuentra caracteres espacio o tabulación, los
salta. Si al empezar la secuencia de dígitos, ésta se
interrumpe, el programa termina.

#include stdio.h
#include ctype.h

int myatoi(char *s);

void main(void){

int n;
char cad[50];
clrscr();

printf("Introduce la cadena: ");

gets(cad);
n=myatoi(cad);
printf("\nEl entero extraido de la cadena fue %d",n);
getch();
}

int myatoi(char *s){

int signo=1,num=0;

while(1){
if(*s==' ' || *s=='\t'){
s++;
}
else break;

Autor: ycarruido 21 20/08/yyyy

}
if(*s=='+'){
s++;
}
else if(*s=='-'){
signo=-1;
s++;
}
while(1){
if(*s=='\0' || !isdigit(*s)){
break;
}
num=10*num+(*s-'0');
s++;
}
return signo*num;
}

Ejemplos de cadenas. Función que realiza la misma operación

que la función strlen. Calcula la longitud de la cadena S.
Regresa el número de caracteres en S sin contar el caracter
de fin de cadena.

#include stdio.h
#include ctype.h

int mystrlen(char *s);

void main(void){

int n;
char cad[50];
clrscr();

printf("Introduce la cadena: ");

gets(cad);
n=mystrlen(cad);
printf("\nEl numero de caracteres de la cadena s fue
%d",n);
getch();
}

int mystrlen(char *s){

int c=0;

while(1){
if(*s=='\0'){
break;
}
c++;

Autor: ycarruido 22 20/08/yyyy

s++;
}
return c;
}

Función que lee una serie de números de la línea de

comandos y ejecuta la instrucción proporcionada después del
último número de la serie. Si la instrucción es GUARDA, los
números son guardados en un arreglo de tipo entero. Si la
instrucción es LISTA, los numeros son desplegados como
cadenas.

#include stdio.h
#include ctype.h
#include string.h
#include stdlib.h

void main(int np, char *ps[]){

int arreglo[100],j,i;
clrscr();

if(strcmp(ps[np-1],"GUARDA")==0){
for(i=0,j=1;j<(np-1);i++,j++){
arreglo[i]=atoi(ps[j]);
printf("\n%d",arreglo[i]);
}
}

if(strcmp(ps[np-1],"LISTA")==0){
for(i=1;i<(np-1);i++){
puts(ps[i]);
}
}

Programa que recibe en la línea de comando un número

flotante, un caracter que represente una de las cuatro
operaciones fundamentales y un segundo número. El programa
deberá desplegar el resultado de la operación deseada.

#include stdio.h
#include stdlib.h
#include string.h

void main(int narg,char *sarg[]){

float op1,op2,resul;
int i=1;
clrscr();

Autor: ycarruido 23 20/08/yyyy

printf("PROGRAMA QUE CALCULA UNA OPERACION ARITMETICA
SIMPLE ENTRE DOS OPERANDOS");
printf("\n\nLa sintaxis es: Calcula operando operador
operando");
printf("\n");
while(i<=narg){
printf("%s",sarg[i]);
i++;
}

op1=atof(sarg[1]);
op2=atof(sarg[3]);

if(strcmp(sarg[2],"+")==0)
resul=op1+op2;
else if(sarg[2][0]=='-')
resul=op1-op2;
else if(strcmp(sarg[2],"*")==0)
resul=op1*op2;
else if(sarg[2][0]=='/')
resul=op1/op2;
else{
printf("\nOperador invalido: '%s'",sarg[2]);
return;
}
printf("\n\nEl resultado es %.1f",resul);
getch();

Editor de textos con arreglo de cadenas.

#include string.h

#include stdio.h

#include ctype.h

void inserta(char t[][50],int *ll,int act,int max);

void modif_actual(int *act,int ll);
void reemplaza_linea(char t[][50],int ll,int *act);
void lista(char t[][50],int *ll);
void agrega_linea(char t[][50],int *ll,int max,int *act);

void main(void){

char txt[30][50],opcion;
int llenas=0,max=30,actual;

while(1){

Autor: ycarruido 24 20/08/yyyy

clrscr();
printf(" EDITOR DE TEXTO");
printf("\n SELECCIONA LA PRIMERA LETRA DE LA
OPCION DESEADA");
printf("\n\nAgregar Salir Lista Reemplaza Inserta
Opcion: ");

opcion=toupper(getch());
if(opcion=='S')
break;
if(opcion=='A')
agrega_linea(txt,&llenas,max,&actual);
if(opcion=='L')
lista(txt,&llenas);
if(opcion=='R')
reemplaza_linea(txt,llenas,&actual);
if(opcion=='I')
inserta(txt,&llenas,actual,max);
}
}

/**********************************************************
****************/
void agrega_linea(char t[][50],int *ll,int max,int *act){
if(*ll==max){
printf("\n\nMemoria insuficiente...");
return;
}
printf("\n\n>");
fflush(stdin);
gets(t[*ll]);
*ll=*ll+1;
*act=*ll;
}

/**********************************************************
****************/

void lista(char t[][50],int *ll){

int i=0;
printf("\n\n");

while(i<*ll){

puts(t[i]);
i++;
}
getch();
}

Autor: ycarruido 25 20/08/yyyy

/**********************************************************
****************/

void modif_actual(int *act,int ll){

int v;

printf("\n\nIndica el numero de la linea a posicionar: ");

scanf("%d",&v);

if(v<=ll && v!=0){

*act=v;
}
else{
*act=-1;
}
}

/**********************************************************
****************/

void reemplaza_linea(char t[][50],int ll,int *act){

if(ll==0){
printf("\n\nNo existe informacion a reemplazar");
getch();
return;
}
modif_actual(act,ll);
if(*act==-1){
printf("\n\nLa linea seleccionada no existe...");
getch();
}

else{

printf("\n\nIntroduce la nueva linea: ");

fflush(stdin);
gets(t[*act-1]);
}
}

/**********************************************************
***************/

void inserta(char t[][50],int *ll,int act,int max){

int j;
if(*ll==max){
printf("\n\nMemoria insuficiente...");
getch();
return;
}

Autor: ycarruido 26 20/08/yyyy

modif_actual(&act,*ll);

if(act==-1){
printf("\n\nLa linea seleccionada no existe...");
getch();
}
else{

j=*ll-1;

while(j>=act-1){
strcpy(t[j+1],t[j]);
j--;
}
printf("\n\nInserta la nueva linea: ");
fflush(stdin);
gets(t[act-1]);
(*ll)++;
}
}

Directorio telefónico con manejo de archivos.

#include stdio.h
#include conio.h
#include ctype.h
#include string.h
#include stdlib.h

struct DIREC{
char nombre[35];
char tele[20];
} ;

FILE *pack(FILE *a);

void ordena(FILE *a);
void consulta2(FILE *a);
long busca_Clave2(FILE *a,char buscado[]);
void lee(FILE *a);
void imprime(FILE *a);

void main(){

char opcion;
FILE *archivo;
archivo=fopen("TELE.DAT","rb+"); /* usar opción "wb+"
para crear el archivo .DAT y después cambiar a "rb+" */

while(1){
clrscr();

Autor: ycarruido 27 20/08/yyyy

 textattr(6+5*5);
clrscr();
textcolor(YELLOW);
cprintf(" DIRECTORIO
TELEFONICO");
printf("\n\n");
cprintf(" N");
printf("uevo");
textcolor(YELLOW);
cprintf(" L");
printf("ista");
textcolor(YELLOW);
cprintf(" B");
printf("aja");
textcolor(YELLOW);
cprintf(" C");
printf("onsulta");
textcolor(YELLOW);
cprintf(" O");
printf("rdena");
textcolor(YELLOW);
cprintf(" S");
printf("alir");

gotoxy(1,25);
printf(" *** PRESIONE LA LETRA RESALTADA PARA
ESCOGER LA OPCION ***");
gotoxy(1,4);
opcion=toupper(getch());

if(opcion=='S')
break;
switch(opcion){
case 'N':{
lee(archivo);
break;
}
case 'L':{
imprime(archivo);
break;
}
case 'B':{
pack(archivo);
break;
}
case 'C':{
consulta2(archivo);
break;
}
case 'O':{
ordena(archivo);

Autor: ycarruido 28 20/08/yyyy

 break;
}
}
}
clrscr();
fclose(archivo);
normvideo();
clrscr();
}

/**********************************************************
***********/

void imprime(FILE *a){

int r,y=0,c=1;
struct DIREC reactivo;
clrscr();
textcolor(YELLOW);
cprintf("NOMBRE
TELEFONO");
normvideo();
rewind(a);
while(1){
r=fread(&reactivo,sizeof(struct DIREC),1,a);
if(r==0)
break;

if((c%2)!=0){
textattr(6+5*5);
/* textcolor(LIGHTGRAY);*/
printf("\n");
cprintf("%d.- %-30s
%16s",c,reactivo.nombre,reactivo.tele);
normvideo();
}
else{
textattr(6+5*4);
/* textcolor(WHITE);*/
printf("\n");
cprintf("%d.- %-30s
%16s",c,reactivo.nombre,reactivo.tele);
normvideo();
}

if(y==23){
getch();
y=0;
}
y++;
c++;
}

Autor: ycarruido 29 20/08/yyyy

 getch();
}

/**********************************************************
***********/

void lee(FILE *a){

struct DIREC reactivo;
printf("\n\n");

fflush(stdin);
printf("Nombre : ");strupr(gets(reactivo.nombre));
if(strlen(reactivo.nombre)<30){

if(busca_Clave2(a,reactivo.nombre)==0){
printf("Tel‚fono : ");gets(reactivo.tele);
fseek(a,0,SEEK_END);
fwrite(&reactivo,sizeof(struct DIREC),1,a);
}
else{
printf("\n\nYa existen esos datos!!!");
getch();
}
}
else{
printf("\n\nM ximo 25 letras por
nombre...");
printf("\n\nEl programa puede da¤arse si
repite este error!!!");
getch();
}
}

/**********************************************************
***********/

long busca_Clave2(FILE *a,char buscado[]){

long p;
struct DIREC r;
rewind(a);
while(1){
if(fread(&r,sizeof(struct DIREC),1,a)==0)
break;
if(strcmp(r.nombre,buscado)==0){
p=ftell(a)/sizeof(struct DIREC);
return(p);
}
}
return 0;
}

Autor: ycarruido 30 20/08/yyyy

/**********************************************************
***********/

void consulta2(FILE *a){

char nombre[30];
long p;
struct DIREC r;
printf("\n\nDame el nombre a buscar: ");
strupr(gets(nombre));

p=busca_Clave2(a,nombre);

if(p!=0){

fseek(a,(p-1)*sizeof(struct DIREC),SEEK_SET);
fread(&r,sizeof(struct DIREC),1,a);
printf("\n\n\n");
textcolor(LIGHTGRAY);
cprintf("NOMBRE
TELEFONO");
normvideo();
printf("\n%-20s %30s",r.nombre,r.tele);
getch();

}
else{
printf("\n\nLa informaci¢n solicitada no existe
...");
getch();
}
}

/**********************************************************
***********/

void ordena(FILE *a){

int i=0,j=0,s,t;
struct DIREC r;
struct DIREC temp[100];
struct DIREC temporal;
while(1){
fseek(a,i*sizeof(struct DIREC),SEEK_SET);
if(fread(&r,sizeof(struct DIREC),1,a)==0)
break;
temp[j]=r;
i++;
j++;
}
for(s=0;s0){
temporal=temp[s];

Autor: ycarruido 31 20/08/yyyy

 temp[s]=temp[t];
temp[t]=temporal;
}

s=0;
i=0;
while(1){
if(s>=j)
break;
r=temp[s];
fseek(a,i*sizeof(struct
DIREC),SEEK_SET);
fwrite(&r,sizeof(struct DIREC),1,a);
s++;
i++;
}
printf("\n\nSus archivos han sido
ordenados alfab‚ticamente...");
getch();

/**********************************************************
***********/

FILE *pack(FILE *a){

int i=0;
long p;
char clave[30];
struct DIREC r;
FILE *t;
t=fopen("TMP.DAT","wb");

printf("\n\nDame el nombre a dar de baja: ");

strupr(gets(clave));
p=busca_Clave2(a,clave);

if(p!=0){
while(1){
fseek(a,i*sizeof(struct DIREC),SEEK_SET);
if(fread(&r,sizeof(struct DIREC),1,a)==0)
break;
if(strcmp(r.nombre,clave)!=0){
fseek(a,i*sizeof(struct DIREC),SEEK_SET);
fwrite(&r,sizeof(struct DIREC),1,t);
}
i++;
}
fclose(t);
fclose(a);

Autor: ycarruido 32 20/08/yyyy

 remove("TELE.DAT");
rename("TMP.DAT","TELE.DAT");
t=fopen("TELE.DAT","rb+");
printf("\n\nLa informaci¢n solicitada ha sido dada de
baja...");
getch();
return(t);
}
else{
printf("\n\nNo existe el nombre...");
getch();
}
return 0;
}

Basicos

Ejemplo salida de datos

#include <stdio.h>

int main( )
{
int i,j;

i=3;
j=4;
printf("Hola el mundo \n");
printf("Valor i:%d \nValor j:%d \n",i,j);
}

/* Salida en pantalla:

Hola el mundo
Valor i:3
Valor j:4 */

Ejercicios salida datos

1. Del programa anterior elimine los \n que aparecen y

vea que sucede
2. Del programa anterior modifique la linea
printf("Valor i:\%d \nValor j:\n%d",i,j); por
printf("Valor i:\%d \nValor j:\n%d",i); y vea que
sucede

Autor: ycarruido 33 20/08/yyyy

Ejemplo captura de datos

/* Programa de ejemplo de captura de un entero corto, un

entero y un flotante */

#include <stdio.h>

int main( )
{
short s;
int l;
float f;

printf("Introduzca un entero corto, un entero y un

flotante separados por un espacio: \n")
scanf("%hd %d %f",&s,&l,&f);

/* Después de haber introducido -123 999 y 99.0044 <RET>

las variables s,l, y f tienen los valores -123 999 y
99.0044 */

Ejercicios captura de datos

1. Del programa anterior borre todos los caracteres "&"

de la función scanf( ) y vea que sucede.
2. El programa anterior no despliega lo captura,
modifique el programa de tal forma que despliegue lo
capturado.
3. Cambie la línea scanf("%hd %d %f",&s,&l,&f); por
scanf("%hd,%d,%f",&s,&l,&f); y vea lo que sucede
4.

Prueba localidad variables

#include <stdio.h>

int global;

int main ( )
{
int l1,l2;

printf("Introduzca tres valores enteros separados

por un espacio:\n");
scanf("%d%d%d",&global,&l1,&l2);

Autor: ycarruido 34 20/08/yyyy

 printf("Desplegado 1, valor de global,l1,l2:);
printf("%d,%d,%d\n",global,l1,l2);

{
int global,l1;
printf("Introduzca tres valores enteros separados
por un espacio:\n");
scanf("%d%d%d",&global,&l1,&l2);
printf("Desplegado 2, valor de global,l1,l2:");
printf("%d,%d,%d\n",global,l1,l2);
}

printf("Desplegado 3, valor de global,l1,l2:");

printf("%d,%d,%d\n",global,l1,l2);
}

Ejemplo operaciones aritméticas enteras

/* Cálculo hora llegada de un vuelo */

#include <stdio.h>

int main()
{

int hora, mins, segs;

int tmpvol;

printf(''De hora salida vuelo (hh mm ss):'');

scanf(''%d%d%d'',&hora,&mins,&segs);
printf(''Tiempo vuelo (en segundos):'');
scanf(''%d'',&tmpvol);
segs = segs + tmpvol;
mins = mins + segs / 60;
segs = segs % 60;
hora = hora + mins / 60;
mins = mins % 60;
hora = hora % 24;
printf(''Hora estimada llegada:'');
printf(''%d hrs %d mins %d segs
\n'',hora,mins,segs);
}

Autor: ycarruido 35 20/08/yyyy

/* Cálculo del área de un triángulo y círculo */

#include <stdio.h>

int main()
{

float base, altura;

float area;
float radio, pi;

printf(''Valor de la base y altura:'');

scanf(''%f%f'',&base,&altura);
area = (base * altura)/2;
printf(''El 'area del triangulo es: %f \n'',area);
printf(''De el valor del radio:'');
scanf(''%f'',&radio);
pi = 3.151416;
area = pi * radio * radio;
printf(''El 'area del circulo es: %f \n'',area);
}

Ejemplo operador condicional

/* Determina si un número es menor mayor o igual a cero */

#include <stdio.h>

int main()
{
int x;

printf(''De el valor de x:'');

scanf(%d'',&x);
if (x <= 0) {
if (x== 0)
printf(''N'umero igual a cero
\n'');
else
printf(''Número MAYOR que cero
\n'');
}
else
printf(''Numero menor que cero \n'');
}

Autor: ycarruido 36 20/08/yyyy

/* Determina el número más grande de entre tres */

#include <stdio.h>

int main()

{
int i,j,k,mayor;

printf(''De los valores i j k : '');

scanf(''%d%d%d'',&i,&j,&k);
if (i > j)
mayor = j;
else
mayor = i;

if (mayor < k)
mayor = k;

printf(''El mas grande de (%d,%d,%d) es: %d

\n'',i,j,k,mayor)
}

Ejercicios operador condicional

1. Escribir un programa que permita jugar a doble o nada:

El jugador apuesta una cantidad y tira una moneda. Si
sale cara obtiene el doble de la cantidad apostada. Si
sale cruz la pierde todo.
2. Escribir un programa que lea tres valores enteros y
muestre por pantalla el máximo y el mínimo de ellos.
3. Escribir un programa que, pida la fecha de nacimiento
(dia y numero de mes) de una persona e imprima por
pantalla su signo zodiacal

Autor: ycarruido 37 20/08/yyyy

 ESTRUCTURA GENERAL DEL switch

Estructura general del switch

switch (var) {

case c1:
case c2: Bloque 1
Bloque 2
break;
case c3:
case c4: Bloque 3
Bloque 4
case c5: Bloque 5
case c6:
case c7:
case c8: Bloque 6
break;
default: Bloque 7
}
Bloque 8

Opcion default no obligatoria.

Ejemplo uso switch: un menu

#include <stdio.h>

int main()
{
int opcion;

printf(''1> Mexico \n'');

printf(''2> Francia \n'');
printf(''3> Italia \n'');
printf(''4> Inglaterra \n'');
printf(''5> Barcelona \n'');
printf(''Opcion: '');
scanf(''%d'',&opcion);
switch (opcion) {
case 1: printf(''Bueno \n'');
break;
case 2: printf(''Allo \n'');
break;
case 3: printf(''Pronto \n'');
break;
case 4: printf(''Hello \n'');
break;
case 5: printf(''Digi \n'');

Autor: ycarruido 38 20/08/yyyy

break;
}
}

#include <stdio.h>

int main()

{
char letra;
printf(''De una letra: '');
scanf(''%c'',&letra);
switch (letra) {
case 'a':
case 'e':
case 'i':
case 'o':
case 'u': printf(''Es una vocal minuscula\n'');
break;
case 'A':
case 'E':
case 'I':
case 'O':
case 'U': printf(''Es una vocal MAYUSCULA\n'');
break;

default: if( (letra>'a') && (letra<'z'))

printf(''Consonante minuscula \n'');
else
printf(''Consonante MAYUSCULA \n'');
}
}
Ejercicios

1. Escribir un programa que pida la nota de un examen (un

nº real entre 0 y 10) e imprima en pantalla
“Suspendido”, si la nota es menor que 5, “Aprobado” si
está entre 5 inclusive y 7 sin incluir, “Notable” si
está entre 7 inclusive y 9 sin incluir,
“Sobresaliente” si está entre 9 inclusive y 10 sin
incluir y “Matrícula de honor” si la nota es igual a
1.
2. Escribir un programa que, dado el número del mes, y
el año (hay que considerar si el año es bisiesto)
saque por pantalla el número de dias del mes.

Autor: ycarruido 39 20/08/yyyy

Autor: ycarruido 40 20/08/yyyy