Академический Документы
Профессиональный Документы
Культура Документы
Curso de Lenguaje C
IDENTIFICADORES
MODIFICADORES DE TIPO
DECLARACION DE VARIABLES
Ejemplo:
int a, b; float f, g; double d;
char ch; long l, k; signed char ca;
EJEMPLOS DE CONSTANTES
char 'a' '\n' '9'
int 12000 -354
long 1236377 -6775774
unsigned 292999 0
float o double 12432.89 -0.89 1.0E100
Ejemplo:
int h; int oc;
h=0xFF /* 255 en decimal */
oc=011 /* 9 en decimal */
CONSTANTES DE CADENA
\b Retroceso
\a Alarma
\f Alimentación de página
\n Nueva linea
\r Retorno de carro
\t Tabulador horizontal
\" Doble comilla
\' Comilla simple
\\ Barra invertida
\v Tabulador vertical (Impresora)
\x Constante hexadecimal
\N Constante octal donde N es una
constante octal
Ejemplo: ch = '\n'
INICIALIZACION DE VARIABLES
CONSTANTES SIMBOLICAS
Ejemplo:
#define PI 3.1416
#define ERR_1 printf("Error 26\n")
OPERADORES
Operadores aritméticos
+ Suma
- Resta
* Multiplicación
/ División
% Modulo
++ Incremento
-- decremento
() Agrupar
Precedencia
++ -- ()
* / %
+ -
Operadores de relación :
> >= < <=
== !=
Operadores lógicos :
&& || !
and or not
1 && !0 || 1 /* resulta 1 */
1 && !(0 || 1) /* resulta 0 */
El operador sizeof() : Devuelve el tamaño de un tipo de dato o
de una variable en bytes.
EXPRESIONES
Conversión de tipo
char y short ............. int
float ................. double
Ejemplo:
char ch;
int i;
float f;
double d;
r = (ch / i) + (f * d) - (f + i);
| | | | | |
int double float
| | |
| / /
\ / /
\ / /
double
|
double
Ejemplo:
int x; float r;
x = 35;
r = (float) x / 2; /* resulta 17.5 */
r = (float) (x / 2) /* resulta 17.0 */
Formato :
variable op= exp;
Ejemplo :
x *= y + 1; a -= 4;
y es equivalente a :
x = x * (y + 1); a = a - 4;
Formato:
printf("cadena_de_ctrl", lista_de_argumentos);
Ejemplo:
printf("Datos %c %d %s\n", 'a', 100, "caracteres");
/*****
*
* suma de valores
*
*****/
main()
{
int a, b;
a = 10; b = 40;
Ejemplo:
printf("%05d", 48); /* visualiza :00048 */
printf("%5d", 48); /* visualiza : 48 */
Ejemplo:
printf("%10.2f", 123.1283);
/* visualiza : 123.12 */
Nota : Tenga en cuenta que el valor que aparece antes del punto
especifica el ancho total de campo incluyendo las posiciones decimales
y el punto decimal. Lo anterior se podría leer como campo de tamaño
diez de los cuales siete se tomarán para la parte entera, dos para
decimales y uno para el punto.
Ejemplo:
printf("%5.7s", "José perez");
Ejercicio:
/*****
*
* formateo de la salida
*
*****/
Ejemplo :
printf("%ld", p); /* visuliza un long int */
Formato :
scanf("cadena_de_ctrl", lista_de_argumentos);
1. Especificadores de formato
2. Caracteres de espacio en blanco
3. Caracteres de no espacio en blanco
Ejemplo:
scanf("%d %f %s", &i, &f, &str);
/* la entrada podria ser: 20 3.5 maria */
Ejemplo:
scanf("%d,%d", &x, &y);
/* la entrada podria ser : 20,50 */
Ejemplo:
scanf("%d%*c%d", &x, &y);
/* la entrada podria ser :20/40 */
/* x = 20 y = 40 */
Ejemplo :
scanf("20s", str); /* lee máximo 20 caracteres */
Si la entrada tiene más de 20 caracteres, el siguiente scanf() o
cualquier llamada a una posterior entrada comenzará donde quedó la
anterior.
Ejemplo:
scanf("%2d %f %*d %2s", &i, &f, &nom);
/* al leer :5674 139 49abc74 quedará:
i = 56 f = 74.00 saltará 139 nom = "49" */
EJERCICIOS DE APLICACION
Programas ejemplo
/*****
*
* lee un valor y devuelve su cuadrado
*
*****/
main()
{
int a;
/*****
*
* conversion de grados celcius a fahrenheit
* C = (5/9)(f-32)
*
*****/
main()
{
float fahr, celcius;
#include nombre_de_archivo_cabecera
Ejemplo:
#include "stdio.h"
#include <stdio.h>
Ejemplo :
#include "c:\cabercera\stdio.h"
#include <c:\include\ctype.h>
SENTENCIAS DE CONTROL
La sentencia if() / ?:
Formato:
if(<expL>) sentencia;
[else sentencia; ]
Ejemplo:
if(<expL>) {
sentencia_1;
sentencia_2;
.
.
sentencia_n;
}
----------------------------
if(<expL>)
sentencia;
else {
sentencia_1;
sentencia_2;
.
.
sentencia_n;
}
-----------------------------
if(<expL>) {
sentencia_1;
.
.
sentencia_n;
}
else {
sentencia_1;
.
.
sentencia_n;
?: Formato:
(<expL>) ? <exp1> : <exp2>
<expL> :Es la condición a ser evaluada.
<exp1> :Se ejecuta si <expL> es verdadera.
<exp2> :Se ejecuta si <expL> es falsa.
#include "stdio.h"
main() /* convierte letra a tipo contrario */
{
char ch;
if(<expL>)
sentencia;
else if(<expL>)
sentencia;
else if(<expL>)
sentencia;
.
.
.
else
sentencia;
LA EXPRESION CONDICIONAL
if(co)
sentencia;
else
sentencia;
Ejemplo:
main()
{
int i
printf("Numero entero :"); scanf("%d", &i);
if(i)
printf("%d\n", i/2);
else
printf("No puedo dividir por cero\n");
LA SENTENCIA switch()
case constante_2:
secuencia_de_sentencias
break;
.
.
.
default :
secuencia_de_sentencias
}
Ejemplo:
BUCLES
EL BUCLE for()
Formato:
for(inicialización; <expL>; variación) sentencia;
main()
{
int i;
main()
{
int x;
main()
{
int x, y;
#include <stdio.h>
main()
{
char ch;
for(;;) {
printf(Digita un caracter :"); ch=getche();
if(ch=='$') break; /* rompe el ciclo */
}
}
main()
{
int x;
for(x=0; x != 100;) {
printf("Introduce un número 100 para salir");
scanf("%d",&x);
#include <stdio.h>
#include <ctype.h>
main()
{
int i, j, resp;
char done = ' ';
Ejemplo:
for(t=0; t<NMAX; ++t)
;
EL BUCLE while()
Ejemplo:
#define FIN '*'
#include <stdio.h>
main()
{
char ch = '\0';
while(ch != FIN) ch=getche();
}
#include "stdio.h"
while((c=getchar()) != EOF)
putchar(c);
}
#include "stdio.h"
main()
{
int c, nc=1;
} else
putchar(c);
}
}
EL BUCLE do/while()
Formato :
do {
sentencia;
.
.
.
} while(<expL>);
Ejemplo:
#include <stdio.h>
main()
{
char opc;
do {
opc=toupper(getche());
LA SENTENCIA continue
Ejemplo:
main() /* imprime nros. pares */
{
int x;
ETIQUETAS y goto
Una etiqueta debe estar en la misma función donde está el goto que la
utiliza.
Ejemplo:
loop:
x++;
if (x<100) goto loop;
ARRAYS Y CADENAS
Arrays unidimensionales:
Los índices de los arrays deben arrancar desde cero (0) yá que el
primer elemento comienza en esa posición.
Ejemplo: #define N 10
main()
{
int i, tem, j=N-1, a[N];
CADENAS O STRING
Ejemplo:
char nombre[30];
/* declara la variable nombre de 30 caracteres */
Ejemplo:
#define TM 5
#include "stdio.h"
main()
{
char s[TM];
puts("Escribe hola");
gets(s);
printf("%s\n", s);
}
main()
{
char string[80];
main()
{
char s[80];
int i;
Ejemplo:
#include "string.h"
main()
{
char a[80];
Ejemplo:
#include <string.h>
#include <stdio.h>
main()
{
char a1[80], a2[40];
strcpy(a1,"cartagena");
strcpy(a2," colombia");
strcat(a1, a2);
Ejemplo:
#include <string.h>
#include <stdio.h>
main()
{
char s[80];
Formato : strlen(cadena);
Ejemplo :
#include <string.h>
#include <stdio.h>
main()
{
int s[80];
strcpy(s, "Hello...");
printf("%d\n", strlen(s));
getche();
}
strchr()
strstr() :Ver su funcionalidad luego de haber tratado el tema de
punteros.
FUNCIONES DE CARACTER
Formato :isalnum(ch);
Ejemplo :
#include <stdio.h>
#include <ctype.h>
main()
{
char ch;
for(;;) {
ch=getche();
if(ch==' ')
break;
if(isalnum(ch)) printf("%c\n",ch);
}
}
Formato : iscntrl(ch);
main()
{
char ch;
for(;;) {
ch=getche();
if(ch==' ')
break;
if(iscntrl(ch)) printf("%c\n");
}
}
Formato : isdigit(ch);
Ejemplo :
#include <ctype.h>
main()
{
char ch;
for(;;) {
ch=getche();
if(ch==' ')
break;
if(isdigit(ch))
printf("%c\n", ch);
}
}
Formato : isgraph(ch);
Formato : islower(ch);
Formato : isupper(ch);
Formato : isprint(ch);
Formato : ispunt(ch);
Formato : isspace(ch);
Ejemplo :
#include <ctype.h>
#include <stdio.h>
#define NMAX 80
main()
{
Formato : isxdigit(ch);
ARRAYS BIDIMENSIONALES
0 1 2 3
Ejemplo : 2 * 10 * 2 = 40 bytes
Ejemplo :
#define NMAX 4
main()
{
int a[NMAX][NMAX], i, x;
Ejemplo : gets(lineas[0]);
INICIALIZACION DE ARRAYS
Formato :
Ejemplos :
Ejemplo:
main()
{
auto int a, b;
auto char ch;
auto float f= 4.5;
}
Ejemplo
main()
{
cuenta();
cuenta();
cuenta();
}
cuenta()
{
static int x=0;
printf("%d\n",x);
x++;
}
Ejemplo:
int a=4;
main()
{
printf("%d\n",a);
func();
}
func()
{
printf("%d\n",a);
}
extern int x;
main()
Ejemplo:
Ejemplo:
int i;
main()
{
int i;
.
.
.
}
otra()
{
auto int i;
}
Ejemplo:
main()
{
register int a,b;
.
.
.
}
main()
{
register int i_rápida;
.
.
.
}
MODIFICADORES DE ACCESO
Ejemplo:
FUNCIONES
LA SENTENCIA return
return puede terminar una función sin retornar ningún valor. En caso
de que la función devuelva algún valor, la expresión o el valor debe
ser colocado al frente de return.
Ejemplo:
main()
{
int a = 10, b = 20;
suma(x, y)
int x, y;
{
return(x + y);
}
Ejemplo :
main()
{
int a = 10, b = 20;
max(x, y)
int x, y;
{
return((x > y) ? x : y);
}
Ejemplo:
main()
{
imprime_cadena(x);
}
imprime_cadena(n);
int n;
{
int i;
Ejemplo:
main()
{
printf("%d\n", power(4, 2));
}
power(n, x)
int n, x;
{
int p;
/* funcion xtolower() */
xtolower(s)
char ch;
{
if(s > 65 && s < 91)
s += 32;
return(s);
}
Una variable puede ser conocida solo dentro de una función especifíca
lo cuál no debe crear conflictos con otras variables que tienen el
mismo nombre dentro de otras funciones.
FUNCIONES Y ARRAYS
/*****
*
* ejemplo de una clasificacion de array por metodo de shell
* y busqueda binaria.
*
*****/
#define SALIDA 0
#define MAXNUM 10
} /* end of main() */
shell(v, n)
int v[], n;
{
int gap, i, j, tem;
/*****
*
* udf binary(x, v, n)
* busqueda binaria
* busca a x en v[0]...v[n-1]
*
*****/
binary(x, v, n)
int x, v[], n;
{
int low, high, mid;
low = 0;
high = n - 1;
while(low <= high) {
mid = (low + high) / 2;
if(x < v[mid])
high = mid - 1;
else if(x > v[mid])
low = mid + 1;
else
return(mid); /* lo encontro */
}
return(-1); /* x no fue hallado */
n = 0;
for(i = 0; s[i] >= '0' && s[i] <= '9'; ++i)
n = 10 * n + s[i] - '0';
return(n);
}
Formato:
tipo nombre_de_función();
Ejemplo:
float suma(x, y)
float x, y;
{
return(x + y);
}
Una función se declara de tipo void para evitar que la misma devuelva
algún valor.
Ejemplo:
void imprime_col(s)
char s[];
{
int i;
for(i=0; s[i]; ++i)
PUNTEROS
Ejemplo:
MEMORIA
Formato:
tipo *nombre_de_variable;
Ejemplo:
int *m;
char *ch;
OPERADORES DE PUNTERO
*, &
Ejemplo:
/* sumando a un puntero */
main()
{
int arr1[5], *p1, i;
float arr2[5], *p2;
esto se debe a que cada puntero int es de dos bytes y cada puntero
float es de cuatro bytes y al sumarle una unidad, simplemente
direcciona la posición de comienzo del próximo elemento de su tipo en
la memoria.
ARITMETICA DE PUNTEROS
Ejemplo:
/*****
*
* funcion swap()
* intercambia valores de variables
*
tem = *x;
*x = *y;
*y = tem;
}
APUNTADORES Y ARRAYS
Ejemplo:
#define NMAX 10
display(s)
int s[];
{
int j;
void _areverse();
#include "stdio.h"
#define NMAX 4
main()
{
int a[NMAX], i;
_areverse(a);
printf("........%d\n",sizeof(a));
getche();
}
void _areverse(x)
int x[];
{
int j = NMAX / 2, l = NMAX - 1, t, k;
printf("------ %d\n",sizeof(x));
for(k=0; k<j; k++, l--) {
t=x[k];
x[k]=x[l];
x[l]=t;
}
}
int media();
main()
{
int arr[5], x;
int media(a_vlrs, n)
int *a_vlrs, n;
{
int i;
int suma;
if(n > 0) {
for(i = 0, suma = 0; i < n; ++i)
suma += *(a_vlrs + i);
return((int) (suma / n));
}
else {
printf("Elementos no hallados\n");
return(0);
}
}
ARREGLOS DE APUNTADORES
char *lineas[MAX_LINE];
Ejemplo :
char *month_name();
/*****
*
* month_name(n)
* devuelve el nombre del mes
*
*****/
char *month_name(n)
int n;
{
static char *name[] = {
"mes fuera de rango",
"Enero",
"Febrero",
"Marzo",
"Abril",
"Mayo",
"Junio",
"Julio",
"Agosto",
"Septiembre",
"Octubre",
"Noviembre",
"Diciembre"
};
return((n < 1 || n > 12) ? name[0] : name[n]);
}
"Hola mundo..."
Ejemplo :
char *mensaje;
Luego es posible hacer una asignación de la siguiente forma:
Ejemplos:
printf("%s\n", mensaje);
}
#include "stdio.h"
main() /* ejemplo de strcpy() */
{
char a[20];
/*****
*
* funcion xstrcpy()
* copia cadena origen en destino
*
*****/
xstrcpy(dest, orig)
Ejemplo:
/*****
*
* STRING.C
* devuelve n caracteres
*
*****/
char *string();
main()
{
printf("%s", string('*', 5));
}
/*****
*
* string(<expC>, <expN>)
*
*****/
char *string(ch, n)
char ch;
int n;
{
int i;
char x_str[200];
x_str[i]='\0';
return(x_str);
}
Los dos argumento más importantes de main() son argv y argc que
estudiaremos a continuación.
Ejemplo:
/* visualiza argumentos */
main(argc, argv)
int argc;
char *argv[];
{
while(--argc > 0)
printf("%s%c", *++argv, (argc > 1) ? ' ' : '\n');
}
malloc y free
Formato:
void *malloc (unsigned int n)
Ejemplo:
float *f;
f=(float *) malloc (sizeof(float));
if (!f) {
printf ("error de asignación \n");
exit (1);
}
Formato:
free (void *p);
#include "stdlib.h"
Formato:
struct [identificador] {
tipo identificador;
.
.
.
}[identificador[,identificador, ...]];
Ejemplo:
struct usr {
int nro_usr;
char nombre[35];
float cuota;
} reg_usr;
struct usr {
int nro_usr;
char nombre[35];
float cuota;
};
ESTRUCTURAS ANIDADAS
Ejemplo:
struct date {
int day;
int month;
int year;
};
struct usr_date {
int nro_usr;
char nombre[35];
Ejemplo:
reg_usr.nro_usr = 453;
printf("%s\n", reg_usr.nombre);
reg_usr.date_in.day = 15;
Ejemplo:
struct usr {
char *name;
char *keyword;
};
/* Un ejemplo más */
struct data {
int ident;
char *text;
} Xdat;
main()
{
Xdat.ident = 454;
Xdat.text = "cadena";
ARRAYS DE ESTRUCTURAS
struct key {
int nro;
char *keyword;
} lst_key[NMAX];
INICIALIZACION DE ESTRUCTURAS
/***
* programa de demostracion de inicializacion
* (arrays de estructuras)
*
*/
struct date {
char *cmonth;
int nmonth;
} month[12] = { "Ene", 1,
"Feb", 2,
"Mar", 3,
"Abr", 4,
"May", 5,
"Jun", 6,
"Jul", 7,
"Ago", 8,
"Sep", 9,
"Oct",10,
"Nov",11,
"Dic",12
};
main()
{
int i;
Ejemplo:
/***
* demostracion de estructuras
* pasando elementos de una estructura a una funcion
main()
{
static struct {
int a;
int b;
} d = { 4, 8};
/***
* udf swap()
* recibe : punteros a cada campo de estructura
* devuelve: datos intercambiados
*/
swap(x, y)
int *x, *y;
{
int t;
t = *x;
*x = *y;
*y = t;
}
PUNTEROS A ESTRUCTURAS
Ejemplo:
/***
* demostracion del paso de estructuras a una funcion
*/
#include <stdio.h>
struct {
char *name;
int nro_cta;
float saldo;
main()
{
void ajuste(struct reg *pt); /* prototipo */
/***
* udf ajuste()
*/
ESTRUCTURAS AUTOREFERENCIALES
Ejemplo:
/***
* crea una lista
*/
#include <stdio.h>
#define LOCALIZAR (struct nodo *) malloc(sizeof(struct nodo))
struct nodo {
int info;
struct nodo *sig;
};
cab = NULL;
while(i > 0){
q = LOCALIZAR;
q->info = i;
q->sig = cab;
cab = q;
i--;
}
}
Ejemplo:
y luego declarar:
ENTERO a, i, j;
Ejemplo:
y luego declarar:
Ejemplo:
REGISTRO usr_reg;
Los campos bit son un medio adecuado para manipular datos bit a bit en
un byte.
Existen varias razones que hacen de los campos bit una herramienta de
programación de extrema utilidad. Algunas de estas razones son las
siguientes:
Los campos bit nos permiten almacenar en un mismo byte datos de tipo
booleano (Verdadero/Falso) lo cual significa un ahorro de espacio.
struct [identificador] {
tipo identificador : longitud;
.
.
.
}[identificador [, identificador, ...]];
Ejemplo:
struct bits {
unsigned a: 1;
unsigned b: 1;
unsigned c: 1;
unsigned d: 1;
unsigned e: 1;
unsigned f: 1;
unsigned g: 1;
unsigned h: 1;
} byte;
Usted puede apreciar que los campos bit son declarados como unsigned
debido a que cada bit de la palabra debe ser 1 ó 0 sin tener en cuenta
el signo.
15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
-------------------- h g f e d c b a
Sin usar
struct {
unsigned a : 1;
unsigned b : 1;
unsigned c : 5;
unsigned d : 2;
unsigned e : 3;
unsigned f : 4;
} word;
15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
Ejemplo :
union word {
char w[2];
int i;
0 Xword;
Xword
+------------------+
w
-------+--------
w[0] w[1]
+------+------+
i
+-----------------+
/***
* toma caracteres del teclado y los visualiza en binario (ASCII)
*/
#include <stdio.h>
#include <conio.h>
union bits {
char ch;
struct byte bit;
} ascii;
main()
{
while((ascii.ch = getche()) != 'q') {
printf(": ");
decodifica(ascii);
}
}
/***
* udf decodifica()
* recibe : union del tipo bits
* devuelve : nada
*/
/***
* demostracion de campos bit
*/
#include <stdio.h>
main()
{
unsigned m, d, a;
static struct {
unsigned a : 2;
Formato:
enum [identificador] {
identificador,
.
.
.
} [identificador [,identificador,...]];
Ejemplo:
enum {negro,
azul,
cyan,
verde,
magenta,
rojo,
blanco,
amarillo
} fondo, primerplano;
negro 0
azul 1
cyan 2
verde 3
magenta 4
rojo 5
blanco 6
amarillo 7
enum {negro,
azul = 4,
cyan,
verde,
magenta,
rojo,
blanco,
amarillo
} fondo, primerplano;
negro 0
azul 4
cyan 5
verde 6
magenta 7
rojo 8
blanco 9
amarillo 10
primerplano = blanco;
if(fondo == azul)
primerplano = blanco;
else
primerplano = azul;
switch(fondo) {
case negro:
primerplano = blanco;
break;
case azul:
cyan:
verde:
magenta:
rojo:
primerplano = amarillo;
case blanco:
primerplano = negro;
break;
case amarillo:
primerplano = azul;
break;
default:
puts("Error en selección del color de fondo");
}
OPERADORES DE BITS
Ejemplo:
Ejemplo:
Ejemplo:
Da como resultado un uno (1) si el bit del primer oprando esta en uno
(1) y el bit del segundo operando esta en cero (0) o lo contrario. En
cualquier otro caso da como resultado cero (0).
Ejemplo:
Ejemplo:
ENTRADA Y SALIDA (ARCHIVOS)
/***
* copia cualquier archivo
*/
#include <stdio.h>
#include <stdlib.h>
main(argc, argv)
int argc;
char *argv[];
{
FILE *in, *out;
char ch;
if(argc != 3){
puts("Error en parametros...");
exit(1);
}
if((in=fopen(argv[1],"rb"))==NULL) {
puts("No puedo abrir archivo...");
exit(1);
}
if((out=fopen(argv[2],"wb"))==NULL) {
puts("No puedo abrir archivo...");
exit(1);
}
while(!feof(in))
putc(getc(in), out);
fclose(in); fclose(out);
}
/***
*
* las funciones fgets() y fputs()
main(argc, argv)
int argc;
char *argv[];
{
FILE *fp;
int x;
char Xstring[TAM];
if(argc != 2){
puts("Uso : prog <file>");
exit(1);
}
if((fp=fopen(argv[1], "w"))==NULL){
puts("Error en apertura de datos");
exit(1);
}
while(strlen(Xstring) != 0){
fputs(Xstring, fp);
printf("-=> "); gets(Xstring);
}
fclose(fp);
}
/***
*
* las funciones fgets() y fputs()
* char *fgets(char *str, FILE *fp);
* char *fputs(char *str, int long, FILE *fp);
*----------------------------------------------------------
* fgets() : lee una cadena desde la corriente especificada
* hasta que encuentra el caracter de nueva linea
* fputs() : escribe una cadena en la corruente especificada
*/
main(argc, argv)
int argc;
char *argv[];
{
FILE *fp;
int x;
char Xstring[TAM];
if(argc != 2){
puts("Uso : prog <file>");
exit(1);
}
if((fp=fopen(argv[1], "r"))==NULL){
puts("Error en apertura de datos");
exit(1);
}
fclose(fp);
}
/***
*
* la funcion fseek()
* int fseek(FILE *fp, long num_bytes, int origen);
* establece el localizador de posicion en un byte especifico
* num_byte : numero de bytes desde el origen a alcanzar la nueva
* posicion
*
* origen :
* comienzo del archivo SEEK_SET 0
* posicion actual SEEK_CUR 1
* fin de archivo SEEK_END 2
*/
#include <stdio.h>
#define SIZE 20
main()
{
FILE *fp;
fclose(fp);
}
LA ROM-BIOS
VECTORES DE INTERRUPCION
1. La inicialización de video
2. La tabla base de disco
3. La tabla de caracteres graficos
Ejemplo:
20 decimal es igual a 14 hexadecimal
de esta manera podriamos escribir:
DEBUG <cr>
D 0000:0014 L 4 <cr>
La respuesta seria:
54 FF 00 F0
EL MICROPROCESADOR 8088
Permiten:
3. Registros de segmento.
Soportan el esquema de memoria segmentada del 8086.
CS :Segmento de codigo actual.
DS :Segmento de datos actual.
ES :Segmento extra.
ES :Segmento de pila.
SP SI
Puntero de pila Puntero indice
BP DI
Puntero base Indice destino
Registros de segmento
CS SS
Segmento de codigo Segmento de pila
DS ES
Segmento de dato Segmento extra
registros de proposito especial
IP
Registro indice Puntero de instrucciones
Se reserva el primer Kilo Byte de memoria para usarlo con una tabla de
/***
* INTER1.C
* interrupcion ROM-BIOS 19h
* activacion de la rutina de arranque del sistema
* (bootstrap)
*-------------------------------------------------
* Objetivo : Utilizo frecuentemente esta interrupcion para dos
* cosas:
* 1. El inmediato cierre de las operaciones del
* computador cuando se encuentra una situacion
* intolerable, por ejemplo el intento de copia de
* un software.
* 2. Para hacer un arranque del sistema sin hacer
* las operaciones de reset y restart.
*/
#include <dos.h>
void boot();
main()
{
boot();
}
void boot()
{
union REGS r;
/***
* INTER2.C
* interrupcion DOS (21h)
* Servicio : 35h Captar el vector de interrupcion
#include <dos.h>
void showvec();
main()
{
showvec();
}
void showvec()
{
int i;
union REGS r;
struct SREGS sr;
/***
* INTER3.C
* interrupcion DOS (21h)
* escribir caracteres en la impresora
*-------------------------------------------------
* Entrada:
* AH = 5h
* AL = caracter
* Devuelve:
* none
*/
#include <dos.h>
void escricar();
void escricar(c)
int c;
{
union REGS r;
r.h.ah = 0x5;
r.h.al = c;
intdos(&r, &r);
}
/***
* INTER4.C
* interrupcion ROM-BIOS 13h
* sistema de disco
* servicio : 1
* obtiene status del disco
*-------------------------------------------------
* Entrada:
* AH = 1
* Devuelve:
* AL : 1 comando incorrecto
* 2 marca de direccion no encontrada
* 3 intento de escritura en disco protegido
* 4 sector no encontrado
* 6 disco retirado
* 8 rebasar el limite del DMA
* 9 DMA mas alla de los 64K
* 10 mal CRC
* 20 fallo del controlador NEC
* 40 falo de busqueda
* 80 time out
*/
#include <dos.h>
drive_st();
main()
{
int i;
i = drive_st();
drive_st()
{
union REGS r;
r.h.ah = 0x1;
return(int86(0x13, &r, &r));
}
#include <dos.h>
wherex()
{
regs.h.ah = 3; /* obtener posicion del cursor */
regs.h.bh = 0; /* para la pagina 0 */
int86(0x10, ®s, ®s);
return(regs.h.dl); /* columna actual */
}
#include <dos.h>
wherey()
{
regs.h.ah = 3; /* obtener posicion del cursor */
regs.h.bh = 0; /* para la pagina 0 */
int86(0x10, ®s, ®s);
return(regs.h.dh); /* fila actual */
}
#include "dos.h"
gotoxy(col, row)
int col, row;
{
union REGS regs;
Temas a cubrir:
4. Ejemplo de funciones C
6. Ejercicios de demostración
Ejemplo:
Xvar_mem = funcion(<exp>)
Ejemplo:
charactervoid_retc(char*) __RETC
datevoid _retds(char*) __RETDS
logicalvoid _retl(int) __RETL
numericvoid _retni(int) __RETNI
numericvoid _retnl(long) __RETNL
numericvoid _retnd(double) __RETND
(no return value)void_ret(void) __RET
RECIBIENDO PARAMETROS EN C
En C:
CLIPPER <function_name>()
/* parametros formales C omitidos */
{
<declaración de variables locales>
DECLARE arr[3]
arr[1] = "Devorah"
arr[2] = 456.56
arr[3] = CTOD("09/01/87")
Arrfunc(arr)
En C:
Donde:
a = No chequea alias
l = Habilita la optimización de los loop
t = Ejecuta a la maxima velocidad
Ejemplo:
MACROS C PREDEFINIDOS
#defines en EXTEND.H
Tipo Devuelve
-------------------------------------
indefinido = UNDEF
caracter = CHARACTER
numerico = NUMERIC
logico = LOGICAL
fecha = DATE
por referencia = MPTR
memo = MEMO
arreglo = ARRAY
_parc()
Sintaxis de uso:
#include <extend.h>
Descripción:
_parclen()
Sintaxis de uso:
#include <extend.h>
Descripción:
Sintaxis de uso:
#include <extend.h>
_pards()
Sintaxis de uso:
#include <extend.h>
Descripción:
_parinfa()
Sintaxis de uso:
#include <extend.h>
Descripción:
En Clipper:
DECLARE array[2]
array[1] = "Devorah"
array[2] = 456.56
ArrFunc(array)
En C:
{ /* variables string */
if (_parinfa(1, x) == CHARACTER)
{
cprintf("%s\n", _parc(1, x));
}
_parinfo()
Sintaxis de uso:
#include <extend.h>
int _parinfo(order)
Descripción:
Ejemplo:
CLIPPER cfunc()
{
char *parm1;
double parm2;
int parm3; /* logico declarado como int */
char *parm4; /* fecha declarado como char (YYYYMMDD) */
{
<codigo a ejecutar si los parametros son validos>
}
else
{
<codigo a ejecutar si los parametros son invalidos>
}
_parl()
Sintaxis de uso:
#include <extend.h>
Description:
_parnd()
Sintaxis de uso:
#include <extend.h>
double _parnd(order, index)
Descripción:
_parni()
Sintaxis de uso:
#include <extend.h>
Descripción:
Sintaxis de uso:
#include <extend.h>
Descripción:
_exmgrab()
Asigna memoria.
Sintaxis de uso:
#include <extend.h>
Descripción:
Ejemplo:
size = 512
buff = _exmgrab(size)/* asignar memoria */
if (buff)/* si todo salio bien (!null) */
check = TRUE;
size = 512
buff = _exmgrab(size)/* asigna memoria */
if (buff)/* si todo salio bien (!null) */
check = TRUE;
if (check)
_exmback(buff, size);/* libera memoria */
_exmback()
Sintaxis uso:
#include <extend.h>
Descripción:
_ret()
#include <extend.h>
void _ret(void)
Descripción:
_retc()
Sintaxis de uso:
#include <extend.h>
Descripción:
_retclen()
Sintaxis de uso:
#include <extend.h>
Descripción:
_retds()
Sintaxis de uso:
#include <extend.h>
void _retds(string)
Descripción:
_retl()
Sintaxis de uso:
void _retl(flag)
Descripción:
_retnd()
Sintaxis de uso:
#include <extend.h>
void _retnd(x);
Descripción:
_retni()
Sintaxis de uso:
#include <extend.h>
void _retni(n)
Descripción:
_retnl()
#include <extend.h>
void _retnl(n)
Descripción:
/***
*
* DIRE.C
* Funciones de usuario para manejo de directorios.
* Nota : Para enlazar con CLIPPPER/SUMMER '87.
* Estas funciones deben ser compiladas con Microsoft C 5.0 .
* Fecha: Cartagena, Noviembre 22 De 1991.
* Copyright (c) 1991. Anibal G. Martinez Arcia.
* (Especialista en Lenguaje C).
*
*
*
*---------------------------------------------------------------
* Contenido:
* ==========
* FUNCION PROPOSITO
*---------------------------------------------------------------
* get_drive() Obtiene la unidad por defecto.
* set_drive() Establece la unidad por defecto.
* makedir() Crea directorio.
* changedir() Cambia de directorio.
*/
#include <dos.h>
#include <nandef.h>
#include <extend.h>
#include <direct.h>
/***
* get_drive()
* Int DOS. (21h).
* servicio 19h. Captar unidad de disco actual.
* AH : 19h
* AL : devuelve unidad de disco actual
* : 0 = A, 1 = B, 2 = C, Etc.
* Proposito : Captar unidad de disco actual.
* Ej. Uso : var = get_drive()
*
*/
CLIPPER get_drive()
{
static char *drv_name[] = {"A:", "B:", "C:", "D:", "E:", "F:"};
union REGS r;
r.h.ah = 0x19;
intdos(&r, &r);
_retc(drv_name[r.h.al]);
}
regs.h.ah = 0x0E;
regs.h.dl = drive;
intdos(®s, ®s);
/* return(regs.h.al); */
_ret(); /* no debuelva nada */
}
/***
* makedir(<path>)
* Proposito : Crear directorio.
* Recibe : Path.
* Devuelve : 0 = Exito. -1 = Error.
* Ej. Uso : var = makedir("\usr")
*/
CLIPPER makedir()
{
int error;
char *path = _parc(1);
error = mkdir(path);
_retni(error);
}
/***
* changedir(<path>)
* Proposito : Cambiar de directorio.
* Recibe : Path.
* Devuleve : 0 = exito. -1 = Error.
* Uso : vas = changedir("\usr")
*/
CLIPPER changedir()
{
error = chdir(path);
_retni(error);
}
/***
*
* STRING.C
* Funciones de usuario para manejo de cadenas.
* Nota : Para enlazar con CLIPPPER/SUMMER '87.
* Estas funciones deben ser compiladas con Microsoft C 5.0 .
* Fecha: Cartagena, Noviembre 22 De 1991.
* Copyright (c) 1991. Anibal G. Martinez Arcia.
* (Especialista en Lenguaje C).
*
*
*
*-------------------------------------------------------------
* Contenido:
* ==========
* FUNCION PROPOSITO
*-------------------------------------------------------------
* cnt_cadena() Devuelve el numero de veces que una subcadena se *
encuentra en una cadena.
*/
#include <dos.h>
#include <nandef.h>
#include <extend.h>
/***
* cnt_cadena(<expC1>, <expC2>)
* Proposito : Devuelve el numero de veces que una subcadena se
* encuentra
* en una cadena.
* <expC1> : Cadena.
* <expC2> : Subcadena.
* Ej. Uso : var = cnt_cadena("esto es una prueba", "es")
*/
CLIPPER cnt_cadena()
{
char *string = _parc(1); /* cadena */
char *sub_string = _parc(2); /* subcadena */
int i, j, k, conta = 0;
/***
* SOUNDEX()
* kevin j. shepherd, NANTUCKET Corporation.
* 09/14/87
*
* Produces a code based on the "Soundex" method originally
* eveloped by M.K. Odell and R.C. Russell. Algorithm can
* be found on page 392 of Knuths' book 'Sorting and
* Searching', volume 3 of 'The Art of Computer
* Programming", Addison/Wesley publisher.
*
* code = SOUNDEX(name)
*
* code - character string.
* name - character string.
*
* Non-alphabetic characters in input stream will cause the
* function to abort and return a NULL pointer.
*
**/
#include "nandef.h"
#include "extend.h"
/***
*
* soundex()
* kjs
* 09/14/87
*
* Main soundex function, does param checking, allocation,
* string prep, and deallocation.
*
**/
CLIPPER SOUNDEX()
{
Boolean error;
quant i;
quant name_size;
byte *name;
byte *code;
code = NULL;
error = (PCOUNT != 1 || !ISCHAR(1) || _parclen(1) == 0);
if (!error)
{
name = _parc(1);
name_size = (quant)(_parclen(1) + 1);
/** +1 for NIL byte **/
code = _exmgrab(name_size >= CODE_ALLOC
? name_size : CODE_ALLOC);
/** make uppercase **/
for (i = 0; i < name_size; i++)
name[i] = UPPER(name[i]);
if (!error)
/***
*
* name_2_code()
* kjs
* 09/14/87
*
* Converts a name into 4 unit code (alpha, digit, digit, digit)
* as per the SOUNDEX method rules.
*
* error = name_2_code(source, source_size, target)
*
**/
byte *source;
quant source_size;
byte *target;
{
Boolean error;
quant i;
quant j;
error = FALSE;
if (!error)
{
target[j] = source[i];
j++;
i++;
}
target[j] = NIL;
if (!error)
{
/** translation **/
for (i = 1; i < j; i++)
target[i] = translate(target[i]);
target[i] = NIL;
}
return (error);
}
/***
*
* translate()
*
* Translates a character into a code digit.
*
* digit = translate(chr)
*
**/
byte translate(chr)
byte chr;
{
Boolean found;
quant i;
quant j;
byte digit;
found = FALSE;
digit = NIL;
if (!found)
i++;
}
return (digit);
}
/***
*
* omit()
*
* Check the character if it is on the omit list.
*
* status = omit(chr)
*
**/
Boolean omit(chr)
byte chr;
{
quant i;
Boolean found;
found = FALSE;
/***
* STUFF()
* kevin j. shepherd, NANTUCKET Corporation.
* 09/13/87
*
* Replace LENGTH number of characters in SOURCE starting at START
* with the entire MODIFIER string.
*
* target = STUFF(source, start, length, modifier)
*
* target - character string.
* source - character string.
* start - numeric.
* length - numeric.
* modifier - character string.
*
**/
CLIPPER STUFF()
{
quant i;
quant j;
quant s_max;
quant m_max;
quant buffer_size;
quant start;
quant length;
byte *source;
byte *modifier;
byte *buffer;
buffer[j] = NIL;
_retclen(buffer, j);
_exmback(buffer, buffer_size);
}
else
{
_retc("");
}
}
/***
* DISKSPACE()
* Tom Rettig, Brian Russell
* 11/01/85
*
#define DEFAULT 0
CLIPPER DISKSPACE()
{
struct /* structure to hold disk info */
{
unsigned no_clusts; /* number of free clusters */
unsigned secs_clusts; /* sectors per cluster */
unsigned clusts_drv; /* total clusters per drive */
} drv_info;
#define FALSE 0
#define TRUE 1
/***
*extend.h
*
*DEFINEs and EXTERNs for interfacing with Clipper from C.
*
*Large model C only (double word pointers to code and data)
*
*Copyright (c) Nantucket Corporation 1987
*/
/* _parinfo types */
#define UNDEF 0
#define CHARACTER 1
#define NUMERIC 2
#define LOGICAL 4
#define DATE 8
#define ALIAS 16
#define MPTR 32
/* or'ed with type when passed by reference */
#define MEMO 64
#define WORD 128
#define ARRAY 512 /* parameter count/type */
extern int _parinfo(int);
extern int _parinfa(int, int);
/* parameter values */
extern char *_parc(int, ...);
extern int _parcsiz(int, ...);
extern int _parclen(int, ...);
extern int _parni(int, ...);
extern long _parnl(int, ...);
/* allocate memory */
/* parameter: requested size in bytes */
/* returns: far pointer to memory or NULL */
extern unsigned char *_exmgrab(unsigned);
/* misc. */
extern unsigned strlen(unsigned char *);
/* Header structure */
typedef struct
{
byte signature;/* 03 = dbf, 83 dbf+dbt */
byte ymd[3]; /* y+1900 m d */
long last_rec;
quant data_off;
quant rec_size;