Turbo c++

© Rodolfo Gallardo-Rosales

Programación en Lenguaje C

Universidad de Colima

Colima, Col.

Copyright© 2001 por Rodolfo Gallardo-Rosales
rodolfo@gallardo.cc
http://www.gallardo.cc

Tutorial
Turbo C


Programación en Lenguaje C avanzado

Estado del presente documento
Este documento es un manual rápido para aprender a programar en Lenguaje C,
dedicado en especial a los estudiantes de programación en Lenguaje C, que es editado
con el propósito de complementar la información que pueda ser encontrada en el mercado,
uniendo el análisis de varios textos en un solo documento.

Introducción
El lenguaje C fué implementado e inventado por Dennis Ritchie en un DEC PDP-11 bajo
UNIX; basado en dos lenguajes anteriores: BCPL de Martín Richards y B de Ken
Thompson.

C es un lenguaje de nivel medio, porque combina elementos de lenguajes de alto nivel con
la funcionalidad del ensamblador; es portable, porque si se escribe para un tipo de
computadora, se puede adaptar a otra.

Aunque es un lenguaje estructurado, no permite la creación de funciones dentro de
funciones.

El componente estructural principal de C es la función.

Tabla de contenidos

1. El entorno de Turbo C

1.1. Sumario de las órdenes del menú principal
1.2. Abreviaturas del teclado de Turbo C
1.3. Uso del editor de Turbo C

2. Lenguaje C

2.1. Introducción
2.2. Variables, constantes, operadores y expresiones
2.3. Sentencias de control de programa
2.4. Funciones
2.5. Arrays

Tutorial
Turbo C


2.6. Punteros
2.7. Estructuras, uniones y variables definidas por el usuario
2.8. Entrada, salida y archivos de disco
2.9. El preprocesador de Turbo C
2.10. Funciones gráficas y de pantalla

3. La biblioteca de Turbo C

3.1. Funciones de E/S
3.2. Funciones de cadenas, memoria y caracteres
3.3. Funciones matemáticas
3.4. Funciones de hora, fecha y otras del sistema
3.5. Funciones de aignación dinámica de memoria
3.6. Funciones de directorio
3.7. Funciones de control de procesos
3.8. Funciones de gráficos y de la pantalla de texto
3.9. Funciones variadas

4. Librería de programas

5. Bibliografía

Tutorial
Turbo C


1. El entorno de Turbo C

1.1. Sumario de las órdenes del menú principal
Elemento Opciones

File Carga y graba archivos, maneja directorios, invoca a DOS y termina
Edit Invoca al editor de Turbo C
Run Compila, enlaza y ejecuta el programa cargado
Compile Compila el programa cargado
Project Gestiona proyectos de varios archivos
Options Diversas opciones de compilación y enlazado
Debug Diversas opciones de depuración
Break/Watch Inspecciona expresiones y puntos de ruptura

Menú File

Sub-elemento Acción

Load Cargar programa
Pick Escoger programa
New Nuevo programa
Save Guardar programa
Write to Escribir en...
Directory Directorio
Change dir Cambiar directorio
OS shell Sale temporalmente a MS_DOS
Quit Terminar

Menú Edit

Se activa el editor de Turbo C

Menú Run


Run Ejecutar programa
Program reset Reinicialización de programa
Goto cursor Ejecutar programa hasta donde está el cursor
Trace into Trazar dentro
Step over Saltarse
User screen Pantalla del usuario

Tutorial
Turbo C


Menú Compile


Compile to OBJ Compilar a archivo .OBJ
Make EXE file Crear archivo .EXE
Link EXE file Enlazar archivo .EXE
Build all Construír todo
Primary C file Archivo primario de C
Get info Obtener información

Menú Project


Project name Nombre del proyecto
Break make on Detener la creación por...
Auto dependencies Auto dependencias
Clear project Termina con proyecto
Remove messages Eliminar mensajes

Menú Options


Compiler Compilador
Linker Enlazador
Environment Entorno
Directories Directorios
Arguments Argumentos
Save options Guardar opciones
Retrieve options Recuperar opciones

Menú Debug


Evaluate Evaluar
Call stack Pila de llamada
Find function Encontrar función
Refresh display Refrescar pantalla
Display swapping Cambio de pantalla
Source debugging Depuración de fuente

Tutorial
Turbo C


Menú Break/Watch


Add watch Añadir inspector
Delete watch Borrar inspector
Edit Watch Editar inspector
Remove all Elimina todos los inspectores watches
Toggle breakpoint Poner o quitar puntos de ruptura
Clear all Quitar todos los puntos de ruptura breakpoints
View next Ver siguiente punto de ruptura breakpoint

1.2. Abreviaturas del teclado de Turbo C
Abreviatura Acción
F1 Ayuda
F2 Grabar archivo
F3 Carga archivo
F4 Ejecuta hasta cursor
F5 Amplía ventana
F6 Cambio entre ventanas
F7 Traza dentro de llamadas a función
F8 Traza sin entrar a función
F9 Compila y enlaza
F10 Cambia entre editor y menú

Alt-F1 Ultima pantalla de ayuda
Alt-F3 Escoge archivo a cargar
Alt-F5 Cambia entre pantalla de usuario y editor
Alt-F6 Cambia entre ventanas de inspección y mensajes
Alt-F7 Error anterior
Alt-F8 Error siguiente
Alt-F9 Compila a .OBJ
Alt-C Menú Compile (Compila)
Alt-D Menú Debug (Depurador)
Alt-E Menú Edit (Editar)
Alt-F Menú File (Archivo)
Alt-O Menú Options (Opciones)
Alt-P Menú Project (Proyecto)
Alt-R Menú Run (Ejecutar)
Alt-X Sale de Turbo C

Tutorial
Turbo C


Ctrl-F1 Ayuda donde está el cursor
Ctrl-F2 Devuelve programa a estado inicial
Ctrl-F3 Muestra Call stack
Ctrl-F4 Evalúa expresiones
Ctrl-F7 Inspecciona expresión
Ctrl-F8 Activa/Desactiva breakpoint
Ctrl-F9 Ejecuta programa actual

1.3. Uso del editor de Turbo C
Ordenes de cursor Acción
Ctrl-R Mover una pantalla hacia arriba (RePág)
Ctrl-C Mover una pantalla hacia abajo (AvPág)
Inicio Va a inicio de línea
Fin Va a fin de línea
Ctrl-RePág Principio de archivo
Ctrl-AvPág Fin de archivo
Ctrl-Inicio Principio de pantalla
Ctrl-Fin Fin de pantalla

Ordenes de borrado Acción
Ctrl-Y Borra línea completa
Ctrl-QY Borra hasta fin de línea
Ctrl-T Borra palabra a la derecha del cursor

Ordenes de bloque Acción
Ctrl-KB Marca comienzo de bloque
Ctrl-KK Marca fin de bloque
Ctrl-KT Marca palabra
Ctrl-KC Copia bloque marcado
Ctrl-KY Borra bloque marcado
Ctrl-KH Oculta o muestra bloque
Ctrl-KV Mueve bloque marcado
Ctrl-KW Escribe bloque marcado a disco
Ctrl-KR Lee bloque marcado de disco
Ctrl-KP Imprime bloque marcado

Ordenes de búsqueda Acción
Ctrl-QF Buscar
Ctrl-QA Buscar y reemplazar
Ctrl-L Repite búsqueda

Tutorial
Turbo C


2. Lenguaje C
2.1. Introducción

Una forma típica de estructuración en C es mediante el uso de bloques de código, que es un
grupo de sentencias conectadas en forma lógica que es tratado como una unidad. En C se
colocan entre llaves.

Ejemplo:

if (x<10){
printf("demasiado pequeño, pruebe de nuevo...");
reini_contador(-1);
}

El bloque se ejecuta sólo si x es menor que 10.

C tiene sólo 43 palabras clave:

32 definidas por el estándar ANSI

auto double int struct
break else long switch
case enum register typedef
char extern return union
const float short unsigned
continue for signed void
default goto sizeof volatile
do if static while

11 añadidas por Turbo C

asm _cs _ds _es
_ss cdecl far huge
interrupt near pascal

Todos los programas en C consisten de una o más funciones. La única que debe estar
absolutamente presente es la demçnominada main()

Tutorial
Turbo C


La forma general de un programa en C es:

declaraciones globales
main()
{
variables locales
secuencia de sentencias
}
f1()
{
variables locales

}
f2()
{
variables locales
}
.
.
.
fn()
{
variables locales
}

Términos más frecuentes usados en la programación en Turbo C:

Código fuente: Texto de un programa, es la entrada al
compilador, su extensión es .C

Código objeto: Traducción del código fuente a código máquina,
es la entrada al enlazador, su extensión es .OBJ

Enlazador: Programa que enlaza funciones para prodiçucir un
solo programa, su salida es el código ejecutable,
cuya extensión es .EXE

Biblioteca: Archivos que contienen las funciones estándar de
C

Tutorial
Turbo C


Tiempo de compilación: Lo que sucede mientras un programa es
compilado

Tiempo de ejecución: Lo que sucede mientras un programa es ejecutado

2.2. Variables, constantes, operadores y expresiones
Existen 5 tipos de datos atómicos: carácter, entero, punto flotante, punto flotante de doble
precisión, y sin valor.

Tamaño y rango:

Tipo Tamaño en bits Rango

char 8 0..255
int 16 -32768..32767
float 32 3-4E-38..3-4E+38
double 64 1.7E-308..1.7E+308
void 0 sin valor

char: valores definidos en caracteres ASCII
int: variables enteras
float y double: variables reales
void: sirve para
a. declarar una función que no devuelva un valor
b. declarar una función sin parámetros
c. crear punteros genéricos

Modificadores:

signed, unsigned, short, long: para variables int y char
long: para variables double
const: variables que no pueden ser cambiadas durante la ejecución del programa

ejemplo:

const int a; /*no está inicializada*/
const int cuenta=100; /*ya inicializada*/

volatile: indica que puede cambiar por medios no especificados
explícitamente.

Tutorial
Turbo C


Declaración de variables

La forma general es:

tipo lista_de_variables;

ejemplos:

int i, j, l;
short int si;
unsigned int u;
double balance, beneficio, perdida;

Variables locales: son las que se declaran dentro de una función, son conocidas sólo
dentro del bloque de código.

ejemplo:

void func1(void)
{
int x;
x=10;
}

otro ejemplo:

void f(void)
{
int t;
scanf ("%d",&t);
if (t==1){
char s[80]; /*se crea al entrar al bloque*/
printf("introduzca el nombre");
gets(s);
procesar(s);
}
/*aquí no se conoce s*/
}

Parámetros formales

