0x07: Tutorial de programacion en C

eZine lover (@eZine)

Published in 

Systat Security Team

 · 1 year ago

Este tutorial se organiza de la siguiente manera:

• INTRODUCCION A LA PROGRAMACION Y AL LENGUAJE C
• DEFINICION Y TIPOS DE VARIABLES EN C
• ESTRUCTURAS DE CONTROL DE FLUJO, BUCLES
• ESTRUCTURAS CONDICIONALES
• INTERACCION CON EL USUARIO
• FUNCIONES
• FUNCIONES CON PARAMETROS
• ARRAYS
• PUNTEROS
• ESTRUCTURAS
• FICHEROS
• STRINGS
• ALGUNOS EJEMPLOS
• APENDICE (PENDIENTE)

INTRUCCION A LA PROGRAMACION Y AL LENGUAJE C

El concepto programacion se refiere a crear programas por supuesto, para esto es necesario crear un codigo especifico, es ahi donde nacen los lenguajes de programacion. Cada lenguaje es distinto, lo que se hace es escribir este codigo en un editor de texto (normalmente) y luego un compilador lo traduce a lenguaje maquina, o sea a un ejecutable. C es un lenguaje de programacion para el que no lo sepa, este lenguaje es muy poderoso, los sistemas UNIX estan escritos en C. Cada lenguaje tiene su sintaxis, en C lo basico que hay que saber es que un programa siempre tiene lo siguiente:

 ----8<-----8<-----8<------8<-------8<-------8<--------8<------- 
 void main() 
 { 

 } 
 ----8<-----8<-----8<------8<-------8<-------8<--------8<--------

eso es un programa ya en si, solo que no hace nada, tiene justo lo basico para que no te aparesca algun error al compilarlo. void se refiere al tipo de funcion que es main(), main() esta presente en todos los programas escritos en C, es aqui donde empieza nuestro programa. las llaves( { y } ) indican el principio y el final de la funcion. Quiza por ahora todo esto suene confuso, pero vas a ver que al final de los tres proximos capitulos ya no tendras ningun problema. Otra cosa que hay que recalcar es el uso de librerias, para hacer mas facil nuestro trabajo, por ejemplo si yo quiciera escribir en la pantalla un mensaje, tendria que incluir la libreria stdio.h , esto se hace de la siguiente manera

 #include<stdio.h>

y ahora todas las funciones de esas librerias las puedes usar. Veamos el ejemplo mas basico que se escribe con cada lenguaje cuando recien se comienza:

 ------8<---------8<--------8<---------8<------------8<---------- 
 #include<stdio.h> 

 void main() 
 { 
 printf("Hola mundo\n"); 
 } 
 -----8<----------8<------------8<---------8<---------8<---------

este programa solo escribira Hola mundo en la pantalla, \n es para que salte linea, o sea, que haga como un enter.cada instruccion en C termina con un ' ; '. Para los que usan windows pueden bajar el turboC de http://tcpp.homepage.com , es muy facil de usar, los que usan linux, deben tenerlo instalado, solo escriban el programa y luego ejecuten: cc programa.c el ejecutable quedara en el mismo directorio con el nombre de a.out.

DEFINICION Y TIPOS DE VARIABLES EN C

Primero es necesario saber que es una variable, una variable es un dato que puede variar durante la ejecucio de un programa (fisicamente es un espacio de memoria donde se almacena un dato). Hay distintos tipos de variables, numericas, alfanumericas, etc. Cada tipo de variable tiene un nombre.

para declarar una variable en un programa se escribe el tipo de variable y luego el nombre que le quieres dar a esa variable en particular, por ejmplo a continuacion voi a declarar 3 variables.

• int variableuno;
• char caracter;
• int variabledos;

ahora necesitamos poder operar estas varibles, las operaciones en C son:

Operadores aritmeticos:

• +:suma
• -:resta
• *:multiplicacion
• /:division
• %:modulo(resto de la division)
• ++:incremento
• --:decremento

Operadores de relacion (lo usaremos en el proximo capitulo)

• ==:igual a
• !=:distinto que
• <:menor que
• <=:menor o igual que
• >:mayor que
• >= :mayor o igual que

Operadores logicos (tambien los usaremos a partir del proximo capitulo)

• !: no logico(NOT)
• &&:Y logico(AND)
• || :O logico(OR)

Operadores de asignacion