Si una función va a usar argumentos, debe declarar las variables que van a aceptar los
valores de los argumentos. Se deben dar tras el nombre de la función y entre paréntesis.

Tutorial
Turbo C


ejemplo:

/*devuelve 1 si c es parte de la cadena, si no devielve un 0*/
esta_en(char s, char c)
{
while (*s)
if (*s==c) return 1;
else s++;
return 0;
}

Variables globales

Son las que se conocen a lo largo de todo el programa y se pueden usar en cualquier parte
del código, además mantiene su valor durante toda la ejecución del programa; se crean al
declararse fuera de todas las funciones.

Actividad:

>> Desarrollar en TC los programas ejemplo Nos. 1 y 2

Especificadores de clase de almacenamiento

Son cuatro especificadores:
extern
static
register
auto

su forma general es:

especificador_de_almacenamiento tipo nombre_de_variable;

-> extern

Se usa para compilar programas por separado; en uno de ellos se declaran las variables
globales, y en los otros, como extern.

Tutorial
Turbo C


Archivo 1 Archivo 2 Archivo 3

int x,y; extern int x,y; extern int x,y;
char ch; extern char ch; extern char ch;
main(void) void func1(void) void func2(void)
{ { {
--------- --------- ---------
--------- --------- ---------
--------- --------- ---------
} } }

-> Variables estáticas (locales)

Son variables permanentes que mantienen su valor entre llamadas, si no se permitiera usar
static, habría que usar variables globales. Un ejemplo se ilustra con la función cuenta().

Actividad:


-> Variables estáticas (globales)

Indican al compilador que cree una variable global sólo en éste archivo, por lo que las
rutinas de otros archivos no la reconocerán ni alterarán.

ejemplo:

/*debiera estar en un sólo archivo*/
static int num;
int series(void);
void comienza_series(int semilla);
series(void)
{
num=num+23;
return (num);
}
/*inicialización de num*/
void comienza_series(int semilla)
{
num=semilla;
}

Tutorial
Turbo C


-> Variables registro

Las operaciones sobre variables registro son mucho más rápidas que sobre variables
guardadas en memoria. Cuando una variable está realmente guardada en la CPU no
requiere acceso a memoria para determinar o modificar su valor.

Son ideales para el control de bucles.

ejemplo:

pot_ent(int m, register int e)
{
register int temp;

temp=1;
for (;e;e--) temp *=m;
return temp;

}

Sentencias de asignación

Su forma general es:

nombre_de_variable=expresión;

donde expresión puede ser una constante o una combinación de variabñes, operadores y
constantes.

Conversión de tipo en las asignaciones

Cuando se mezclan variables de un tipo con variables de otro, se da la conversión de tipo;
el valor del lado derecho se convierte al tipo del lado izquierdo.

ejemplo:

int x;
char ch;
float f;

void func(void)
{
ch=x; /*x ahora es caracter*/
x=f; /*f ahora es entero*/

Tutorial
Turbo C


f=ch; /*ch ahora es flotante*/
f=x; /*x ahora es flotante*/
}

Inicialización de variables

Se hace colocando el signo igual y una constante después del nombre de una variable.

Forma general:

tipo nombre_de_variable=constante;

ejemplos:

char ch='a';
int primero=0;
float balance=123.45;

Constantes

Son valores fijos que no pueden ser alterados por el programa. Una constante de cadena,
será entre " ", como "es una prueba". La de un solo carácter, con comillas simples, como en
'a'.

ejemplos:

char 'a', 'n', '9'
int 1, 123, 21000, -234
long int 35000, -34
short int 10, -12, 90
unsigned int 10000, 987, 40000
float 123.45, 4.34e-3
double 12345.67, 112356476, -0.9876756

Constantes de carácter con barra invertida

Algunos caracteres no se pueden traducir desde el teclado, como el <cr>, por ejemplo:

c='t';
printf("esto es una prueban");

Asigna tabulación a c y escribe la cadena y <cr>

Tutorial
Turbo C


Códigos de barra invertida

Código Significado

b Espacio atrás
f Salto de página
n Salto de línea
r Retorno de carro
t Tabulación horizontal
" Comillas dobles
' Comilla simple
0 Nulo
Barra invertida
v Tabulación vertical
a Alerta
o Constante octal
x Constante hexadecimal

Operadores

Símbolos que indican al compilador que efectúe ciertas manipulaciones matemáticas o
lógicas.

-> Operadores aritméticos

- Resta y menos monario
+ Suma
* Multiplicación
/ División
% División en módulo
-- Decremento
++ Incremento

ejemplo:

int x, y;
x=10;
y=3;
printf ("%d", x/y); /*muestra 3*/
printf ("%d", x%y); /*muestra 1*/

Tutorial
Turbo C


Respecto a incremento y decremento:

x=x+1; equivale a ++x;
x=x-1; equivale a --x;

Operadores relacionales y lógicos

Relacional: se refiere a la relación entre unos valores y otros.

Lógico: se refiere a las formas en que las relaciones se pueden conectar entre sí siguiendo
las reglas de la lógica formal.

-> Operadores relacionales:

> Mayor que
>= Mayor que o igual a
< Menor que
<= Menor que o igual a
== Igual a
!= No igual a

-> Operadores lógicos

&& And (Y)
|| Or (O)
! Not (NO)

Tabla de verdad de los operadores lógicos

p q p&&q p||q !p

0 0 0 0 1
0 1 0 1 1
1 0 0 1 0
1 1 1 1 0

Operadores a nivel de bits

Se refieren a la comprobación, asignación o desplazamiento de los bits reales
que componen un byte o una palabra.

Tutorial
Turbo C


-> Operadores a nivel de bits

& Y
| O
^ = exclusiva (XOR)
~ Complemento a uno
>> Desplazamiento a la derecha
<< Desplazamiento a la izquierda

Tabla de verdad de XOR

p q p^q

0 0 0
0 1 1
1 0 1
1 1 0

Un ejemplo de uso:

char obtener_car_del_modem(void)
{
char c;
c=leer_modem();
return (c&127);
}

El & pone el bit de paridad a cero. Suponiendo que se ha recibido una letra
'A', entonces:

11000001 'A' con paridad 1
01111111 127
-------- &
01000001 'A' sin paridad

El | pone el bit de paridad a uno, por ejemplo:

01000001 'A' sin paridad
10000000 128
-------- |
11000001 'A' con paridad 1

La ^ pone a uno sólo los bits que al compararse sean distintos, por ejemplo:

Tutorial
Turbo C


01111111 127
01111000
-------- ^
00000111

Los operadores >> y << mueven todos los bits a la derecha o izquierda, por
ejemplo:

x=7 00000111 7
x=x<<1; 00001110 14
x=x<<3; 01110000 112
x=x<<2; 11000000 192
x=x>>1; 01100000 96
x=x>>2; 00011000 24

El operador de complemento a uno (~) cambia el estado de cada bit en la
variable especificada, por ejemplo:

byte original 00101100
1er. complemento 11010011
2do. complemento 00101100

-> El operador ?

Operador ternario que puede usarse para sustituir ciertas sentencias de la
forma if-then-else.


expresión1? expresión2: expresión3;

Ejemplo:

Forma ? Forma if-then-else

x=10; x=10;
y=x>9? 100: 200; if (x>9) y=100;
else y=200;

-> Los operadores de puntero & y *

Un puntero es la dirección de memoria de una variable

ejemplo:

Tutorial
Turbo C


m=&cont;

coloca en m la dirección de memoria de la variable cont, supongamos que sea
la posición de memoria 2000, m tendrá el valor de 2000.

si anotamos: q=*m;

entonces, devuelve a q el valor ubicado en la dirección de memoria que se
especifica, devolverá cont.

Las variables que vayan a mantener direcciones de memoria, se declararán
colocando un * delante del nombre.

ejemplo:

char *c;
int x, *y, cont;

código ejemplo:

main(void)
{
int destino, fuente;
int *m;

fuente=10;
m=&fuente;
destino=*m;
return 0;
}

-> El operador de tiempo de compilación sizeof

Es un operador monario que devuelve la longitud en bytes, de la variable
entre paréntesis.

Es muy útil para desarrollar código a ejecutarse en diferentes entornos, por
ejemplo:

poner_reg(FILE *fp, int reg[6])
{
int long num;

Tutorial
Turbo C


longit=sizeof(reg);
num=fwrite(reg,longit,l,fp);
if (num<>1) printf ("error de escritura...");
}

-> La coma como operador

La coma encadena varias expresiones. La parte izquierda se evalúa como void,
y el valor de la derecha tomará el valor total de la expresión.

ejemplo:

x=(y=3, y+1); /*x vale 4*/
y=10;
x=(y=y-5, 25/y); /*x vale 5*/

-> Los operadores . y ->

hacen referencia a elementos individuales de las estructuras y las uniones,
tipos de datos compuestos denominados bajo un solo nombre.

El punto se usa cuando se trabaja realmente con la estructura o la unión. El
operador flecha, cuando se usa un puntero a una estructura.

ejemplo:

struct empleado{
char nombre[80];
int edad;
float sueldo;
}emp;

Para asignar el valor 123.45 al elemento sueldo de la estructura emp, se
realizaría así:

emp.sueldo=123.45;

y usando un puntero a la estructura emp, sería de esta manera:

emp->sueldo=123.45;

Tutorial
Turbo C


-> Los operadores [] y ()

En C los paréntesis son operadores que aumentan la precedencia de las
operaciones. Los corchetes llevan a cabo el indexamiento de arrays. Dado un
array, la expresión entre corchetes proporciona un índice para el array.

Actividad


2.3. Sentencias de control de programa
Sentencias condicionales

C soporta dos tipos de sentencias condicionales: if y switch.

if


if (expresión) sentencia;
else (sentencia);

donde sentencia puede ser simple o un bloque de sentencias. Else es opcional.
Con bloques de sentencias, la forma general será:

if (expresión){
secuencia_de_sentencias
}
else{
}

Actividad:


ifs anidados

Se deben usar llaves para saltarse la asociación normal, por ejemplo:

if (x){
if (y) printf("1");

Tutorial
Turbo C


}
else printf ("2");

Para ver el programa "mágico" mejorado se sugiere la siguiente

Actividad:

>> Desarrolar en TC los programas ejemplo Nos. 9 y 10

La escala if-else-if


if (expresión)
sentencia;
else if (expresión)
sentencia;
else if (expresión)
sentencia;
else
sentencia;

Utilizando lo anterior, se puede mejorar el programa mágico, para lo que se
sugiere la siguiente

Actvidad:


La alternativa ?


expresión1? expresión2: expresión3;

Para ver el programa mágico con esta alternativa, se sugiere la siguiente

Actividad:


Tutorial
Turbo C


switch

Sentencia de decisión de ramificación múltiple.

Forma general:

switch (variable){
case constante1:
break;

case constante2:
break;
case constante3:
break;
.
.
.
default:
}

default se ejecuta sólo si no se encuentra ninguna correspondencia.

ejemplo:

void menu(void)
{
char c;

printf("1. Comprobar ortografían");
printf("2. Corregir errores ortográficosn");
printf("3. Mostrar errores ortográficos");
printf("Pulse cualquier otra tecla para terminar...");
printf("Introduzca su opción...");
c=getche();
switch (c){
case '1':
comprobar_ortografia();
break;
case '2':
corregir_errores();

Tutorial
Turbo C


break;
case '3':
mostrar_errores();
break;
default:
printf("Ninguna opción seleccionada...");
}
}

Sentencias switch anidadas

Cuando un switch forma parte de la secuencia de otro switch, por ejemplo:

switch(x){
case 1:
switch (y){
case 0: printf ("división por cero");
break;
case 1: procesar (x, y);
}
break;
case 2:
}

Bucles for, while y do

for


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

inicialización normalmente es una sentencia de asignación, también llamada
variable de control

condición es una expresión relacional que determina cuándo finaliza el bucle

incremento define cómo cambia la variable de control

Actividad:


Con múltiples sentencias, se maneja como un bloque.

Tutorial
Turbo C


ejemplo:

for (x=100;x!=65;x-=5) {
z=sqrt(x);
printf ("La raíz cuadrada de %d, es %f", x, z);
}

Otro ejemplo sería:

void conexión(void)
{
char cad[20];
int x;

for(x=0;x<3&&strcmp(cad,"clave");++x){
printf("Password:");
gets(cad);
}
if(x==3) cerrar();
}

El bucle infinito

Se realiza dejando la expresión condicional vacía, por ejemplo:

for(;;) printf ("Este bucle estará siempre ejecutándosen");

La sentencia break, se usará para dar fin al bucle, por ejemplo:

c='0';
for(;;){
c=getchar(); /*obtener un caracter*/
if (c=='A') break; /*salir del bucle*/
}
printf("Ha pulsado una A...")

este bucle se ejecutará hasta que se pulse una "A"

Los bucles for sin cuerpo

Pueden aplicarse para aumentar la eficiencia de algunos algoritmos o para
originar retardos.

Tutorial
Turbo C


ejemplo:

for(t=0;t<ALGUN_VALOR;t++);

El bucle while

Forma general:

while (condicion) sentencia;

sentencia puede ser vacía, simple o bloque; condición, puede ser cualquier
expresión, diferente de 0

ejemplo:

void esperar_caracter(void)
{
char c;
c='0'; /*inicializa c*/
while (c!='A') c=getchar();
}

do/while

Analiza la condición al final del bucle. El bucle se ejecuta al menos una
vez. Su forma general es:

do{
}while (condición);

ejemplo:

do{
scanf("%d",&num);
}while(num>100);

Lee los números del teclado hasta que encuentra uno menor o igual que 100.

Quizás el uso más común es en rutinas de seleción por menú.

Ejemplo:

void menu(void)

Tutorial
Turbo C


{
char c;

printf("2. Corregir erroresn");
printf("3. Mostrar erroresn");
do{
c=getche();
switch(c){
case '1':
comprobar_ortografia();
break;
case '2':
corregir_errores();
break;
case '3':
mostrar errores();
break;
}
}while (c!='1'&&c!='2'&&c!='3');
}

break

Tiene dos usos: para finalizar un case en switch o forzar la terminación de
un bucle.

ejemplo:

Cuando encuentra break dentro del bucle, éste finaliza de inmediato.

Actividad:


ejemplo:

El siguiente código, puede detener la ejecución del bucle al presionar una
tecla. "kbhit()" devuelve 0 si no se presiona una tecla.

localiza (char *nombre)
{
char tnombre[40];

Tutorial
Turbo C


int pos;

pos=-1;
do {
pos=leer_sig_nombre(tnombre);
if (kbhit()) break;
}while (!strcmp(tnombre, nombre));
return pos;
}

exit()

Esta función permite salir anticipadamente de un programa, y forzar la vuelta
al sistema operativo.

forma general:

void exit(int estado);

Generalmente estado devuelve un cero (0 se usa como argumento para
terminación normal)

ejemplo:

mein(void)
{
if (!tarjeta_color()) exit(1);
jugar();
return 0;
}

Como otro ejemplo, podemos considerar el uso de exit() en una versión de la
función menu() para abandonar el programa y volveer al sistema operativo.

void menu(void)
{
char c;

printf("2. Corregir erroresn");
printf("3. Mostrar erroresn");
printf("4. Salirn");
do{

Tutorial
Turbo C


c=getchar();
switch(c){
case '1':
comprobar();
break;
case '2':
corregir();
break;
case '3':
mostrar();
break;
case '4':
exit(0);
}
}while (c!='1'&&c!='2'&&c!='3');
}

continue

Funciona de manera similar a break, pero en vez de forzar la terminación,
forza una nueva iteración del bucle. Por ejemplo:

do{
scanf("%d", &num);
if(x<0) continue;
printf("%d",x);
}while(x!=100);

esta fracción de código, muestra sólo números positivos.

2.4. Funciones
Las funciones son los bloques constructores de C y el lugar donde se da toda
la actividad del programa.


especificador_de_tipo nombre_de_función(lista_de_parámetros)
{
cuerpo_de_la_función
}

especificador_de_tipo: es el tipo de valor que devuelve la sentencia return
de la función. Si no se especifica ninguno, asume que es un entero.

Tutorial
Turbo C


lista_de_parámetros: son los parámetros separados por comas, que son los
argumentos cuando se llama a la función. Si no tiene parámetros, contiene la
palabra "void".

return

Tiene dos usos importantes: primero, una salida inmediata de la función, o
que vuelva al código que la llamó; segundo, para devolver un valor.

Todas las funciones, excepto las de tipo void, devuelven un valor, y pueden
ser usadas como operando en una expresión.

main() devuelve un código de terminación; 0 significa que el programa ha
terminado normalmente.

Argumentos de las funciones

Si una función va a usar argumentos, debe declarar variables que acepten los
valores de los argumentos, éstas se llaman parámetros formales.

ejemplo:

esta_en(char *cad, char c)
{
while (*cad)
if (*cad==c) return 1;
else cad++;
return 0;
}

Prototipos de funciones

Se aplica en C la declaración anticipada tradicional de funciones.

Cualquier función de la biblioteca estándar que se use en un programa debe
estar prototipada. Se debe incluir el archivo de cabecera apropiado.

Tutorial
Turbo C


Archivos de cabecera de Turbo C

Archivo Funciones

alloc.h Asignación dinámica de memoria
assert.h Define la función assert()
bios.h Interface con el BIOS
conio.h Entrada/salida por consola
ctype.h Relacionadas con caracteres
dir.h Relacionadas con directorios
dos.h Interface con el DOS
errno.h Define varios códigos de error
fcntl.h Constantes de tipo UNIX
float.h Límites reales de punto flotante
graphics.h Relacionadas con gráficos
io.h Entrada/salida de bajo nivel
limits.h Límites de enteros
locale.h Específicas de países
math.h Matemáticas
mem.h Manipulación de memoria
process.h Control de procesos
setjmp.h requerido por setjmp() y logjmp()
share.h Compartición de archivos
signal.h Soporte para signal() y raise()
stdargs.h Argumentos de longitud variable
stddef.h Tipos y macros estándar
stdio.h Entrada/salida estándar
stdlib.h Variadas
string.h Relacionadas con cadenas
sysstat.h Constantes relacionadas con archivos
systimeb.h Soporta la función ftime()
systypes.h Define time_t para hora
time.h Hora y fecha
values.h Constantes varias

2.5. Arrays
Un array es una colección de variables del mismo tipo que se denominan por un
nombre común y diferenciado por un índice.

Arrays unidimensionales


Tutorial
Turbo C


tipo nombre_de_variable[tamaño];

Todos los arrays tienen 0 como índice de su primer elemento, así:

char p[10];

tiene diez elementos, desde p[0] hasta p[9].

Actividad:


Cadenas

El uso más común de array unidimensional es como un string. Termina siempre
con un caracter nulo ('0'), por lo que la declaración debe ser un caracter
más.

strcpy(), strcat(), strlen() y strcmp()

Sus formas generales son:

strcpy(cadena1, cadena2);

Copya la cadena 1 en la cadena 2.

strcat(cadena1, cadena2);

Concatena las cadenas 1 y 2.

strlen(cadena);

Devuelve el número de caracteres de una cadena.

strcmp(cadena1, cadena2);

Compara las cadenas 1 y 2.

Actividad:

>> Desarrolar en TC los programas ejemplo Nos. 21 y 22

Arrays bidimensionales

Tutorial
Turbo C


Son esencialmente un array de arrays unidimensionales.


tipo nombre[tamaño 2a. dimesión] [tamaño 1a. dimensión];

ejemplo:

int d[10][20];

Actividad:

>> Desarrollar en TC los programas ejemplo Nos. 23, 24, 25 y 26

2.6. Punteros
La importancia de los punteros se basa en:
1. Proporcionan los medios por los cuales las funciones modifican sus
argumentos de llamada.
2. Soportan rutinas de asignación dinámica de TC
3. Mejora la eficiencia de ciertas rutinas.
4. Se usan como soportes de ciertas estructuras de datos como las listas
enlazadas y árboles binarios.

Un puntero es una variable que contiene una dirección de memoria, que es la
posición de otra variable. Si eso ocurre, se dice que la variable apunta a la
segunda.

Si una variable en 1004 está apuntada por otra situada en la posición 1000,
esta última contiene el valor 1004

-> Variable puntero

Consiste en un tipo base, un asterisco (*) y el nombre de la variable. Su
forma general es:

tipo *nombre;

-> Los operadores de punteros

Existen dos operadores especiales de punteros: & y *. El ampersand (&) es un
operador monario que devuelve la dirección de memoria de su operando; por
ejemplo:

Tutorial
Turbo C


m=&cuenta;

pone en m la dirección de memoria de la variable "cuenta".

El asterisco (*) es el complemento de &. Es un operador monario que devuelve
el valor de la variable localizada en la dirección que sigue; por ejemplo:

q=*m;

pone el valor de la variable cuenta en q.

Actividad:

>> Desarrollar en TC los programas ejemplo Nos. 27, 28 y 29

2.7. Estructuras, uniones y variables definidas por el usuario
El lenguaje C proporciona cinco formas diferentes de creación de tipos de
datos propios:

1. La estructura es una agrupación de variables bajo un nombre.
2. El campo de bits es una variación de la estructura.
3. La unión permite que la misma parte de memoria sea definido como dos o más
tipos diferentes de memoria.
4. La enumeración es una lista de símbolos.
5. typedef crea un nuevo nombre para un tipo ya existente.

-> estructuras

Es una colección de variables bajo un mismo nombre para mantener junta la
información relacionada.

struct indica al compilador que se está declarando una estructura.


struct etiqueta{
tipo nombre_de_variable;
}variables_de_estructura;

Por ejemplo:

Tutorial
Turbo C


struct dir{
char nombre[30];
char calle[40];
char ciudad[20];
char estado[3];
long int codigo;
}info_dir, binfo, cinfo;

Para referir los elementos individuales de la estructura, se usará el
operador . (punto); por ejemplo:

info_dir.codigo=12345;

printf("%d", info_dir.codigo);

gets(info_dir.nombre);

El uso más común, será el de array de estructuras; primero se declara la
estructura y luego el array.

Por ejemplo:

#define MAX 100
struct inv{
char item[30];
float coste;
int dispo;
}info_inv[MAX];

Actividad:


-> Campos de bits

Método incorporado por C para acceder a un bit individual dentro de un byte.
Será útil cuando:

1. El almacenamiento es limitado, se pueden almacenar varias variables
lógicas en un byte.
2. Ciertos dispositivos transmiten la información codificada en los bits
dentro de bytes.
3. Ciertas rutinas de cifrado necesitan acceder a los bits dentro de los

Tutorial
Turbo C


bytes.


struct etiqueta{
tipo nombre1: longitud;
tipo nombre2: longitud;
. .
. .
. .
tipo nombren: longitud;
}

Los tipos deben ser int, unsigned o signed.

Por ejemplo:

struct dispositivo{
unsigned activo: 1;
unsigned preparado: 1;
unsigned error: 1;
}codigo_disp;

-> Uniones

Una unión es una posición de memoria que es compartida por varias variables
de diferentes tipos, su declaración es similar a una estructura, por ejemplo:

union tipo_n{
int i;
char ch;
};

-> Enumeraciones

Conjunto de constantes enteras con nombre que especifica todos los valores
válidos que una variable de ese tipo pueda tener.


enum etiqueta{lista_de_enumeraciones} variables;

Por ejemplo:

Tutorial
Turbo C


enum moneda{penique, níquel, diez_centavos, cuarto, medio_dolar, dolar};

-> typedef

Permite definir un nuevo nombre de tipo.


typedef tipo nombre;

Por ejemplo:

typedef float balance;

y se puede usar para declarar otras variables, por ejemplo:

balance negativo;

2.8. Entrada salida y archivos de disco
Los conjuntos completos de funciones de E/S definidos en Turbo C son:

1. El sistema de E/S definido por el estándar ANSI, también denominado
sistema de archivos con buffer.
2. El sistema de E/S tipo UNIX, a veces referido como sistema de archivos sin
buffer.
3. Algunas funciones de E/S de bajo nivel que operan directamente sobre el
hardware de la computadora.

-> Flujos y archivos

Flujos: dispositivos, como terminales y controladores de disco y conta son
transformados en dispositivos lógicos llamados flujos. Los hay de texto y
binarios.

Flujos de texto: es una secuencia de caracteres.

Flujos binarios: es una secuencia de bytes con una correspondencia de 1 a 1
con los del dispositivo externo.

Archivos: es un concepto lógico aplicable a cualquier cosa, desde un archivo
de disco hasta una terminal.

Se asocia un flujo con un archivo realizando una operación de apertura.

Tutorial
Turbo C


Se puede desasociar un flujo con un archivo por la operación de cerrar.

Todos los archivos se cierran automáticamente cuando termina main(), devuelve
el control al Sistema Operativo llamando a exit(). Cerrar el archivo, se hece
mediante fclose().

Los archivos no se cierran cuando un programa interrumpe su ejecución por una
llamada a abort().

Al iniciar la ejecución de un programa, se abren cinco flujos de texto
predefinidos:

stdin, stdout, stderr, stdaux, stdprin

definidos con los dispositivos estándar del sistema así:

flujo dispositivo

stdin teclado
stdout pantalla
stderr pantalla
stdaux primer puerto serie
stdprn impresora

-> E/S por consola

-> getche() y putchar()

getche() lee un caracter del teclado y putchar() lo pone en la pantalla.

Actividad:


-> getch()

Trabaja igual que getche(), pero no muestra eco en la pantalla.

-> gets() y puts()

Permiten leer y escribir cadenas de caracteres.

Las funciones más simples que realizan las operaciones de E/S por consola

Tutorial
Turbo C


son:

función Operación

getchar() Lee caracter del teclado, espera por enter
getche() Lee caracter con eco, no espera enter
getch() Lee sin eco, no espera enter
putchar() Escribe caracter en pantalla
gets() Lee cadena del teclado
puts() Escribe cadena en la pantalla

-> E/S por consola y con formato

-> printf()

Especificadores de formato para printf()

especificador aplicación

%c caracter
%d decimal
%i decimal
%e notación científica
%f real
%g %e o %f, el más corto
%o octal
%s cadena
%u decimal sin signo
%x hexadecimal
%% signo %
%p puntero
%n puntero a entero

Por ejemplo:

%05d rellena con ceros para que sea de cinco espacios
%5.7s imprime cadena de al menos 5 y no más de 7 caracteres
%-10.2f ajusta a la izquierda, 10 espacios y dos decimales

Tutorial
Turbo C


-> scanf()

Especificadores de formato para scanf()

especificador aplicación

%c caracter
%d decimal
%i decimal
%e real
%f real
%h corto
%o octal
%s cadena
%x hexadecimal
%p puntero
%n entero con número de caracteres leídos

Por ejemplo:

scanf("%20s", cad); lee sólo 20 caracteres

Funciones más comunes de un sistema de archivos

Función Actividad

fopen() Abre un flujo
fclose() Cierra un flujo
putc() Escribe caracter a un flujo
getc() Lee un caracter de un flujo
fseek() Busca un byte específico en el flujo
fprintf() Hace lo mismo que printf() en un flujo
fscanf() Hace lo mismo que scanf() en un flujo
feof() Cierto si es fin de archivo
ferror() Cierto si hay error
rewind() Resetea al principio del archivo
remove() Elimina archivo

-> fopen()

Abre un flujo y lo asocia con un archivo, su forma general es:

FILE *fopen(*nombre_archivo, *modo);

Tutorial
Turbo C


modo puede tener los valores siguientes:

Modo Significado

"r" Abre archivo de texto, sólo lectura
"w" Abre archivo de texto, sólo escritura
"a" Abre archivo de texto sólo para agregar
"rb" Abre archivo binario para lectura
"wb" Crea archivo binario para escritura
"ab" Crea archivo binario para agregar
"r+" Abre archivo de texto, lectura/escritura
"w+" Crea archivo de texto lectura/escritura
"a+" Abre o crea archivo de texto lectura/escritura
"r+b" Abre binario lectura/escritura
"w+b" Crea archivo binario lectura/escritura
"a+b" Abre o crea archivo binario lectura/escritura
"rt" Abre archivo de texto para lectura
"wt" Crea archivo de texto para escritura
"at" Abre archivo de texto para agregar
"r+t" Abre archivo de texto para lectura/escritura
"w+t" Crea archivo de texto lectura/escritura
"a+t" Abre o crea archivo de texto lectura/escritura

Por ejemplo:

if((fp=fopen("prueba","w"))==NULL){
puts("no se puede abrir el archivon");
exit(1);
}

-> putc()

Escribe caracteres en un flujo abierto con fopen(). Si tiene éxito, devuelve
el caracter escrito, si no, eof().

-> getc()

Lee caracteres de un flujo abierto con fopen().

-> fclose()

Cierra un flujo abierto con fopen().

-> ferror() y rewind()

Tutorial
Turbo C


ferror() determina si ha habido error en una operación, si es así, devuelve
positivo. rewind() inicializa el indicador al principio del archivo.

Actividad:

>> Desarrollar en TC los programas ejemplo Nos. 36, 37 y 38.

-> getw() y putw()

Se usan para leer y escribir enteros de y en un archivo de disco.

-> fputs() y fgets()

Leen y escriben cadenas de caracteres sobre archivos de disco.

-> fread() y fwrite()

Sirven para leer y escribir bloques de datos

-> fseek() y E/S de acceso directo.

Son operaciones de lectura y escritura directa.

-> fprintf() y fscanf()

Se comportan como el printf() y el scanf(), pero redirigidos a un archivo.

Actividad:


2.9. El preprocesador de Turbo C
El preprocesador contiene las siguientes directivas:

#define
#error
#include
#if
#else
#elif
#endif
#ifdef

Tutorial
Turbo C


#ifndef
#undef
#line
#pragma

-> #define

Se usa para definir un identificador y una cadena que será sustituída por el
identificador.


#define nombre_de_macro cadena

Por ejemplo:

#define MS_E "Error estándar en la entradan"
.
.
.
printf(MS_E)

-> #error

Forza a Turbo C a parar la compilación, su forma general es:

#error mensaje_de_error

manda el mensaje de error cuando éste existe.

-> #include

Hace que el compilador incluya otro archivo fuente, debe estar entre comillas
(" ") o entre ángulos (< >), por ejemplo:

#include "stdio.h"
#include <stdio.h>

-> #if, #else, #elif y #endif

Si la expresión constante que sigue a #if es cierta, se compila el código que
hay entre ella y #endif


Tutorial
Turbo C


#if expresión_constante
secuencia_dfe_sentencias
#endif

Por ejemplo:

#include <stdio.h>
#define MAX 100
main (void)
{
#if MAX>99
printf("Compilado para arrays mayores de 99n");
#endif
return 0;
}

El #else proporciona una alternativa:

#include <stdio.h>
#define MAX 100
main(void)
{
#if MAX>99
printf("Compilado para arrays mayores de 99n");
#else
printf("Compilado para arrays pequeñosn");
#endif
return 0;
}

#elif establece una escala if-else-if para opciones de compilación múltiples.

#if expresión
sentencias
#elif expresión1
sentencias
#elif expresión2
sentencias
.
.
.
#elif expreiónN

Tutorial
Turbo C


sentencias
#endif

Por ejemplo:

#define USA 0
#define GB 1
#define ESP 2
#define PAIS_ACTIVO ESP

#if PAIS_ACTIVO==USA
char moneda[]="dólar";
#elif PAIS_ACTIVO==GB
char moneda[]="libra";
#else
char moneda[]="peseta";
#endif

-> #ifdef y #ifndef

Significan "si definido" y "si no definido". Su forma general es:

#ifdef nombre_de_macro
sentencias
#endif

Por ejemplo:

#include <stdio.h>
#define TED 10
main(void)
{
#ifdef TED
printf("HOla, Ted!n");
#else
printf("Hola, quienquiera que seas!n");
#endif
return 0;
}

-> #line

Es el número de línea que se está compilando. Su forma general es:

Tutorial
Turbo C


#line numero <<nombre_archivo>>

-> #pragma

Permite que se den varias instrucciones conforme al compilador; su forma
general es:

#pragma nombre

donde nombre puede ser:

inline argused
saveregs exit
warn startup
option

argused, precede a una función y se usa para prevenir mensajes de advertencia
cuando no se usa la función.

exit, especifica una o más funciones que se llamarán al terminar el programa.

startup, especifica una o más funciones que se llamarán nada más al comenzar
la ejecución del programa.


#pragma exit función prioridad
#pragma startup función prioridad

prioridad es un valor entre 64 y 255, si no se especifica, es 100.

Actividad:


2.10. Funciones gráficas y de pantalla.
Las funciones de E/S básicas de texto para ventanas son:

cprintf() escribe salida con formato
cputs() escribe cadena
cputch() escribe un caracter
getche() lee un caracter

Tutorial
Turbo C


cgets() lee una cadena

Funciones de Turbo C para manipulación de la pantalla de texto:

clrscr() limpia ventana
clreol() borra hasta fin de línea
delline() borra la línea
gettext() copia parte del texto al buffer de memoria
gotoxy() coloca cursos en la posición indicada
insline() inserta línea vacía
movetext() copia texto de una parte a otra
puttext() copia texto de buffer a pantalla
textmode() establece modo texto en la pantalla
window() define y activa una ventana

Sus formas generales son:

-> clrscr();

-> clreol();

-> delline();

-> insline();

-> gotoxy(x,y);

x=1..80 y=1..25

-> gettext(izquierda, arriba, derecha, abajo, *buffer);

-> puttext(izquierda, arriba, derecha, abajo, *buffer);

buffer=filas x columnas x 2

-> movetext(arriba, izquierda, derecha, abajo, nuevoarriba, nuevoizquierda);

-> window(izquierda, arriba, derecha, abajo);

Actividad:

>> Desarrollar en TC el programa ejemplo No. 45.

Tutorial
Turbo C


Las funciones de los atributos de texto son:

highvideo() alta intensidad
lowvideo() baja intensidad
normvideo() intensidad original
textattr() texto y fondo en color
textbackground() color de fondo
textmode() modo de video

-> highvideo()

-> lowvideo()

-> normvideo()

-> textcolor(color)

color:

BLACK 0 BROWN 6 LIGHTRED 12
BLUE 1 LIGHTGRAY 7 LIGHTMAGENTA 13
GREEN 2 DARKGRAY 8 YELLOW 14
CYAN 3 LIGHTBLUE 9 WHITE 15
RED 4 LIGHTGREEN 10 BLINK 128
MAGENTA 5 LIGHTCYAN 11

-> textattr(atributo)

atributo: FONDO*16 | TEXTO

-> textmode(modo)

modo:

BW40 0 Blanco y negro, 40 columnas
C40 1 Color, 40 columnas
BW80 2 Blanco y negro, 80 columnas

C80 3 Color, 80 columnas
MONO 7 Monocromo, 80 columnas
LASTMODE -1 Modo anterior
C4350 64 EGA 80X43, VGA 80X25

Tutorial
Turbo C


Las funciones de estado de la pantalla de texto son:

gettextinfo() Información sobre ventana
wherex() Coordenada de x
wherey() Coordenada de y

Actividad:


Funciones de gráficos:

initgraph(), para poner el adaptador en modo gráfico, su forma es:

initgraph(*controlador, *modo, *camino);

Controladores y modos:

Controlador Modo Equivalente Resolución

CGA CGAC0 0 320X200
CGAC1 1 320X200
CGAC2 2 320X200
CGAC3 3 320X200
CGAHI 4 640X200
MCGA MCGAC0 0 320X200
MCGAC1 1 320X200
MCGAC2 2 320X200
MCGAC3 3 320X200
MCGAMED 4 640X200
MCGAHI 5 640X480
EGA EGALO 0 640X200
EGAHI 1 640X350
EGA64 EGA64LO 0 640X200
EGA64HI 1 640X350
EGAMONO EGAMONOHI 3 640X350
HERC HERCMONOHI 0 720X348
ATT400 ATT400C0 0 320X200
ATT400C1 1 320X200
ATT400C2 2 320X200
ATT400C3 3 320X200
ATT400CMED 4 640X200
ATT400CHI 5 640X400

Tutorial
Turbo C


Controlador Modo Equivalente Resolución

VGA VGALO 0 640X200
VGAMED 1 640X350
VGAHI 2 640X480
PC3270 PC3270HI 0 720X350
IBM8514 IBM8514HI 0 1024X768
IBM8514LO 0 640X480

-> Gráficos básicos

-> putpixel()

Pone un punto en la pantalla. Forma general:

putpixel(x,y,color);

-> line()

Dibuja una línea. Forma general:

line(x1,y1,x2,y2);

-> circle()

Dibuja un círculo. Forma general:

circle(x,y,radio):

-> setcolor()

Color del dibujo. Forma general:

setcolor(color);

-> floodfill()

Rellenar figura cerrada. Forma general:

floodfill(x,y,colorborde);

-> setfillstyle()

Cambia la manera de rellenar objetos. Forma general:

Tutorial
Turbo C


setfillstyle(patron,color);

patron:

EMPTY_FILL 0 Rellena color del fondo
SOLID_FILL 1 Rellena color liso
LINE_FILL 2 Rellena con líneas
LTSLASH_FILL 3 Rellena con barras finas
SLASH_FILL 4 Rellena con barras
BKSLASH_FILL 5 Rellena con barras invertidas
LTBKSLASH_FILL 6 Rellena con barras invertidas finas
HATCH_FILL 7 Rellena con trama fina
XHATCH_FILL 8 Rellena con trama
INTERLEAVE_FILL 9 Rellena con puntos espaciados
WIDE_DOT_FILL 10 Rellena con puntos muy espaciados
CLOSE_DOT_FILL 11 Rellena con puntos poco espaciados
USER_FILL 12 Rellena con patrón de usuario

Ejemplo:

circle(320,175,100);
setfillstyle(SOLID_FILL, GREEN);
floodfill(500,250,1);

Otro ejemplo:

void borde(void)
{
line(0,0,639,0);
line(0,0,0,349);
line(0,349,639,349);
line(639,0,639,349);
}

-> Texto en modo gráfico

-> outtext()

Pone texto en la pantalla en modo gráfico. Forma general:

outtext(cadena);

-> settextstyle()

Tutorial
Turbo C


Define estilo, tamaño y dirección del texto. Forma general:

settextstyle(fuente,dirección,tamaño);

fuente:
DEFAULT_FONT 0
TRIPLEX_FONT 1
SMALL_FONT 2
SANS_SERIF_FONT 3
GOTHIC_FONT 4

dirección:

HORIZ_DIR 0
VERT_DIR 1

tamaño:

0 a 10

Actividad:


-> outtextxy()

Escribe texto en una posición determinada. Su forma general es:

outtextxy(x,y,*cad);

Funciones de control de la pantalla gráfica:

clearviewport() Limpia ventana gráfica
getimage() Copia parte de un gráfico al buffer de memoria
imagesize() Devuelve el número de bytes de una imagen
putimage() Copia buffer a pantalla
setactivepage() Qué página de afectará por los gráficos
setviewpart() Crea ventana gráfica
setvisualpage() Determina la página que se muestra

Actividad:


Tutorial
Turbo C


3. La biblioteca de Turbo C
3.1. Funciones de E/S

-> access(*archivo,modo);

lib=io.h

Comprueba archivos, modo:

0 sí existe
1 es ejecutable
2 se le puede escribir
4 se puede leer
6 acceso de lectura/escritura

Por ejemplo:

access("PRUEBA.PRU", 0);

-> _chmod(*archivo,fijar,atributo);

lib=io.h

Establece el byte de atributo para un archivo.

atributo:

FA_RDONLY sólo lectura
FA_HIDDEN oculto
FA_SYSTEM de sistema

Por ejemplo:

_chmod("PRUEBA.PRU",1,FA_RDONLY);

-> chmod(*nombre,modo);

lib=io.h

Cambia el modo a un archivo

modo:

Tutorial
Turbo C


S_IWRITE Escribirse
S_IREAD Leerse

Por ejemplo:

chmod("PRUEBA.PRU",S_IREAD|S_IWRITE);

-> chsize(manejador,tamaño);

lib=io.h

Aumenta o reduce el tamaño de un archivo, por ejemplo:

chsize(manejador,256);

-> clearerr(FILE *flujo);

lib=stdio.h

inicializa a cero el indicador de error. Por ejemplo:

clearerr(fp);

-> close(dat);
-> _close(dat);

lib=io.h

Cierra un archivo. Por ejemplo:

close(arch);
_close(arch);

-> creat(*archivo,modo);
-> _creat(*archivo,atrib);
-> creatnew(*archivo,atrib);
-> creattemp(*archivo,atrib);

lib=io.h

creat(), crea un nuevo archivo, modo es S_IWRITE, S_IREAD.

_creat(), crea un archivo nuevo, pero atrib tiene los valores de FA_RDONLY,

Tutorial
Turbo C


FA_HIDDEN, FA_SYSTEM.

creatnew(), si ya existe, devuelve error.

creattemp(), crea un archivo temporal.

-> dup(manejador);
-> dup2(manejador,manejador_nuevo);

lib=io.h

Devuelven el descriptor de archivo, es decir, lo duplica. Por ejemplo:

FILE *pa, *pa2;
.
.
.
pa2=dup(pa);

-> eof(arch);

lib=io.h

Devuelve 1 si es fin de archivo, Por ejemplo:

eof(arch);

-> fclose(FILE *flujo);
-> fcloseall(void);

lib=stdio.h

Cierra archivos.

-> fdopen(manejador, modo);

lib=stdio.h

Abre un archivo.

-> feof(FILE *flujo);

lib=stdio.h

Tutorial
Turbo C


Indica fin de archivo para flujo.

-> ferror(FILE *flujo);

lib=stdio.h

Si es cero, no hay errores.

-> fflush(FILE *flujo);

lib=stdio.h

El contenido del buffer de salida se escribe a archivo.

-> fgetc(FILE *flujo);

lib=stdio.h

Obtiene el siguiente caracter del flujo e incrementa posición.

-> fgetchar();

lib=stdio.h

Igual que el anterior.

-> fgetpos(FILE *flujo, *pos);

lib=stdio.h

Guarda el valor de posición del archivo.