• =:asignacion simple
• +=:suma y asignacion
• -=:resta y asignacion
• *=:multiplicacion y asignacion
• /=:division y asignacion
• %=:modulo y asignacion

Operadores de direccion (estos no los tomes mucho en cuenta por ahora)

• &:direccion de variable
• * :operador de direccionamiento

Ahora la gracia es poder dar los resultados, por ejemplo hagamos un programa que sume dos numeros:

 -------------------------------------------------------------- 
 #include<stdio.h> 

 void main() 
 { 
 int uno; 
 /* Declaro la primera variable */ 

 int dos; 
 /* Declaro la variable numero dos */ 

 int tres; 
 /* Y por ultimo declaro la variable donde pondre el resultado */ 

 uno=5; 
 dos=7; 
 /* Asigno un valor a las variables */ 

 tres=uno+dos; 
 /* Asigno el valor de la variable tres como la sume de uno y dos */ 

 printf(" La suma de %d y %d es igual a %d \n",uno,dos,tres); 
 /* imprimo en la pantalla el resultado */ 
 } 
 --------------------------------------------------------------

Aqui si haz leido todo lo anterior, la unica cosa nueva seria el printf(" La suma de %d y %d es igual a %d \n",uno,dos,tres); analizemoslo:

 printf();

es la funcion que viene en la libreria stdio.h

" La suma de %d y %d es igual a %d \n" es lo que queremos imprimir, pero que significan esos %d, bueno esa es la forma de imprimir un variable, se pone % luego la letra que identifica a la variable segun la siguiente tabla y las variables se ponen separadas por comas a lado.

 %      			Tipo de variable 

 c				caracter 
 d, i				numero entero 
 e, E				notacion cientifica 
 f, g, G			float o double 
 n				puntero a entero 
 o				octal 
 p				puntero 
 s				String(cadena de caracteres) 
 u				unsigned 
 x, X				hexadecimal

Y aprovechando el vuelo con la funcion printf(); aprovechemos de completarla, con los distintos \

 \				Accion 

 a				pitido 
 b				retroceso 
 f				nueva pagina o pantalla 
 n				nueva linea 
 r				retorno de carro 
 t				tabulador horizontal 
 v				tabulador vertical 
 \				signo \ 
 '				signo ' 
 "				comillas 
 OOO				digitos octales 
 xHHHH				digitos hexadecimales

Para dejarlo mas claro modifiquemos el ejemplo anterior de las siguiente manera:

 -------------------------------------------------------------- 
 #include<stdio.h> 

 int main() 
 { 
 int uno; 
 /* Declaro la primera variable */ 

 int dos; 
 /* Declaro la variable numero dos */ 

 int tres; 
 /* Y por ultimo declaro la variable donde pondre el resultado */ 

 uno=5; 
 dos=7; 
 /* Asigno un valor a las variables */ 

 tres=uno+dos; 
 /* Asigno el valor de la variable tres como la sume de uno y dos */ 

 printf(" La suma de %d y %d es igual a %d \n",uno,dos,tres); 
 printf(" %d es 0x%X en hexadecimal\n"); 
 printf(" Ahora voi a dormir 10 segundo, te avisare cuando despierte\n"); 
 sleep(10); 
 printf("\a Desperte!!!!\n"); 
 /* imprimo en la pantalla el resultado */ 
 return 0; 
 } 
 --------------------------------------------------------------

Ese ejemplo si lo compilas en linux no tendras problemas, en TurboC tendrias que dejarlo asi:

 -------------------------------------------------------------- 
 #include<stdio.h> 
 #include<conio.h> 

 int main() 
 { 
 int uno; 
 /* Declaro la primera variable */ 

 int dos; 
 /* Declaro la variable numero dos */ 

 int tres; 
 /* Y por ultimo declaro la variable donde pondre el resultado */ 

 uno=5; 
 dos=7; 
 /* Asigno un valor a las variables */ 

 tres=uno+dos; 
 /* Asigno el valor de la variable tres como la sume de uno y dos */ 

 printf(" La suma de %d y %d es igual a %d \n",uno,dos,tres); 
 printf(" %d es 0x%X en hexadecimal\n"); 
 printf(" Ahora voi a dormir 10 segundo, te avisare cuando despierte\n"); 
 delay(10000); 
 printf("\a Desperte!!!!\n"); 
 /* imprimo en la pantalla el resultado */ 
 return 0; 
 } 
 --------------------------------------------------------------