-> fgets(*cad, num, FILE *flujo);

lib=stdio.h

lee caracteres del flujo, como cadena.

-> filelenght(manejador);

lib=io.h

longitud en bytes de un archivo.

Tutorial
Turbo C


-> fileno(FILE *flujo);

lib=stdio.h

Devuelve descriptor de archivo.

-> flushall();

lib=stdio.h

Graba físicamente todos los buffers de salida.

-> fopen(*nombre, *modo);

lib=stdio.h

Abre archivo.

-> fprintf(FILE *flujo, *formato, argumentos);

lib=stdio.h

Escribe en el flujo los argumentos.

-> fputc(c, FILE *flujo);

lib=stdio.h

Escribe un caracter c en el flujo.

-> fputchar(c);

lib=stdio.h

Escribe el caracter c en stdout().

-> fputs(*cad, FILE *flujo);

lib=stdio.h

Escribe la cadena en el flujo.

-> fread(*buf, tam, cuenta, FILE *flujo);

Tutorial
Turbo C


lib=stdio.h

Lee el número de caracteres que se indican.

-> freopen(*nombre, *modo, FILE *flujo);

lib=stdio.h

Reabre un archivo.

-> fscanf(FILE *flujo, *formato, argumentos);

lib=stdio.h

Lee una cadena del flujo.

-> fseek(FILE *flujo, desp, origen);

lib=stdio.h

realiza búsqueda en archivo.

-> fsetpos(FILE *flujo, pos, *pos);

lib=stdio.h

Apunta a un lugar especificado.

-> fstat(manejador, stat, *bufstat);

lib=sysstat.h

Llena el buffer con información.

-> ftell(FILE *flujo);

lib=stdio.h

Devuelve indicador de posición del archivo.

-> fwrite(*buf, tam, cuenta, FILE *flujo);

lib=stdio.h

Tutorial
Turbo C


Escribe en un flujo.

-> getc(FILE *flujo);

lib=stdio.h

Devuelve un caracter desde el flujo.

-> getch();

lib=conio.h

Lee un caracter de la consola.

-> getche();

lib=conio.h

Lee un caracter del teclado, haciendo eco.

-> getchar();

lib=stdio.h

Lee un caracter de tipo string desde la consola.

-> gets(*cad);

lib=stdio.h

Lee una cadena desde la consola.

-> getw(FILE *flujo);

lib=stdio.h

Lee el siguiente entero de un flujo.

-> isatty(manejador);

lib=io.h

Devuelve <>0 si manejador está asociado con terminal, consola, impresora o
COM1.

Tutorial
Turbo C


-> lock(manejador, desp, longitud);

lib=io.h

Protege una parte del programa para no ser usado hasta que se desbloquee.

-> lseek(manejador, desp, origen);

lib=io.h

Hace búsquedas de tipo UNIX.

-> open(*nombre, acceso, modo);
-> _open(*nombre, acceso);

lib=io.h

Abren un archivo con un modo de acceso.

-> perror(*cad);

lib=stdio.h

Convierte el valor a cadena.

-> printf(*formato, argumentos);

lib=stdio.h

Escribe en la pantalla una cadena con formato.

-> putc(c, FILE *flujo);

lib=stdio.h

Escribe el caracter c a un flujo.

-> putchar(c);

lib=stdio.h

Escribe el caracter c a la pantalla.

Tutorial
Turbo C


-> puts(*cad);

lib=stdio.h

Escribe una cadena en la pantalla.

-> putw(i, FILE *flujo);

lib=stdio.h

Escribe un entero en un flujo.

-> read(da, *buf, cuenta);
-> _read(da, *buf, cuenta);

lib=io.h

Leen un byte del archivo y lo colocan en el buffer de memoria.

-> remove(*nombre);

lib=stdio.h

Borra el archivo especificado.

-> rename(*anterior, *nuevo);

lib=stdio.h

Renombra un archivo.

-> rewind(FILE *flujo);

lib=stdio.h

Mueve el indicador al principio del flujo.

-> scanf(*formato, argumentos);

lib=stdio.h

Lee datos desde el teclado, con formato.

-> setbuf(FILE *flujo, *buf);

Tutorial
Turbo C


lib=stdio.h

Determina el buffer del flujo.

-> setmode(manejador, modo);

lib=io.h

Inicializa un archivo.

-> setvbuf(FILE *flujo, *buf, modo, tam);

lib=stdio.h

Especifica buffer, tamaño y modo.

-> sopen(*nombre, acceso, compart, modo);

lib=io.h

Abre cadenas para acceso.

->sprintf(*buf, *formato, argumentos);

lib=stdio.h

Genera salida hacia el array apuntado por *buf.

-> sscanf(*buf, *formato, argumentos);

lib=stdio.h

Lee cadena por buffer del teclado.

-> stat(*nombre, *bufstat);

lib=sysstat.h

Llena el buffer con la información del archivo.

-> tell(da);

lib=io.h

Tutorial
Turbo C


Devuelve el indicador de posición del archivo.

-> *tmpfile();

lib=stdio.h

Abre un archivo temporal.

-> *tmpnam(*nombre);

lib=stdio.h

Abre un archivo temporal con nombre.

-> ungetc(c, FILE *flujo);

lib=stdio.h

Devuelve un caracter del byte menos significativo.

-> unlink(*nombre);

lib=dos.h

Elimina el archivo especificado.

-> unlock(manejador, desp, longitud);

lib=io.h

Desbloquea un archivo bloqueado.

-> vprintf(*formato, argumentos);
-> vfprintf(FILE *flujo, *formato, argumentos);
-> vsprintf(*buf, *formato, argumentos);

lib=stdio.h y stdarg.h

Imprimen datos con formato.

-> vscanf(*formato, argumentos);
-> vfscanf(FILE *flujo, *formato, argumentos);
-> vsscanf(*buf, *formato, argumentos);

Tutorial
Turbo C


lib=stdio.h y stdarg.h

Leen datos desde el teclado.

-> write(manejador, *buf, cuenta);
-> _write(manejador, *buf, cuenta);

lib=io.h

Escriben cuenta bytes al archivo.

3.2. Funciones de cadenas, de memoria y de caracteres.
-> isalnum(ch);

lib=ctype.h

Devuelve <>0 si es alfanumérico.

-> isalpha(ch);

lib=ctype.h

Devuelve <>0 si es alfabético.

-> isascii(ch);

lib=ctype.h

Devuelve <>0 si es ascii.

-> iscntrl(ch);

lib=ctype.h

Devuelve <>0 si es caracter de control.

-> isdigit(ch);

lib=ctype.h

Devuelve <>0 si está entre 0 y 9.

Tutorial
Turbo C


-> isgraph(ch);

lib=ctype.h

Devuelve <>0 si es caracter gráfico.

-> islower(ch);

lib=ctype.h

Devuelve <>0 si es minúscula.

-> isprint(ch);

lib=ctype.h

Devuelve <>0 si es caracter imprimible.

-> ispunct(ch);

lib=ctype.h

Devuelve <>0 si es signo de puntuación.

-> isspace(ch);

lib=ctype.h

Devuelve <>0 si es espacio.

-> isupper(ch);

lib=ctype.h

Devuelve <>0 si es letra mayúscula.

-> isxdigit(ch);

lib=ctype.h

Devuelve <>0 si es hexadecimal.

-> *memccpy(*dest, *orig, ch, cuenta);

Tutorial
Turbo C


lib=string.h y mem.h

Copia el contenido de memoria de origen a destino.

-> *memchr(*buffer, ch, cuenta);


Busca ch en los primeros cuenta caracteres.

-> memcmp(*buf1, *buf2, cuenta);
-> memicmp(*buf1, *buf2, cuenta);


Compara los cuenta caracteres entre los dos arrays.

-> *memcpy(*hacia, *desde, cuenta);


Copia cuenta caracteres desde y hacia.

-> *memmove(*hacia, *desde, cuenta);


Mueve los cuenta caracteres desde y hacia.

-> *memset(*buf, ch, cuenta);


Copia el LSB de ch en los cuenta primeros caracteres del array en buf.

-> movedata(origseg, origdesp, destseg, destdesp, cuenta);


Copia cuenta caracteres desde la posición orig hasta destino.

-> movemem(*orig, *dest, cuenta);

lib=mem.h

Tutorial
Turbo C


Copia cuenta caracteres de origen a destino.

-> setmem(*buf, cuenta, ch);

lib=mem.h

Copia ch en los cuenta caracteres del array.

-> *stpcpy(*cad1, *cad2);

lib=string.h

Copia cadena 1 en cadena 2.

-> *strcat(*cad1, *cad2);

lib=string.h

Concatena las cadenas 1 y 2.

-> *strchr(*cad, ch);

lib=string.h

Es un puntero al LSB de ch.

-> strcmp(*cad1, *cad2);

lib=string.h

compara cadena 1 con cadena 2.

-> strcoll(*cad1, *cad2);

lib=string.h

Compara la cadena 1 con la cadena 2.

-> *strcpy(*cad1, *cad2);

lib=string.h

Copia cadena 1 en cadena 2.

Tutorial
Turbo C


-> strcspn(*cad1, *cad2);

lib=string.h

Devuelve la longitud de la subcadena constituida por los caracteres que no
están en la cadena 2.

-> *strdup(*cad);

lib=string.h

Duplica la cadena.

-> *_strerror(*cad);

lib=stdio.h y string.h

Muestra la cadena, dos puntos y el mensaje de error producido por el
programa.

-> *strerror(num);

lib=stdio.h y string.h

Devuelve un puntero a un mensaje de error.

-> stricmp(*cad1, *cad2);
-> strcmpi(*cad1, *cad2);

lib=string.h

Comparan dos cadenas.

-> strlen(*cad);

lib=string.h

Devuelve el número de caracteres de la cadena.

-> *strlwr(*cad);

lib=string.h

Tutorial
Turbo C


Convierte la cadena a minúsculas.

-> *strncat(*cad1, *cad2, cuenta);

lib=string.h

Concatena cuenta caracteres de cad2 a cad1.

-> strncmp(*cad1, *cad2, cuenta);
-> strnicmp(*cad1, *cad2, cuenta);
-> strncmpi(*cad1, *cad2, cuenta);

lib=string.h

Comparan lexicográficamente cad1 y cad2.

-> *strncpy(*dest, *orig, cuenta);

lib=string.h


-> *strnset(*cad, ch, cuenta);

lib=string.h

Pone ch en cuanta caracteres de cad.

-> *strpbrk(*cad1, *cad2);

lib=string.h

Apunta al primer caracter de cad1 que coincida con cad2.

-> *strrchr(*cad, ch);

lib=string.h

Apunta al LSB de ch en cad.

-> *strrev(*cad);