La diferencia entre los dos compiladores es que en linux puedo usar la funcion sleep(numero de segundos); la cual no estoi seguro si esta en DOS/WIN. Y en el TurboC cuento con una libreria llamada conio.h en la cual tengo la funcion delay(); que puedo especificar el numero de milisegundos que quiero cngelar el programa. Para los que usen el TurboC o TurboC++, la libreria conio.h simplifica mucho la programacion demenus y esas cosas, si alguno de ustedes esta interesado en eso que me contacte, ya que no lo especificare en este articulo, debido a que se sale de el objetivo mismo.

ESTRUCTURAS DE CONTROL DE FLUJO, BUCLES

La gracia de un programa por supuesto no es simplemente que solo sume y no haga nada mas, la gracia es que tenga opciones y varie su ejecucion, para eso sirven los bucles.

DO...WHILE

la sintaxis de esta instruccion es la siguiente:

 do 
 { 
 (instrucciones, cuantas quieras) 
 }while(condicion con la que finaliza el bucle);

Lo que hace este bucle es ejecutarse cuantas veces sea necesario, mientras se cumpla la condicion propuesta.

Un ejemplo seria:

--------------------------------------------------------- 
 #include<stdio.h> 

 int main() 
 { 
 int control; 
 control=0; 
 do 
 { 
 control++; 
 printf(" contando %d \n",control); 
 sleep(1); 
 }while(control<20); 
 sleep(3); 
 printf(" Acabo de contar hasta 20\n\n"); 
 } 
---------------------------------------------------------

Este programa esta escrito para linux, si usas TurboC, ya sabes con la informacion de arriba puedes adaptarlo.

WHILE

Esta es muy parecida a la anterior, la diferencia es que la condicion se evalua antes de ejecutar las instrucciones del bucle, en contraste con la anterior, donde se evaluavan al final, la anterior simpre se ejecuta minimo una vez, esta por el contrario puede ser que de repente no se ejecute.

Sintaxis:

 while(condicion propuesta) 
 { 
 (instrucciones varias) 
 }

ejemplo:

----------------------------------------------------------------- 
 #include<stdio.h> 

 main() 
 { 
 int variable=0; 

 while(variable!=5) 
 { 
 printf(" La variable es distinta a 5\n"); 
 printf(" La variable es %d\n\n",variable); 
 variable++; 
 } 

 while(variable!=5) 
 { 
 printf(" La variable es 5\n"); 
 } 
} 
-------------------------------------------------------------------

Si te fijas, el segundo bucle no se ejecutara nunca, ya que la variable es 5.
Este programa correra sin problemas en TurboC.

ADEVERTENCIA

   while() 
   {

este while no lleva ; al final, sino lo mas probable es que consigas un cuelgue, ya que no se ejecutaria nunca el bucle y se quedaria pegado en el while.

FOR

Este bucle se ejecuta un numero determinado de veces o simplemente se puede escribir para que funcion parecido a los otros dos.

Sintaxis:

 for(asignacion;condicion;operacion) 
 { 
 (instrucciones) 
 }

Ejemplo:

---------------------------------------------------- 
 #include<stdio.h> 

 main() 
 { 
 int x; 
 for(x=0;x<20;x++) 
 { 
 printf(" %d \n",x); 
 } 
 } 
---------------------------------------------------

Esto imprimira desde el 0 al 19. Definamos los conceptos por si acaso.

asignacion: aqui se asina la o las variables
condicion: aqui se establece la condicion de salida, pueden ser mas de una como veremos mas adelante
operacion: aqui se incluyen instrucciones de modificacion a las variables de control

Todo esto puede variar, porque como se imaginan, nosotros buscamos hacer cosas raras jaja.

CONSEJO. fijate como van los ; en estas estructuras, es importante ponerlos correctamente, ademas puedes asignar mas de una variable, al igual que se pueden realizar mas de 2 comparaciones o operaciones.

ESTRUCTURAS CONDICIONALES

Las estructuras condicionales son parecidas a las de control de flujo, la diferencia es que estas no se repiten un numero de veces, see ejecutan una vez.

IF...ELSE

sintaxis:

 if(condicion propuesta) 
 { 
 (instrucciones) 
 } 
 else 
 { 
 (instrucciones que se ejecutan si no se cumple) 
 }

else se puede omitir, se pueden poner bucles y mas if dentro de uno, y asi mezclar.

Ejemplo:

---------------------------------------------------- 
 #include<stdio.h> 

 main() 
 { 
 int x; 
 x=1; 
 if(x==1) 
 { 
 printf(" x es uno \n"); 
 } 
 else 
 { 
 printf(" x no es uno \n"); 
 } 
 } 
-------------------------------------------------

la instruccion if es muy util para la programacion como iras viendo a medida que crees tus propios programas. La parte de else se puede eliminar en caso de que sea necesario, o sea, el programa podria quedar asi:

-------------------------------------------------- 
 #include<stdio.h> 

 main() 
 { 
 int x; 
 x=1; 
 if(x==1) 
 { 
 printf(" x es uno \n"); 
 } 
 } 
---------------------------------------------------

SWITCH

Esta es una estructura condicional muy util, pero mas especifica.

sintaxis:

 switch(variable) 
 { 
 case valor1:(instrucciones) 
             break; 
 case valor2:(instrucciones) 
             break; 
 case valor3:(instrucciones) 
 	      break; 
 default:(instrucciones) 
 }

Lo que esta instruccion hace es ejecutar la parte de instrucciones que corresponda al valor de la variables, la final(default) no es obligatoria, y lo que hace es ejecuarse en caso de que el valor de la variable no coincida con ninguna.

Ejemplo:

----------------------------------------------------- 
 #include<stdio.h> 

 main() 
 { 
 char x; 
 printf("Presiona una tecla..."); 
 x=getchar(); 
 switch(x) 
 { 
 case 'b': printf(" opcion b\n"); 
           break; 
 case 'a': printf(" opcion a \n"); 
 	    break; 
 default: printf(" No le pegaste a una  ;) \n\n"); 
 } 
 } 
----------------------------------------------------

Con eso ya puedes controlar los distintos rumbos que puede llevar tus programas. he usado la funcion getchar(), la cual viene explicada en el siguiente item.

INTERACCION CON EL USUARIO

Esta parte es importante en la programacion, porque no nos sirve mucho un prorama que siempre haga lo mismo. Veamos las funciones basicas nada mas:

getchar() devuelve una tecla presionada.
ej:

x = getchar();

(Esta ya se vio abajo.)

gets(cadena) lee una cadena de caracteres del teclado.

Ejemplo:

--------------------------------------------------------- 
#include<stdio.h> 

main() 
{ 
char cadena[30]; 
/* Aqui defini una cadena de caracteres, proto veras esto en los arrays */ 

printf("Ingresa alguna frase:\n"); 
gets(cadena); 
printf("La frase que  escribste fue: %s\n\n",cadena); 
return 0; 
} 
-----------------------------------------------------------

AVISO: gets() es una funcion insegura, puede explotarse este programa.

Bueno, si te preocupas de entender bien los ficheros puedes jugar con stdin, stdout y stderr y hacer algunas cosas mas interesantes, al igual que es muy importante el aprender el uso de ficheros.

FUNCIONES

Esto es una parte muy importante en la programacion, por ejemplo C no tiene una instruccion que imprima caracteres en la pantalla, imaginate si cada vez que quizieras imprimir algo, tuvieras que escribir todo el codigo de la funcion printf(); para imprimir un mensaje, los programas serian kilometricos, para eso las funciones nos hacen ahorrar tiempo creando una parte del programa que simplemente se llama, con un ejemplo te quedara mas claro.

 ---------------------------------------------------------- 
 #include<stdio.h> 

 void funcion() 
 { 
 printf("Hola\n"); 
 } 

 void main() 
 { 
 funcion(); 
 funcion(); 
 } 
 -----------------------------------------------------------

ves la gracia es simplemente escribir asi una funcion, y despoues solo la llamas como se muestra ahi. Ahora la gracia es usar funciones que pasen valores entre si.

FUNCIONES CON ARGUMENTOS

Estas son iguales que las anteriores, pero se pasan valores. Tambien dificil de explicar, pero veras que con un ejemplo se aclara.

 int sumar(int a, int b) 
 { 
 int c; 
 c=a+b; 
 return c 
 }

En este ejemplo aparecieron muchas cosas nuevas, una es int antes de la funcion, esto quiere decir que la funcion devuelve un dato de tipo int, por ejemplo yo podria asignar una variable en el programa asi:

 c=sumar(3,5);

o

 c=sumar(variable1,variable2);

y esto me retona el valor, con return [valor o variable]
y los parametros ya te abras dado cuenta cuales son, fijate que tambien se declara el tipo de variable que es el parametro.

Ejemplo:

------------------------------------------------- 
#include<stdio.h> 

 int sumar(int a, int b) 
 { 
 int c; 
 c=a+b; 
 return c 
 } 

main() 
{ 
int uno; 
int dos; 
int tres; 

uno=2; 
dos=4; 
tres=sumar(uno,dos); 

printf("La suma de %d y %d luego de calcularlo con la funcion sumar() es 
%d",uno,dos,tres); 

} 
-----------------------------------------------------

ARRAYS

Los arrays son conjuntos o matrices, un string es un array de chars o sea u conjunto de chars.

como se declaran:

char esteesarray[largo];

y se accede a cada dato asi:

esteesarray[numero del dato];

los arrays son muy utiles, especialmente para los strings.

Veamos un ejemplo:

---------------------------------------- 
#include<stdio.h> 

main() 
{ 
 char cadena[30]; 
 printf("Ingresa una cadena: "); 
 gets(cadena); 
 printf(" %s\n",cadena); 
} 
---------------------------------------

este pedazo de codigo lee una cadena del teclado y la imprime, la cadena es un array, tambien puedes crear arrays de int y cosas asi eso lo dejo a tu imaginacion, cualquier duda me escribes.

Los arrays tambien pueden tener mas de una dimension, pero no varia mucho el uso, por ejemplo de dos dimensiones

 char dos[2][3];

ahi tengo 12 chars!!!!

Eso es porque el array parte desde 0, o sea...

 dos[0][0] 
 dos[0][1] 
 dos[0][2] 
 dos[0][3] 
 dos[1][0] 
 ... 
 dos[2][3]

estos los puedes tratar como cualquier variable de la misma manera que lo hemos hecho durante todo el texto.

PUNTEROS

Esto es algo ya mas avanzado quiza, pero no por eso no hay que aprenderlo, por el contrario es muy importante y los usaremmos mucho en nuestra labor como hacker, porque son muy flexibles y poderosos como veras a continuacion.

Cada variable tiene una direccion en la memoria como se vio en el principio, los punteros lo que hacen es apuntar a estas direcciones, lo que en verdad se almacena en la direccion fisica del puntero es la direccion a la variable que apunta. Veamos el ejemplo mas claro que existe para esto:

(los punteros se declaran. tipo de variable a la q apuntan * nombre) para entender los & y *, vuelve a los operadores y pegales una releida.

 --------------------------------------------------------------- 
 #include<stdio.h> 

 void main() 
 { 
 int variable; 
 int * puntero; 
 variable = 5; 
 puntero = &variable; 
 printf("puntero %d\n",puntero); 
 printf("direccion variable %d\n",&variable); 
 printf("valor a lo apuntado por puntero %d\n",*puntero); 
 printf("valor variable %d\n",variable); 
 } 
----------------------------------------------------------------- 

El resultado de esto es: 

bash-2.03# ./prog 
puntero -1073743644 
direccion variable -1073743644 
valor a lo apuntado por puntero 5 
valor variable 5

Analizemoslo.

puntero -1073743644
el valor que tiene la variable puntero es -1073743644

direccion variable -1073743644
Esta es la direccion de memoria donde se almacena el valor de variable.

valor a lo apuntado por puntero 5
El valor de la casilla de memori a la que apunta puntero es 5

valor variable 5
El valor de variable es 5

Ahi puedes sacar tus propias conclusiones.

Con eso ya quedo mas o menos clara la idea de un puntero, ahora es importante tambien saber que los punteros se pueden modificar, haciendolos mas grandes o peque§os, para que apunte una casilla mas abajo o mas arriba. Eso se hace sumandole valores especificos, ahi tu puedes probar y jugar un poco, te doi una idea...

Ejemplo:

----------------------------------------------- 
#include<stdio.h> 

main() 
{ 

char * puntero; 
int x; 
char cadena[]="Hola esta es una cadena"; 
puntero=cadena; 
printf("%s \n%s \n\n",puntero,cadena); 
} 
------------------------------------------------ 
Resultado: 
bash-2.03# ./prog 
Hola esta es una cadena 
Hola esta es una cadena

ESTRUCTURAS

Las estructuras son conjuntos de variables agrupadas, por ejjemplo si tu quisieras crear un software de control de stock para una mepresa(como me pidieron a mi), no te conviene hacer un array de strings para los nombres, otro de int para los presios y todo eso, lo mejor seria crear una estructura que contenga todo eso. Una estructura se crea de la siguiente manera:

 struct{ 
 int uno; 
 int dos; 
 int tres; 
 char cuatro; 
 }estructura;

para acceder a cada una de estas variables, se hace asi:

 estructura.uno 
 estructura.dos 
 estructura.tres 
 estructura.cuatro

Esto nos sirve para estructuras definidas, donde serviria una por elemento, por ejemplo para una biblioteca uno por libro, en este caso eso si es mas facil definir un tipo tu mismo que sea una estructura, eso lo harias asi:

 typedef struct{ 
 char nombre[20]; 
 int codigo; 
 int precio; 
 }libro_e;

definiendo esto en el cuerpo del programa y luego en main() definirias esto:

 libro_e libros[30];

para acceder a cada uno de las vaiables y distintos libros harias esto:

 libro[n].nombre[c]

pensando que c y n son variables numericas.

Esto de jugar con las variables ya lo hemos hecho bastante, asique ahi puedes ver tu que utilidad le das a esto, yo lo use una vez que un amigo necesitaba un programa de stock, para crear una estructura que gusradar toda la informacion de un producto. Eso queda a tu imaginacion.

FICHEROS

Los ficheros son muy importantes para por ejemplo guardar datos, en el caso del ejemplo anterior el programa de control de stock, no servia si solo ingresabas los datos y al correrlo de nuevo estaba de nuevo en 0, la gracia es que mantenga los valores, y para eso usaremos los fichero, obviamente tambien para editar, crear utilidades y con fines de otro tipo.

Un fichero se declara de la siguiente manera(para usarlos debes incluir

la libreria stdio.h en C estandar):

 FILE * archivo;

con esto creaste un puntero a la estructura llamada FILE, definida en la libreria stdio.h.

ahora esto es solo un puntero, para abrir ahora el fichero se usa la funcion fopen(), y se utiliza de la siguiente forma:

 archivo = fopen(nombrefichero, modo);

nombrefichero representa el PATH y el nombre de archivo del archivo que queremos cerrar, y modo representa el modo en el que lo queremos abrir, las cuales pueden ser:

• r:Lectura(error si el fichero no existe)
• w:Escritura(si el fichero existe, borra su contenido)
• a:A§adir al final del archivo(lo crea si no existe)
• r+:Lectura y escritura(error si el fichero no existe)
• w+:Lectura y escritura(borra su contenido)
• a+:Lectura y a§adir(lo crea si no existe)
• b:Indica que el fichero es de tipo binario

Las opciones w y w+ crean el fichero en caso de que no exista.

ahora las funciones mas imprtantes para el uso de ficheros:

 fread(dato,tama§o dato,size_t numdato,FILE *fp);

en este caso dato es la variable donde vas a meter lo que leas, tama§o dato es el largo de la variable(lo mas facil es poner sizeof(variable), size_T numdato representa el numero de veces que se debe reperi la lectura, por lo general 1, y el ultimo es nuestro puntero a FILE, o sea nuestro fichero.

 fwrite()

usa el mismo formato de fread, pero para escribir.

Y para terminar, cierras el fichero con

 fclose(FILE *archivo);

en nuestro ejemplo de FILE * archivo definido anteriormente, seria:

 fclose(archivo);

Y sin duda una de las mas importantes, fprintf();

esta funciona asi:

 fprintf(archivo," ... ", variables);

Con eso ya deberias escribir fichero, por lo menos lo basico, en todo caso si hasta ahora has tenido algun problema, no te preocupes, porque al final de este tutorial se incluyen las direcciones para bajar los compiladores y algunos ejemplos desde el principio para que te quede todo claro. En todo caso que se me olvidaba, debes cerrar al fichero al finalizar, con la funcion close(fichero);.

Para terminar hagamos un pequeno ejemplo.

--------------------------------------------- 
#include<stdio.h> 

main() 
{ 
FILE * archivo; 
char frase[50]; 
printf("Ingresa una frase, sera guardada en frase.txt\n"); 
fgets(frase,50,stdin); 
archivo = fopen("frase.txt","a+"); 
if(archivo == NULL) 
{ 
 printf("\nLo siento, nos e puede abrir el fichero\n\n"); 
 exit(0); 
} 
fprintf(archivo,"%s\n\n",frase); 
close(archivo); 
} 
------------------------------------------------------ 

RESULTADO: 
bash-2.03# gcc -o prog prog.c 
bash-2.03# ./prog 
Ingresa una frase, sera guardada en frase.txt 
Esta es la frase que guardaremos. 
bash-2.03# cat frase.txt 
Esta es la frase que guardaremos. 

 
bash-2.03# ./prog 
Ingresa una frase, sera guardada en frase.txt 
Aqu agregamos una frase mas... 
bash-2.03# cat frase.txt 
Esta es la frase que guardaremos.

Aqu agregamos una frase mas...

bash-2.03# 
--------------

STRINGS

Los strings son conjuntos o arrays de char, por ejemplo

 char string[21];

esto seria un string de 20 caracteres, porque se cuenta uno menos. Ya que el ultimo se le asigna '\0' que representa el fin de la cadena. La verdad es que los arrays ya los vimos, pero este capitulo es para ver las funciones mas utiles de strings( string.h ).

Las funciones que yo mas uso(personalmente) son tres:

1.- strcpy()
Esta funcion es para copiar cadenas.
Ejemplos

 char caduno[30]; 
 char caddos[30]; 
 caduno="Hola\0"; 
 strcpy(caddos,caduno);

2.- strcmp()
Esta funcion compara strings.
Ejemplo

 int comparacion; 
 char caduno[30]; 
 char caddos[30]; 
 caduno="Hola\0"; 
 caddos="Hola\0"; 
 comparacion=strcmp(caddos,caduno);

si son iguales devuelve 0, si una es mayor o menor varia en 1 o -1.

3.- strcat()
Esta funcion concatena dos cadenas
Ejempo

 char caduno[30]; 
 char caddos[30]; 
 caduno="Hola \0"; 
 caddos="z0rbas\0"; 
 strcat(caduno,caddos);

Despues de esto caduno quedaria asi:

 "Hola z0rbas\0"

OjO: el \0 no es necesario por lo general, la mayoria de las funciones lo ponen por si solas!!

Y sin duda la funcion mas comoda para trabajar con strings, es sprintf(); que viene en la libreria stdio.h, por lo menos para mi es una de mis funciones preferidas, en este ejemplo se daran cuenta porque. ademas voy a mostrarles una funcion muy importante en linux, system(); esta funcion ejecuta algun comando.

Este programa es un pequeno zapper de ejemplo, solo le podre dos ficheros de logs para que veas como funciona.

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

#include<stdio.h> 

main() 
{ 
char comando[200]; 
char * principio="echo \"\" > "; 
sprintf(comando,"%s /var/log/lastlog",principio); 
system(comando); 
sprintf(comando,"%s /var/log/messages",principio); 
system(comando); 
} 

----------------------------------------------------- 
Resultado: 

bash-2.03# gcc -o prog prog.c 
bash-2.03# ./prog 
bash-2.03# ls -la /var/log | grep messages 
-rw-r-----   1 root     root            1 Feb 17 17:46 messages 
bash-2.03# ls -la /var/log | grep lastlog 
-rw-rw-r--   1 root     tty             1 Feb 17 17:46 lastlog 
bash-2.03#

Como puedes ver, los logs quedaron con el tama§o de un byte, o sea, sin nada.

ALGUNOS EJEMPLOS

Aqui pondremos algunos ejemplos muy basicos, pero suficientes para que tu ya puedas empezar a crear tus propios programas. No haremos ejemplos de ficheros y eso por razones de tiempo, pero si tienes algun problema, escribenos y responderemos tus preguntas, no te preocupes. Estos ejemplos son solo para los que recien se inician en la programacion, para que se hagan una idea basica de como funciona. Y entiendan bien los bucles.

Antes de empezar un detalle importante, en tus programas puedes insertar comentarios asi:

 /* aqui todo 
 lo que quieras 
 */

Esto no afecta al tamano del programa, sirve solamente para dejar mas claro el codigo.

Ejemplo 1:

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

#include <stdio.h> 
#include <stdlib.h> 

 void main() 
 { 
 int numero_pensado; 
 int numero_tuyo; 
 char cadena[40]; 
 numero_pensado= 5; 
 do{ 
 printf("Elige un numero entre el 1 y el 10: "); 
 gets(cadena); 
 numero_tuyo = atoi(cadena); 
 if(numero_tuyo<numero_pensado) printf("Mas alto!!\n"); 
 if(numero_tuyo>numero_pensado) printf("Mas bajo!!\n"); 
 }while(numero_pensado!=numero_tuyo); 
 printf("Felicidades, veo que has acertado!!\n"); 
 } 

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

Resultado: 

bash-2.03# ./prog 
Elige un numero entre el 1 y el 10: 1 
Mas alto!! 
Elige un numero entre el 1 y el 10: 2 
Mas alto!! 
Elige un numero entre el 1 y el 10: 3 
Mas alto!! 
Elige un numero entre el 1 y el 10: 4 
Mas alto!! 
Elige un numero entre el 1 y el 10: 5 
Felicidades, veo que has acertado!! 
bash-2.03# 
----------------------

Bueno obviamente este programa no tiene mucha gracia, porque el tipo que lo programo sabe el numero correcto y el que lo juega, con ganar una vez, gana siempre, seria mucho mejor si usaras una funcion random, para que generara un numero aleatorio,

numero_pensado=random(limite);

pero yo creo que el ejemplo cumple su objetivo de mostrar el uso de un bucle do{}while(); de if(); y de algunas funciones de lectura de datos y de escritura.

Ejemplo 2.

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

 /* Programa escrito por z0rbas para el tutorial de C 
    Este programa imprime numeros del 1 a lo especificado 
    No creo que haga falta pero, cualquier duda escribela 
    a the-little@usa.net                               */ 

#include <stdio.h> 
#include <stdlib.h> 

 void main() 
 { 
 int numero; 
 int contador; 
 char cadena[50]; 
 printf("Hasta que numero deseas contar?"); 
 gets(cadena); 
 numero = atoi(cadena); 
 for(contador=0;contador<=numero;contador++) 
   { 
   printf("%d ",contador); 
   } 
 } 
---------------------------------------------------------------- 

Resultado: 
bash-2.03# ./prog 
Hasta que numero deseas contar?50 
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 
30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 bash-2.03# 

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

Este ejemplos esta muy claro, lo que hace es escribir numeros desde 0 hasta lo especificado, separados por un espacio. Sirve yo creo para entender el funcionamiento de FOR(){}

Ejemplo 3.

Este es un ejemplo cortito:

----------------------------------------------------------------------- 
 /* programa escrito por z0rbas para el tutorial de c 
    the-little@usa.net 
    http://www.systat.net  */ 
 void main() 
 { 
 char opcion; 
 printf("\nPresiona una tecla..."); 
 opcion=getchar(); /*funcion q lee un caracter del teclado */ 
 printf("Presionaste la tecla: %c \n",opcion); 
 } 
---------------------------------------------------------------------

muy simple no creo haga falta comentario.
podria poner lo siguiente...

Ejemplo 4.

---------------------------------------------------------------- 
#include <stdio.h> 

 void main() 
 { 
 char opcion; 
 printf("S/N\n"); 
 opcion=getchar(); 
 if(opcion=='S' || opcion=='s') 
  { 
  printf("Elegiste S\n"); 
  exit(0); 
  } 
 printf("No elegiste S\n"); 
 } 
--------------------------------------------------------------

Estos ejemplos creo yo estan muy claros.

Todos los programas que escribi en este tutorial fueron probados en linux y funcionan, en turboC quiza tengas que modificarlos un poco. Puede que en algunos aparezca una adevertencia por dos cosas:

1. Main, que el retorno es incorrecto, agregale return 0; al final
2. que gets es una funcion peligrosa

Ninguna de estas dos advertencias debiese interrumpir la compilacion.

APENDICE (PENDIENTE)

Queda pendiente la programacion de sockets para empezar a conectarnos con otros pcs y a hacer algunas cosillas mas intersantes. Para los que usen TurboC, cambiense a linux porque ahi no van a poder programar sockets, o por lo menos no los que voy a ense§ar en el proximo numero. Con esto ya me despido, espero que les haya servido mi tutorial, cualquier duda ya saben, escribanla al mail del team syst4t@usa.net o a mi personalmente a the-little@usa.net .

Saludos
z0rbas