lib=string.h

Tutorial
Turbo C


Invierte el orden de la cadena.

-> *strset(*cad, ch);

lib=string.h

Pone ch en toda la cadena.

-> strspn(*cad1, *cad2);

lib=string.h

Devuelve la intersección de las cadenas.

-> *strstr(*cad1, *cad2);

lib=string.h

Apunta la primera ocurrencia de cad2 en cad1.

-> *strtok(*cad1, *cad2);

lib=string.h

Apunta la siguiente palabra de cad1.

-> *strupr(*cad);

lib=string.h

Convierte la cadena a mayúsculas.

-> strxfrm(*dest, *orig, cuenta);

lib=string.h


-> tolower(ch);
-> _tolower(ch);

lib=ctype.h

Devuelve ch en minúscula.

Tutorial
Turbo C


-> toupper(ch);
-> _toupper(ch);

lib=ctype.h

Devuelve ch en mayúscula.

3.3. Funciones matemáticas.

-> acos(arg);

lib=math.h

Arco coseno de arg.

-> asin(arg);

lib=math.h

Arco seno de arg.

-> atan(arg);

lib=math.h

Arco tangente de arg.

-> atan2(x,y);

lib=math.h

Arco tangente de y/x.

-> cabs(znum);

lib=math.h

Valor absoluto de un número complejo.

-> ceil(num);

lib=math.h

Tutorial
Turbo C


Menor entero mayor o igual que num.

-> cos(arg);

lib=math.h

Coseno de arg.

-> cosh(arg);

lib=math.h

Coseno hiperbólico de arg.

-> exp(arg);

lib=math.h

e a la arg potencia.

-> fabs(num);

lib=math.h

Valor absoluto de num.

-> floor(num);

lib=math.h

Mayor entero no mayor de num.

-> fmod(x,y);

lib=math.h

Resto de x/y.

-> frexp(num, *exp);

lib=math.h

mun será igual a la mantisa por 2 a la exp.

Tutorial
Turbo C


-> hypot(x.y);

lib=math.h

Hipotenusa de x e y.

-> ldexp(num, exp);

lib=math.h

Devuelve num por 2 a la exp.

-> log(num);

lib=math.h

Logaritmo de num.

-> log10(num);

lib=math.h

Logaritmo base 10 de num.

-> matherr(*err);

lib=math.h

Estructura de errores matemáticos.

-> modf(num, *i);

lib=math.h

Descompone en entero y fracción.

-> poly(x, n, c[]);

lib=math.h

Evalúa polinomio x grado n desde c[0] hasta c[n].

-> pow(base, exp);

Tutorial
Turbo C


lib=math.h

Base elevado a la exp.

-> pow10(n);

lib=math.h

Devuelve 10 a la n.

-> sin(arg);

lib=math.h

Seno de arg.

-> sinh(arg);

lib=math.h

Seno hiperbólico de arg.

-> sqrt(num);

lib=math.h

Raíz cuadrada de num.

-> tan(arg);

lib=math.h

Tangente de arg.

-> tanh(arg);

lib=math.h

Tangente hiperbólica de arg.

3.4. Funciones de hora, fecha y otras del sistema.
-> absread(unidad, numsects, sectnum, *buf);

Tutorial
Turbo C


-> abswrite(unidad, numsects, sectnum, *buf);

lib=dos.h

Lectura y escritura desde y a disco.

-> *asctime(*punt);

lib=time.h

Devuelve cadena con los datos de fecha.

-> bdos(dx, al);
-> bdosptr(fnum, *dsdx, al)

lib=dos.h

Pone dx en el registro dx y al en el registro al.

-> bioscom(orden, byte, puerto);

lib=bios.h

Manipula el puerto RS232-C.

-> biosdisk(orden, unidad, cabeza, pista, sector, nsects, *buf);

lib=bios.h

Opera en disco a nivel del bios.

-> biosequip();

lib=bios.h

Devuelve el valor del equipo existente.

-> bioskey(orden);

lib=bios.h

Operaciones directas de teclado.

-> biosmemory();

Tutorial
Turbo C


lib=bios.h

Devuelve la cantidad de memoria instaladas en el sistema.

-> biosprint(orden, byte, puerto);

lib=bios.h

Controla el puerto de la impresora.

-> biostime(orden, nuevahora);

lib=bios.h

Ajusta el reloj del sistema.

-> clock();

lib=time.h

Tiempo de ejecución hasta la llamada.

-> *country(codigo_pais, *puntpais);

lib=dos.h

Ajusta elementos del país.

-> ctime(*tiempo);

lib=time.h

Cadena de tiempo.

-> ctrlbrk((*fptr)());

lib=dos.h

Realiza la función de Ctrl-Break.

-> delay(tiempo);

lib=dos.h

Tutorial
Turbo C


Detiene el tiempo de ejecución tiempo milisegundos.

-> difftime(hora2, hora1);

lib=time.h

Diferencia en segundos entre hora1 y hora2.

-> disable();

lib=dos.h

Inhibe las interrupciones.

-> dosexterr(DOSERROR *err);

lib=dos.h

Información extensa de error.

-> dostounix(*d, *t);

lib=dos.h

Hora en formato UNIX.

-> enable();

lib=dos.h

Habilita las interrupciones.

-> FP_OFF(*punt);
-> FP_SEG(*punt);

lib=dos.h

Desplazamiento del puntero.

-> ftime(*hora);

lib=systimeb.h

Tutorial
Turbo C


Información completa sobre la hora del sistema.

-> geninterrupt(intr);

lib=dos.h

Genera interrupción por software.

-> getcbrk();

lib=dos.h

Devuelve 0 si está desactivada ctrl-brk.

-> getdate(*d);
-> gettime(*t);

lib=Rellena date o time con fecha y hora del sistema.

-> getdfree(unidad, *dfpunt);

lib=dos.h

Obtiene el espacio libre en el disco.

-> *getdta();

lib=dos.h

Dirección de transferencia de disco.

-> getfat(unidad, *fpunt);
-> getfatd(*fpunt);

lib=dos.h

Devuelve información sobre la FAT del disco.

-> getftime(manejador, *fpunt);

lib=io.h

Obtiene fecha y hora del sistema.

Tutorial
Turbo C


-> getpsp();

lib=dos.h

Obtiene el PSP.

-> interrupt(*vect(intr))();

lib=dos.h

Devuelve la dirección de la rutina de interrupción.

-> getverify();

lib=dos.h

Estado de verificable del DOS.

-> *gmtime(*hora);

lib=time.h

Apunta a la forma de hora en la estructura tm.

-> harderr((*int)());
-> hardresume(cod);
-> hardretn(cod);

lib=dos.h

Reemplaza el manipulador de errorres del DOS.
El manejador sale a DOS y vuelve código.
El hardretn() retorna el código al programa.

-> inport(port);
-> inportb(port);

lib=dos.h

Devuelve el valor de la palabra leída en el puerto.
Devuelve un byte leído del puerto.

-> int86(int, *reg_e, *reg_s);
-> int86x(int, *reg_e, *reg_s, *segregs);

Tutorial
Turbo C


lib=dos.h

Ejecuta interrupción de software.
Copia los valores de segregs -> ds en DS y ->es en ES.

-> intdos(*reg_e, *reg_s);
-> intdosx(*reg_e, *reg_s, *segregs);

lib=dos.h

Accede a la interrupción de DOS 21H.
El valor de segregs lo pone en DS y ES.

-> intr(intr, *reg);

lib=dos.h

Ejecuta la interrupción especificada.

-> keep(estado, tam);

lib=dos.h

El programa en tam bytes queda residente y devuelve el estado a DOS.

-> *localtime(*hora);

lib=time.h

Apunta a la hora ->tm.

-> mktime(*p);

lib=time.h

Convierte la hora en calendario equivalnte.

-> *MK_FP(seg, desp);

lib=dos.h

Devuelve puntero a far en segmento seg y desp desplazamiento.

Tutorial
Turbo C


-> outport(puerto, palabra);
-> outportb(puerto, byte);

lib=dos.h

Pone palabra o byte en puerto.

-> *parsfnm(*nombre, *fcbpunt, opción);

lib=dos.h

Convierte nombre de archivo en cadena.

-> peek(seg, desp);
-> peekb(seg, desp);
-> poke(seg, desp, palabra);
-> pokeb(seg, desp, byte);

lib=dos.h

Valor en 16 bits de la posición seg:desp.
Valor en 8 bits de la posición seg:desp.
Almacena valor de 16 bits de la posición seg:desp.
Almacena valor de 8 bits de la posición seg:desp.

-> randbrd(*fcbpunt, cuenta);
-> randbwr(*fcbpunt, cuenta);

lib=dos.h

Lee cuenta número de registros.
Escribe cuenta número de registros.

-> segread(*sregs);

lib=dos.h

Copia valores actuales del segmento.

-> setcbrk(cb);

lib=dos.h

Activa o desactiva la comprobación.

Tutorial
Turbo C


-> setdate(*d);
-> settime(*t);

lib=dos.h

Pone fecha del DOS.
Pone hora del DOS.

-> setdta(*dta);

lib=dos.h

Ajusta la dirección de transferencia de disco a 4000:000.

-> setftime(manejador, *t);

lib=io.h

Ajusta hora y fecha a manejador.

-> setvect(intr, (*rsi)());

lib=dos.h

Coloca la interrupción rsi en la tabla.

-> setverify(valor);

lib=dos.h

Ajusta el indicador de verify de DOS.

-> sleep(tiempo);

lib=dos.h

Suspende la ejecución tiempo segundos.

-> stime(*t);

lib=time.h

Pone hora de DOS en el valor t.

Tutorial
Turbo C


-> time(*hora);

lib=time.h

Devuelve la hora del DOS.

-> tzset();

lib=time.h

Ajusta las variables de tiempo.

-> unixtodos(uhora, *d, *t);

lib=dos.h

Convierte la hora de formato UNIX a formato DOS.

3.5. Funciones de asignación dinámica de memoria.
-> allocmem(tam, *seg);

lib=dos.h

Coloca tam párrafos en seg para uso de la memoria.

-> brk(*fsd);

lib=alloc.h

cambia la cantidad de memoria a usarse.

-> *calloc(num, tam);

lib=stdlib.h

Asigna memoria de tam en bytes a num objetos.

-> coreleft();

lib=alloc.h

Número de bytes libres de memoria.

Tutorial
Turbo C


-> *farcalloc(num, tam);

lib=alloc.h

Idéntica a calloc().

-> farcoreleft();

lib=alloc.h

Idéntica a coreleft().

-> farfree(*ptr);

lib=alloc.h

Libera memoria asignada lejana.

-> *farmalloc(tam);

lib=alloc.h

Apunta al primer byte de memoria lejana.

-> *farrealloc(*ptr, nuevotam);

lib=alloc.h

Cambia un bloque de tamaño.

-> free(*ptr);

lib=stdlib.h

Libera la memoria apuntada.

-> freemem(seg);

lib=dos.h

Librea el bloque de memoria.

-> heapcheck();
-> farheapcheck();

Tutorial
Turbo C


lib=alloc.h

Examinan la pila en busca de errores.

-> heapcheckfree(relleno);
->farheapcheckfree(relleno);

lib=alloc.h

Verifica que estén llenas con relleno.

-> heapchecknode(*ptr);
-> farheapchecknode(*ptr);

lib=alloc.h

Comprueban el estado del nodo.

-> heapfillfree(relleno);
-> farheapfillfree(relleno);

lib=alloc.h

Rellenan bloques libres con relleno.

-> heapwalk(*inform);
-> farheapwalk(*inform);

lib=alloc.h

Rellena los campos de esa estructura.

-> *malloc(tam);

lib=stdlib.h

Apunta a una región de tam bytes.

-> *realloc(*ptr, nuevotam);

lib=stdlib.h

Cambia el tamaño de memoria.

Tutorial
Turbo C


-> *sbrk(cantidad);

lib=alloc.h

Incrementa en cantidad bytes la memoria.

-> setblock(seg, tam);

lib=dos.h

Cambia el tamaño del bloque seg a tam.

3.6. Funciones de directorio.
-> chdir(*camino);

lib=dir.h

Convierte a camino en directorio actual.

-> findfirst(*nombrear, *ptr, atrib);
-> findnext(*ptr);

lib=dir.h

Busca el archivo que coincida con nombrear.

-> fnmerge(*camino, *unidad, *dir, *nombrear, *ext);
-> fnsplit(*camino, *unidad, *dir, *nombrear, *ext);

lib=dir.h

Construye el nombre de un archivo en base a sus componentes.
Descompone el nombre de archivo.

-> getcurdir(unidad, *dir);

lib=dir.h

Copia el directorio actual de trabajo en cadena dir.

-> *getcwd(*dir, long);

Tutorial
Turbo C


lib=dir.h

Copia el camino completo, hasta long caracteres.

-> getdisk();

lib=dir.h

Devuelve el número de unidad actual (1,A; 2,B; 3C; etc.)

-> mkdir(*camino);

lib=dir.h

Crea un directorio usando el camino.

-> *mktemp(*nombrear);

lib=dir.h

Crea un nombre de archivo único y lo copia a nombrear.

-> rmdir(*camino);

lib=dir.h

Borra un directorio.

-> searchpath(*nombrear);

lib=dir.h

Devuelve el camino donde está el archivo.

-> setdisk(unidad);

lib=dir.h

Devuelve el número de unidades del sistema.

3.7. Funciones de control de procesos.
-> abort();

Tutorial
Turbo C


lib=process.h y stdlib.h

Terminación inmediata del programa.

-> atexit((*func)());

lib=stdlib.h

Si termina normalmente, llama a la función.

-> execl(*nombrear, *arg0,...,*argn, NULL);
-> execle(*nombrear, *arg0,...,*argn, NULL, *pent[]);
-> execlp(nombrear, *arg0,...,*argn, NULL);
-> execlpe(*nombrear, *arg0,...,*argn, NULL, *pent[]);
-> execv(*nombrear, *arg[]);
-> execve(*nombrear, *arg[], *pent[]);
-> execvp(*nombrear, *arg[]);
-> execvpe(*nombrear, *arg[], *pent[]);

lib=process.h

Ejecutan un programa externo.

-> exit(estado);
-> _exit(estado);

lib=process.h y stdlib.h

Terminación normal inmediata del programa.

-> spawnl(modo, *nombrear, *arg0,...,*argn, NULL);
-> spawnle(modo, *nombrear, *arg0,...,*argn, NULL, *pent[]);
-> spawnlp(modo, *nombrear, *arg0,...,*argn, NULL);
-> spawnlpe(modo, *nombrear, *arg0,...,*argn, NULL, *pent[]);
-> spawnv(modo, *nombrear, *arg[]);
-> spawnve(modo, *nombrear, *arg[], *pent[]);
-> spawnvp(modo, *nombrear, *arg[]);
-> spawnvpe(modo, *nombrear, *arg[], *pent[]);

lib=process.h

Ejecuta archivos externos.

Tutorial
Turbo C


3.8. Funciones de gráficos y de la pantalla de texto.
-> arc(x,y,inicio,fin,radio);

lib=graphics.h

Dibuja un arco desde inicio hasta fin grados con centro en x,y y de radio
radio.

-> bar(izq,arr,der,aba);
-> bar3d(izq,arr,der,aba,prof,indtapa);

lib=graphics.h

Realiza una barra en dos y tres dimensiones.

-> circle(x,y,radio);

lib=graphics.h

Círculo con centro en x,y y radio radio.

-> cleardevice();
-> clearviewport();

lib=graphics.h

Limpia pantalla y restablece a 0,0.
No existen más ventanas gráficas.

-> closegraph();

lib=graphics.h

Desactiva el entorno gráfico.

-> clreol();
-> clrscr();

lib=conio.h

Limpia hasta fin de línea.
Limpia ventana de texto.

Tutorial
Turbo C


-> cprintf(*fmt);

lib=conio.h

Escribe en ventana de texto.

-> cputs(*cad);

lib=conio.h

Escribe cadena a pantalla.

-> cscanf(*fmt);

lib=conio.h

Lee cadena del teclado.

-> delline();

lib=conio.h

Borra línea actual.

-> detectgraph(*controlador, *modo);

lib=graphics.h

Detecta el tipo de controlador gráfico.

-> drawpoly(numpuntos, *puntos);

lib=graphics.h

Dibuja un polígono.

-> ellipse(x,y,inicio,fin,radiox,radioy);

lib=graphics.h

Dibuja una elipse con centro en x,y, la parte mostrada entre iniciio y fin en
grados (0..360) y longitudes radiox y radioy.

-> fillellipse(x,y,rx,ry);

Tutorial
Turbo C


lib=graphics.h

Dibuja y rellena una elipse, con centro en x,y y radios rx y ry.

-> fillpoly(numpuntos, *puntos);

lib=graphics.h

Rellena un polígono.

-> floodfill(x,y,borde);

lib=graphics.h

Rellena un objeto cerrado.

-> getarcoords(*coords);

lib=graphics.h

Da valores a los campos de la estructura de coords.

-> getaspectratio(*xasp, *yasp);

lib=graphics.h

Razones de aspecto de un objeto.

-> getbkcolor();

lib=graphics.h

Devuelve el color de fondo actual.

-> getcolor();

lib=graphics.h

Devuelve el color actual del dibujo.

-> getdefaultpalette();

lib=graphics.h

Tutorial
Turbo C


Devuelve la paleta por defecto.

-> getdrivername();

lib=graphics.h

Devuelve el nombre del controlador de gráficos.

-> getfillpattern(*patron);

lib=graphics.h

-> getfillsettings(*info);

lib=graphics.h

Da valor a la estructura de info.

-> getgraphmode();

lib=graphics.h

Devuelve el modo de registro actual.

-> getimage(izq,arr,der,aba,*buf);

lib=graphics.h

Copia una porción de pantalla a buffer.

-> getlinesettings(*info);

lib=graphics.h

Da valores a las estructuras de info.

-> getmaxcolor();

lib=graphics.h

Mayor valor válido para el color actual.

-> getmaxmode();

Tutorial
Turbo C


lib=graphics.h

Modo máximo disponible.

-> getmaxx();
-> getmaxy();

lib=graphics.h

Mayor valor de x o y.

-> getmodename(modo);

lib=graphics.h

Nombre del modo especificado.

-> getmoderange(controlador, *modobajo, *modoalto);

lib=graphics.h

Modos que soporta el controlador.

-> getpalette(*pal);

lib=graphics.h

Carga la estructura con paleta actual.

-> getpalettesize();

lib=graphics.h

No. de colores de la paleta actual.

-> getpixel(x,y);

lib=graphics.h

Color del pixel en esas coordenadas.

-> gettext(izq,arr,der,aba,*buf);

Tutorial
Turbo C


lib=conio.h

Copia el texto de esas coordenadas a buffer.

-> gettextsettings(*info);

lib=graphics.h

carga la estructura con valores de info.

-> getviewsettings(*info);

lib=graphics.h

Información sobre ventana gráfica actual.

-> getx();
-> gety();

lib=graphics.h

Devuelven x e y de posición actual.

-> gotoxy(x,y);

lib=conio.h

Sitúa al cursos de la pantalla de texto.

-> graphdefaults();

lib=graphics.h

Restaura el sistema gráfico por default.

-> grapherrormsg(coderror);

lib=graphics.h

Apunta al mensaje de error.

-> _graphfreemem(*ptr, tam);
-> _graphgetmem(tam);

Tutorial
Turbo C


lib=graphics.h

Devuelve el valor de última operación gráfica.

-> highvideo();

lib=conio.h

Alta intensidad de video.

-> imagesize(izq,arr,der,aba);

lib=graphics.h

Bytes necesarios para almacenar imagen.

-> initgraph(*controlador, *modo, *camino);

lib=graphics.h

Inicializa sistema de gráficos.

-> insline();

lib=conio.h

Inserta línea en blanco.

-> installuserdriver(*controlador, (*func)());

lib=graphics.h

Instala controladores BGI creados por otros.

-> installuserfont(*nomfuente);

lib=graphics.h

Instala fuentes trazadas por otros.

-> line(xini,yini,xfin,yfin);
-> lineto(x,y);
-> linerel(deltax,deltay);

Tutorial
Turbo C


lib=graphics.h

Traza una línea desde ini hasta fin.
Traza una línea desde CP hasta x,y.
Traza una línea desde cp hasta dx y dy.

-> lowvideo();

lib=conio.h

Video de baja intensidad.

-> moverel(deltax,deltay);

lib=graphics.h

Se desplaza desde CP hasta dx y dy.

-> movetext(izq,arr,der,aba,nuevaizq,nuevaarr);

lib=conio.h

Mueve área a nueva izq y arr.

-> moveto(x,y);

lib=graphics.h

Mueve el cursor desde CP hasta x,y.

-> normvideo();

lib=conio.h

Intensidad normal.

-> outtext(*cad);
-> outtextxy(x,y,*cad);

lib=graphics.h

Muestra texto en modo gráfico.

-> pieslice(x,y,inicio,fin,ratio);

Tutorial
Turbo C

Turbo c++

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (16)

Destacado

Destacado (9)

Similar a Turbo c++

Similar a Turbo c++ (20)

Turbo c++