Últimos Temas de: piou

Fuente http://whitehathacking.wordpress.com
Como no encuentro el botón de editar en el otro post, hago un copypast en este.
Los manuales los podéis seguir arriba en mi blog, la web que está arriba, mejor estructurados que aquí.

Manual de programación en C: Introducción

Empiezo con este artículo una serie de tutoriales con los cualquier interesado podrá iniciarse en la programación en C, decir que no hace falta absolutamente ningún conocimiento previo de programación, y que para cualquier duda puedes contactar conmigo (página Contacto).

Decir que yo se C y lo he aprendido por mi cuenta, así que quizá algunas partes del curso no sean correctas, me gustaría que me enviarais cualquier crítica a mi correo para intentar hacerlo lo mejor posible. Que esto sirva para hacer ver que no hace falta hacer ingeniería de software para poder hacerse programitas que no encontremos por internet, y que todo lo podemos aprender por nuestra cuenta.

Yo sigo aprendiendo programación en otros lenguajes mientras escribo este curso, no soy un profesional; siempre me ha quedado esa sensación después de las clases que me gustaban de que ojalá supiera lo que el profesor, pues eso no va a pasar aquí, porque yo de informática se más bien poco, cuanto más aprendas más te darás cuenta de lo poco que sabes, y C, junto con C# y el facilísimo html son los únicos lenguajes que sé BIEN.
Estructura y creación de un programa.

El siguiente texto no lo entenderás si no has visto nada de programación, pero tranquilo, léelo por encima y cuando vaya avanzando el curso irás viendo lo que es cada cosa, de hecho, si te lo saltas y te quedas con que nosotros escribimos el código y un programa llamado compilador lo traduce al lenguaje del ordenador, de momento te irá bien y no te liarás tanto.

* Lo primero evidentemente es escribir un código que resuelvo un problema que tenemos.
* Ahora viene el preprocesado, un programa cambia los archivos de código, por ejemplo incluye los ficheros de las directivas #include, sustituye los #define, y elimina los comentarios.
* Lo siguiente es el análisis sintáctico. Que no cunda el pánico sobre aquellos que cateaban sobre las faltas de ortografía, pero sí, algunas habrá que aprender, un lenguaje de programación, como todo lenguaje, tienes sus reglas y estas deben cumplirse, este programa devolverá algún fallo y parará el proceso si alguna regla se salta.
* El análisis semántico descubrirá algún otro tipo de fallos lógicos más complejos, por ejemplo si una función intenta guardar una letra en una variable que solo admite números
* Un generador de código recorre el código traduciéndolo a un lenguaje para la máquina en la que se compila.
* Un enlazador (linker) juntará todos los recursos en un solo ejecutable (.exe en MS Windows).

En la práctica no tendremos que hacer esto cada vez que escribamos algo, sino que un mismo programa hace todas las funciones a la vez.
Herramientas que utilizaremos

Intentaré hacer el curso de modo que sea válido en las plataformas windows y gnu/linux, en windows puedes usar cualquier IDE, esto es un programa que incluye un editor, gestión de proyectos completos y un compilador, puedes usar Visual C/C++ (creo que es de pago) o wxDev-C++, gratis y bastante bueno, es una evolución de Dev-C++, que dejó de desarrollarse hace algún tiempo.

Para Linux puedes usar los IDEs NetBeans o MonoDevelop, ambos gratuitos y bastante buenos, aunque para el curso puedes usar gcc, que viene instalado en prácticamente todas las distribuciones de linux, es tan solo compilador de consola en modo texto, no tan pijín como los IDEs pero igual de funcional.
Primer programa

Vamos a hacer un primer programa, el clásico Hola Mundo, solo conseguirás que en la pantalla ponga Hola Mundo, pero por lo menos verás resultados.

Abre tu IDE o cualquier editor de texto y escribe:

Código:

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

int main()
{

 printf(“Hola Mundo\n”);
 return 0;

}

Guárdalo con extensión .c (los ides lo harán ellos solos y compílalo. Si estás usando un IDE habrá un botón que ponga Ejecutar, Compilar y Ejecutar o algo así, si estás en Linux, abre una terminal y muévete a la carpeta donde tengas el archivo holamundo.c, si esta en /home/tnombre/ escribe

Código:

cd /home/tunombre

Ahora pon:

Código:

gcc holamundo.c -o HolaMundo

Este es el compilador, -o sirve para especificar el nombre del ejecutable, si solo pusiéramos gcc main.c, el ejecutable se llamaría a.out, ahora ejecútalo escribiendo ./HolaMundo y verás el resultado.

Puede ser que, sobre todo si estás usando un IDE, aparezca una ventana negra y desaparezca muy rápido, esto es porque el SO cierra el programa cuando llega a return 0; en main, si te pasa eso, prueba a escribir lo siguiente:

Si estás en Windows, escribe

Código:

system(“PAUSE”);

entre las filas printf y return.

Si estás en Linux, prueba poniendo:

Código:

printf(“Press ‘Enter’ to continue: … “);
while ( getchar() != ‘\n’)
;

También entre las filas printf y return, Con las dos harás los mismo, el programa esperará a pulsar una tecla para salir.

Ahora explicaremos cada linea.

Código:

#include <stdio.h>

Esta función lo que hace es llamar a la librería stdio.h, stdio significa standard input/output.

Las librerías las podemos entender así, como un sitio al que vamos a buscar algo, solo que aquí hay miles de librerías según lo que queramos hacer.

Supongamos que nos da por construir un coche, en vez de comprarlo nos da la vena de mecánico y decidimos construirlo, tenemos dos opciones, podemos construir el coche desde cero, inventándonos un motor, fabricando todas las piezas nosotros mismos, o podemos ir a una biblioteca e informarnos sobre el tema, así como usar piezas usadas de modo que sea más sencillo. Esto es lo que hacen las librerías (del inglés library, debería ser traducido como biblioteca, pero todo el mundo usa librería, y si no puedes vencerlos, únete a ellos), nos dan funciones ya programadas para que hacer nuestro programa sea más fácil y menos tedioso. Ya veremos más adelante cómo se usan incluso cómo hacer nuestras propias librerías.

Código:

#include <stdlib.h>

Lo mismo que antes, ahora incluimos la librería stdlib (standard library), también con algunas funciones standard que nos pueden ser útiles.

Código:

int main()

Aquí decimos que empieza el programa, esta es la manera de definir una función, en este caso llamada main, aunque ya veremos las funciones más adelante, quédate con el programa se empieza a ejecutar por esta linea int main().

Código:

este signo es muy importante e indica que aquí empieza la función main, todo lo que haya dentro de la función main debe ir entre un { de inicio y un } de final, estos dos símbolos indican el inicio y final de cualquier estructura o bloque en C.

Código:

printf(“Hola Mundo\n”);

printf es una función que pertenece a la librería stdio.h. Si no hubiéramos incluido esa librería al intentar compilar nos habría dado un error diciendo que no ha encontrado la función printf. Lo que hay entre paréntesis son los datos que usará la función, conocidos como parámetros. printf toma una cadena de caracteres, en este

caso Hola Mundo\n y la escribe en la pantalla. Es importante decir que en C las cadenas de caracteres siempre deben ir entre comillas “cadena”, cuando esta función se encuentra un \n lo que hace saltar una linea. Si ponemos:

Código:

printf(“Hola “);

printf(“Adiós”);[/code 
y ejecutamos, la pantalla mostrará Hola Adiós

Si ponemos:

[code]printf(“Hola\n”);

printf(“Adiós”);

y ejecutamos, tendremos:

Código:

Hola

Adiós

Código:

return 0;

indica que el programa ha acabado sin fallos y lo termina.

Ya has hecho tu primer programa, decir que no te preocupes si no has entendido algo, al principio puede ser un poco raro y dentro de muy poco tiempo verás este primer programa, y dirás: “Menuda estupidez que hice”.
Comentarios

Lo último que vamos a ver en esta introducción son los comentarios, a veces queremos indicar en nuestra programa que hace cada cosa para que esté más claro. Sobre todo si vamos a liberar nuestro código, es conveniente decir que hace cada función para que el que lea el código lo entienda mejor.

Estas lineas evidentemente no se compilan y son desechadas en la primera fase de creación, el preprocesado, del que se habló al principio de este artículo. Usaremos nuestro código Hola Mundo.

Código:

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

/*Esto es un bloque
de comentarios
que no se ejecutarán*/

int main()
{

 printf(“Hola Mundo\n”); // Esto es un comentario
 return 0;

}

Vemos aquí dos tipos de comentarios, empezaremos por el segundo:

//Esto es un comentario

Vemos que tiene dos / delante, esto indica que es un comentario y que no debe compilarse, toda linea que empiece con dos // será un comentario.
NOTA:
Recuerda que las lineas en C no se distinguen cada vez que pulses enter, sino con punto y coma ;
Si tenemos escrito:

Código:

printf(“Hola”); printf(“Adiós”);

Diremos que tenemos dos lineas, no 1
Pero con // debemos pulsar enter para pasar a una linea compilable.
Si tenemos

Código:

printf(“Hola”); //Comentario printf(“Adiós”);

Solo se ejecutará el printf(“Hola”);
Debemos poner

Código:

printf(“Hola”); //Comentario
printf(“Adiós”);

El segundo tipo es /* Comentario */

A veces queremos hacer un comentario muy grande que ocupa varias lineas y es un rollo poner // delante de cada linea, así que usamos /* */ Todo lo que el compilador encuentre entre esos dos símbolos será un comentario. Podemos incluso usarlo dentro de los parámetros de las funciones, aunque no lo recomiendo.

Código:

printf(“Hola”/*Comentario*/);

Cuidado, que todo lo que haya entre comillas es interpretado como una cadena, y si tenemos.

Código:

printf(“Hola /*Comentario */ Mundo”);

En pantalla se mostrará:

Código:

Hola /*Comentario*/ Mundo

Y muy importante no cortar funciones por la mitad.

Código:

pri/*Comentario*/ntf(“Hola”);

Es un error garrafal y dará un error cuando intentemos compilar.

Esta ha sido la primera entrega, cualquier cosa comentad, o mandadme un mensaje (Contacto), sobre cosas que mejorar, de las que queréis que hable o lo que sea.

Manual de programación en C: Introducción 2ª parte. Funciones básicas

Aquí volvemos con esta segunda entrega del manual de C, en la que explicaré el concepto de función, un poco más profundamente que lo que hice en la primera entrega, y expondré algunas funciones estándar que nos serán bastante útiles
en prácticamente todos nuestros programas.

Para esta entrega y de aquí en adelante, creo un nuevo formato, creo que más entendible: todo permanece igual, pero los códigos van en letra cursiva y dentro de
tablas para que se diferencien mejor.

Una función es un fragmento de código que hace algo, así de simple. Si queremos escribir un informe, podemos hacerlo nosotros, o podemos decirle a la secretaria (o secretario, que se enfada la RAE) que lo haga ella, la secretaria es la función, hace el informe y nos lo da, tenemos el mismo resultado, pero para nosotros ha sido mucho más fácil. Ahora bien, la secretaria nos puede hacer ciertas preguntas: ¿un informe de qué? ¿Cómo de largo? ¿Con cuántos detalles? A esto lo llamaremos
parámetros y las funciones en C (no todas) también pueden pedirlos.

Por ejemplo si tenemos una función que suma dos números y nos da la solución, la pregunta se hace evidente, ¿qué números tengo que sumar?

En la primera entrega veíamos la función printf, que sirve para escribir texto en la consola. La forma de esta función es la siguiente:

Código:

printf(const char *format, …)

Código:

NOTA:Para los que sepan algo de C, me he comido aposta
la salida de la función, porque ahora no viene a cuento, esto es solo
una pequeña introducción al concepto de función.

Basta saber de momento que todo lo
que
haya entre los paréntesis son los parámetros de la función, y que
cada uno va separado por comas del otro, de modo que en la función
printf tenemos un solo parámetro: format. Las palabras const y char
hacen referencia al tipo de dato, y eso lo veremos en el próximo
capítulo con las variables.

Como veis parece que hay otro
parámetro
ya que hay una coma y 3 puntos suspensivos. Pues sí, lo hay, y sirve
para poder meter datos no constantes (variables), en la cadena e
imprimirlas en pantalla, de modo que también lo veremos en
variables.

Esto significa que la función
printf
va a tomar lo que le pongamos entre paréntesis y lo va a mostrar por
pantalla. El parámetro que esta función pide es una cadena, y como
dijimos en la primera entrega, las cadenas de texto que se han de
interpretar como texto han de ir entre comillas, si no, el compilador
lo entenderá como algo del lenguaje y nos dará un error al
compilar.

Por ejemplo:

Código:

printf(“Hola”);

Esta función es así de simple, es
cierto que admite más parámetros, pero los veremos cuando veamos
variables. (A este paso para el capítulo de variables voy a tener
que escribir la Biblia en verso)

La siguiente función de hoy es
fprintf, esta función hace lo mismo que printf, solo que toma dos
parámetros y le podemos indicar la salida del texto, el formato de
la función es el siguiente:

Código:

fprintf(FILE *stream, const char *format,…)

Veis un primer parámetro llamado
stream, luego una coma, y un segundo parámetro format, igual que en
printf. En stream pondremos la salida, es decir, donde escribirá lo
que le pongamos, y en format pondremos, al igual que en printf, la
cadena a escribir.

El stream puede ser cualquier
cosa,
desde una salida estándar, como stdout, stderr, a un archivo, es
decir, con esta función podremos crear archivos con información,
pero eso es más complicado y lo dejo para posteriores capítulos.

Esta función es usada sobre todo para
mandar texto a stderr, si hacemos un programa que puede producir
fallos dependiendo del uso que le de el usuario, le mandamos los
fallos a stderr. Por ejemplo:

Código:

fprintf(stderr, “Has cometido un fallo horrible, aprende a usar el programa y no seas cazurro\n”);

Esto mostraría en pantalla esa frase pero usando la salida de errores.

Código:

NOTA: Para los que no lo sepan, en consola (la pantalla
negra donde escribimos comandos), hay varias salidas de texto, una es
stdout, o salida estándar, y es salida simple de texto. La otra es
stderr, o salida de errores estándar, y es usada para mostrar errores
del programa.

Otra función útil es la función
system. Esta función pide los mismos parámetros que printf, es
decir, una cadena, solo que lo que hace con la
cadena es mandársela a la consola del sistema y ejecutarla, es
decir, ejecutar en consola lo que nosotros
le escribamos. El formato es:

Código:

system(const char *command)

Solovemos un parámetro, el parámetro command, que es una cadena de
texto que se ejecutará en consola.Por ejemplo:

Código:

system(“mkdir carpetanueva”);

Esto creará una carpeta nueva en el directorio en el que esté el ejecutable. Mkdir es un comando tanto en Windows como en Linux que crea una carpeta en el directorio en el que estés.

Por último hablaré de la función
main, esta es la función que se empieza a ejecutar en el programa,
tal y como vimos en la primera entrega del manual, la diferencia es
que esta función la creamos nosotros, mientras que las demás están
ya creadas y las usamos.

Código:

int main(int argc, char *argv[])

{

}

De este modo queda definida, todo lo
que haya entre los dos { y } pertenecerá a la función, si te fijas,
le hemos metido dos parámetros, argc y argv, que nos servirán en un
futuro para leer comandos desde la consola, son muy útiles, aunque
si no los pones no pasa nada.

He aquí un ejemplo que usa todo lo
visto:

Código:

#include
<stdio.h> //Incluimos la librería con las funciones que usaremos

 

int
main(int argc, char *argv[])

{

 printf(“Este es un mensaje escrito con printf\n”);

 fprintf(stderr, “Este es un mensaje que viene por standard error (stderr)\n”);

 

 system(“ls -l /”); //En Windows pon system(“dir C:\”); dir es lo mismo que ls, uno en Windows y otro en Linux

 

 return 0; //El 0 indica que el programa ha terminado correctamente.

}

Si compilamos esto, y lo ejecutamos, nos mostrará en pantalla:

Código:

Este es un mensaje escrito con printf

Este es un mensaje que viene por standard error (stderr)

drwxr-xr-x 2 root root 4096 2010-10-06 15:06 bin

drwxr-xr-x 3 root root 4096 2010-10-20 18:27 boot

drwxr-xr-x 2 root root 4096 2010-09-22 21:57 cdrom

drwxr-xr-x 18 root root 3920 2010-10-26 14:37 dev

drwxr-xr-x 144 root root 12288 2010-10-26 14:37 etc

drwxr-xr-x 4 root root 4096 2010-04-23 12:11 home

drwxr-xr-x 20 root root 12288 2010-10-23 11:44 lib

drwx—— 2 root root 16384 2010-09-22 21:48 lost+found

drwxr-xr-x 2 root root 4096 2010-10-23 22:49 media

drwxr-xr-x 2 root root 4096 2010-04-23 12:11 mnt

drwxr-xr-x 4 root root 4096 2010-10-05 15:10 opt

dr-xr-xr-x 187 root root 0 2010-10-26 16:36 proc

drwx—— 21 root root 4096 2010-10-17 13:06 root

drwxr-xr-x 2 root root 4096 2010-10-23 11:43 sbin

drwxr-xr-x 2 root root 4096 2009-12-05 22:55 selinux

drwxr-xr-x 2 root root 4096 2010-08-16 11:32 srv

drwxr-xr-x 13 root root 0 2010-10-26 16:36 sys

drwxrwxrwt 16 root root 36864 2010-10-26 16:01 tmp

drwxr-xr-x 11 root root 4096 2010-09-23 16:24 usr

drwxr-xr-x 15 root root 4096 2010-08-16 11:48 var

Lo último es el resultado de ejecutar un comando ls -l en linux, son las carpetas de la raiz de mi ordenador.

No creo que haga mucha falta explicar el código: primero incluimos la librería stdio.h, inciamos la función main, y dentro de ella imprimimos un mensaje con dos funciones diferentes y mandamos un comando a la consola.

Recuerdo que me podéis enviar cualquier duda, sugerencia, crítica, etc. Podéis dejar un comentario aquí, o si queréis un trato más directo, enviarme un correo electrónico, entra en la sección Contacto.

Para el próximo capítulo ahora sí que sí, veremos los tipos de datos en C y las variables.

En la próxima entrega empezaremos con las variables, algunas funciones de input, es decir, escribir información por pantalla y guardarla en una variable para poder usarla en el programa.
Licencia de Creative Commons

Manual de C by http://whitehathacking.wordpress.com is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License.

Manual de Programación en C: Tipos de datos. Variables.

Recuerdo cuando veía la gente que aprendía programación oír hablar por primera vez de las variables, (esto fue en el colegio, cuando nos enseñaron LOGO, bastante inútil por cierto), yo ya había aprendido a programar por mi cuenta, y cuando nos hablaban de guardar datos o números bajo un nombre, la gente decía, ¿y para qué quiero yo guardar un número?

Para alguien que sepa de informática esta pregunta es bastante estúpida, ¿para qué quiero yo guardar algo en el ordenador? Sería una pregunta similar.

La respuesta es: para todo. Supongamos que hacemos un videojuego, ¿cuántas balas le quedan al protagonista? Pues creamos una variable y guardamos el número de balas dentro, cada vez que dispara le restamos 1 a la variable y ya
está, ¿cómo puedo saber si si está en un sitio? De la misma forma, creamos una variable en la que guardamos la posición. Espero que veáis para qué sirven las variables, no es muy difícil comprender su importancia.

Tipos de datos:

Es evidente que no todos los datos de un ordenador son iguales, habrá quien diga: ¿pero no eran todo unos y ceros? Pues sí, lo son, pero en programación abstraemos eso para que sea más sencillo, y creamos distintos tipos de variables según el dato que sea y la memoria que se use.

Podemos ver las variables como un cajón en el que guardar cosas, en cada cajón solo podemos guardar una cosa, y los cajones pueden ser de distinto tipo y de distinto tamaño.

Código:

NOTA: Recuerda que la memoria del ordenador funciona sobre
bits, que es la unidad más pequeña y que solo puede ser 1 o 0. 

1 byte = 8 bits, 1 byte puede ir desde 00000000 a 11111111,
para pasar de binario a decimal, multiplicamos de derecha a izquierda
por 2 elevado a la series de números naturales de 0 a donde lleguemos,
en este caso:

1·2^0 + 1·2^1 + 1·2^2 + 1·2^3 + 1·2^4 + 1·2^5 + 1·2^6 + 1·2^7 = 255

De modo que en un byte podemos guardar números desde el 0
hasta el 255.

Para calcular el mayor número que podemos guardar en una
cantidad de bytes, elevamos 2 al número de bits, por ejemplo en 4 bytes
= 32 bits, podemos guardar hasta el número:

2^32 = 4294967296 → desde 0 hasta 4294967296

O hasta la mitad si contamos desde el menor negativo hasta el
mayor positivo.

Cuando creamos una variable le damos un nombre que usaremos para referirnos a ella dentro del programa, y le damos un tipo de dato, vamos a verlo con un ejemplo sobre el primer tipo de datos:

Tipo int → entero

El tipo int maneja números enteros, podemos guardar en este tipo de variables cualquier número entero entre un rango que depende de la memoria que ocupe el tipo int, que son 4 bytes.

Para crear una variable la declaramos, declarar una variable es decirle al sistema que nos reserve un hueco en la memoria para ella, y la declaramos escribiendo el tipo de dato y luego un nombre que nos inventemos, por ejemplo:

Código:

int variable;

De este modo creamos una variable de tipo int que se llama “variable”, y este nombre es el que usaremos para referirnos a ella en nuestro programa. ¿Cómo le damos un valor? Pues tan fácil como esto:

Código:

variable = 20;

Así la variable llamada variable tendrá guardado el número 20. No hace falta volver a poner int una vez creada, de hecho si lo pones el compilador interpretará que la quieres crear de nuevo y dará error, de modo que ponemos int solo la primera vez, cuando la declaramos.

Hay dos modos de declarar una variable, de modo local y de modo global, eso tiene que ver con funciones y no
lo veremos de momento, quédate con una variable es declarada como global si se crea fuera de la función main() y como local si se crea dentro, como no vamos a crear funciones de momento, crea las variables dentro de la función main(). Por ejemplo:

Código:

#include <stdio.h> 

int main(int argc, char *argv[])

{

int numero;

numero = 5;

 

return 0;

}

También se puede dar valor a una variable a la vez que se crea, de la siguiente manera:

Código:

int numero = 3; // Creamos una variable llamada numero y le damos el valor 3.

Y declarar varias variables del mismo tipo en una sola linea si las separamos por comas.

Código:

int var1, var2; // Creamos dos variables 

int var3 = 5, var4 = -3; // Creamos otras dos variables y les damos valores.

El nombre de la variable puede ser el que quieras, siempre y cuando no empiece por números y no tenga los símbolos / . y otros reservados. Yo recomiendo usar solo letras, números y barras bajas. Tampoco pueden tener espacios.

Tipo char

El tipo char (del inglés character) sirve para almacenar, como bien habrás deducido, caracteres.

Puede tener cualquier número del código ASCII, es decir, entre 0 y 255.

Código:

NOTA: El código ASCII le da un número entre 0 y 255 a cada
carácter imprimible.

Puedes ver una tabla con los códigos ASCII de cada carácter
aquí.

Pero no necesitaremos saber el código para darle valor a una variable char. Estas variables, como todas, se
definen poniendo delante el tipo de dato y luego el nombre de la variable.

Código:

char caracter;

Le podemos dar valor de dos formas, o bien dándole el código ASCII del carácter, o bien dándole
directamente el carácter entre comillas simples.

Código:

char letra = ‘a’;

Es lo mismo que:

Código:

char letra = 97; // El 97 es el código ASCII de la letra a minúscula.

Cada variable char puede contener un solo carácter.

Mostrar las variables.

Hemos conseguido hasta ahora crear variables y guardar datos en ellas, para imprimirlas por pantalla usaremos la ya conocida función printf, ¿recuerdas su estructura?

Código:

void printf(const char *format, …)

Código:

NOTA IMPORTANTE: Vemos que las funciones también tienen un
tipo de dato, en este caso void, el tipo de datos de una variable
indica que dato dará por salida, o que nos devolverá, por ejemplo, si
tenemos una función que nos suma dos números y nos devuelve la suma, su
forma podría ser así: 
int suma_numeros(int numero1, int numer2)

Ahora ya entendemos esto: los parámetros son numero1 y
numero2, que son de tipo int, de modo que cuando usemos esta variable
le deberemos pasar dos argumentos entre paréntesis de tipo int
(números), y nos dará otro dato de tipo int, que será la suma.

Luego veremos como aprovechar esto.

El tipo void, que en inglés significa vacío, es precisamente
eso, que no devuelve nada, ya que printf lo único que hace es sacar un
texto por la pantalla, no devuelve ningún tipo de dato.

Si recordáis la metáfora de la secretaria, si le pedimos por
ejemplo que llame a alguien no obtendremos nada, realizará la función,
pero no nos dará ningún dato de salida, será “void”.

Empezamos a entender el parámetro que nos pide: const char *format, un dato de tipo char, el asterisco indica que es un puntero, algo que veremos en próximos capítulos (y que hace C uno de los lenguajes más potentes), recuerda que una variable de tipo char solo puede guardar un carácter, con el * hacemos que pueda guardar una serie de caracteres.

Usemos la función printf para escribir el valor de una variable, haber si has entendido como crearlas: haz un programa, dentro de la función main declara una variable de tipo entero (int) llamada variable y dale el valor 3, a continuación pon:

Código:

printf(“El valor de la variable es: %i\n”, variable);

El código queda:

Código:

#include <stdio.h>

 

int main()

{

int variable
= 3;

printf(“El
valor de la variable es: %i”, variable);

 

return 0;

}

Ahora compila y ejecuta, en pantalla se mostrará el mensaje:

Código:

 
El valor de la variable es: 3

¿Qué hemos hecho? Lo único que vemos nuevo es que dentro de la cadena hay un símbolo %i

El símbolo % en una cadena y la letra siguiente indica que se va a incluir una variable y sustituirá el % y la letra siguiente, en este caso i de int, por el valor de la variable que le pasemos como segundo parámetro.

Para las variables de tipo char es igual solo que en vez de %i escribiremos %c, la c es de char.

Pues ahora haremos un programa que imprima una letra en pantalla. Prueba a hacerlo tú, deberías ser capaz, tan solo hay cambiar el tipo de variable a char, meterle como valor una letra entre comillas simples y cambiar el %i por %c en la
función printf().

Tamaño de las
variables en memoria.

Como he dicho al principio, cuando declaramos una variable le mandamos un mensaje la sistema para que nos reserve un espacio en la memoria RAM del ordenador para esa variable, y la cantidad de memoria que nos reservará dependerá del tipo de variable, hay una función que nos permite saber cuánto ocupa cada variable en bytes, lo que nos permite calcular su rango.

Esa función es sizeof, y su formato es el siguiente:

Código:

int sizeof(tipo_de_dato)

Ahora si entendemos lo que hace, su salida es de tipo int, eso es como si a la hora de ejecutar, la función se convirtiera en un número entero que dependerá del parámetro, que es tipo_de_dato, aquí podemos poner el tipo de dato directamente o una variable, calculará el número de bytes que ocupa esa variable:
sizeof(int);

Es lo mismo que:

Código:

int variable;

sizeof(variable);

Probemos a ver que nos da, los resultados que muestre aquí son los de mi ordenador, los tuyos pueden cambiar, ya que depende del ordenador que uses, (memoria y procesador) y del compilador.

Código:

#include <stdio.h> 

int main()

{

int dato;

int tamaño = sizeof(dato);

printf(“Tamaño de int:
%i\n”,tamaño);

return 0;

}

Como el tipo de salida de sizeof es int, creamos una variable llamada tamaño de tipo int y le damos el valor que nos devuelva sizeof, después la imprimimos con printf, habría dado lo mismo hacer esto directamente:

Código:

printf(“Tamaño de int: %i\n”, sizeof(int));

La salida del anterior en mi ordenador es:

Código:

Tamaño de int: 4

Eso significa que el tipo int puede almacenar 4 bytes de información, como 4 bytes = 4 · 8 bits = 32
bits, y 232 = 4.294.967.296, entonces ese es el número de valores distintos que puede tener una variable de tipo int, pero atención, no es el número máximo que puede guardar, porque int también puede guardar números negativos, de modo que el número máximo será la mitad, ya que puede guardar desde el -2.147.483.648 al +2.147.483.648.

Más variables.

Hemos visto los tipos principales de variables, pero hay más que veremos a continuación.

Tipo float.

Este tipo es float o coma flotante, eso quiere decir que podremos meterle números con decimales, no solo
enteros como anteriormente.

En float podemos guardar valores de -3.4·10-38 a 3.4·1038.

Pongo puntos en vez de comas porque el decimal debe especificarse así, cuidado que las comas darán error.

Código:

float variable = 456.23;

Tipo double

Esto es de doble coma flotante, podremos guardar números en el rango de -1.7·10-307 a 1.7·10308

Código:

 
double variable = 432.23435;

Para imprimir tanto el tipo double como el float con la función printf podemos usar el símbolo %d, de hecho, podemos usar ese para int, float y double.

Código:

 
double variable = 43.43; 

printf(“Valor de variable: %d\n”, variable);

Unsigned

Esto no es un tipo de dato, sino un modificador, esto quiere decir que cambiará el tipo de variable pero no es un tipo en si mismo, se puede asignar a cualquier tipo y lo que hace es quitarle el signo, por ejemplo, si le hacemos un sizeof a
char, veremos que ocupa 1 byte = 8 bits, 28 = 255, así que puede guardar 256 valores, entre -127 y 128, si definimos el char como unsigned, lo que hacemos es quitarle el signo, es decir podrá guardar valores entre 0 y 255.

Por ejemplo

Código:

unsigned int entero_sin_signo = 3000000000;

Ese valor estaría fuera del rango del tipo int, que llega a 2.147.483.648, pero al hacerlo de tipo unsigned, ya lo podemos guardar en la variable.

Overflow

El overflow es algo que pasa cuando nos pasamos del rango de la variable, en el caso anterior, si guardáramos ese número en una variable int sin el modificador unsigned, al compilar el compilador nos daría un aviso de que nos hemos pasado, no nos daría error, ya que lo que haría sería una vez se ha pasado, ir al mínimo valor y seguir sumando desde allí, por ejemplo:

Código:

#include <stdio.h> 

int main()

{

int entero_con_signo = 3000000000;

printf(“Valor: %i\n”,
entero_con_signo);

return 0;

}

Al compilar en Linux con gcc me da este aviso:

Código:

mostrar.c: In function ‘main’:

mostrar.c:5: warning: this decimal constant is unsigned
only in ISO C90

Me dice que no lo he definido como unsigned, osea que me he pasado.

El resultado es:

Código:

Valor: -1294967296

Se ha pasado y ha seguido sumando desde el menor. Este tipo de fallos se llaman fallos de overflow.

Constantes

Este es el último apartado de esta entrega.

Hasta ahora hemos visto variables, si nos vamos al significado de la palabra significa que varían, y efectivamente, durante el transcurso del programa podemos cambiar el valor de las variables de forma sencilla al que queramos. Podemos hacer:

Código:

int variable = 3; 

variable = 5;

Al definirla le hemos dado el valor 3 y luego le hemos dado el valor 5, osea que el 3 desaparece.

Operaciones muy básicas

También podemos hacer operaciones con ellas, aunque las veremos en el próximo capítulo más a fondo:

Código:

 
int variable = 3; 

variable = variable +1; // Variable vale 3, luego si ahoravale variable +1, valdrá 3+1 = 4.

int var1 = 3, var2 = 4;

int var3 = var1 + var2; //var3 valdrá 3+4 = 7

Código:

NOTA: Signos básicos de operaciones 

+ sumar → var1 + var2;

- restar → var1 – var2;

* multiplicar → var1 * var2;

/ dividir → var1 / var2;

++ sumar uno → var1++;

– restar 1 → var1–;

A veces nos conviene definir variables cuyo valor no cambie durante el programa, serán constantes, estas se definen con #define al principio y su valor no puede cambiar.

Código:

#define Constante 5

Se definen así, #define, Luego un espacio y el nombre de la variable, en este caso Constante, luego un espacio y al final su valor, en este caso 5. No es obligatorio, pero es como una regla de buena presentación poner el valor de la variable después de un tabulado, no solo un espacio simple.

Vamos a ver el uso de constantes con un programa muy sencillo que hará algo tan simple como calcular la longitud de una circunferencia, que como deberías saber es 2xPIxradio. Con lo que hemos visto hasta ahora deberías ser capaz de
hacerlo, aunque aquí tienes el código:

Código:

#include <stdio.h> 

int main()

{

float radio = 5;

float pi = 3.1416;

float longitud = 2 * pi *
radio;

 

printf(“La longitud es de %d
cm\n”, longitud);

return 0;

}

Es un programa muy simple, no creo que haga falta comentarlo, ya que deberías entenderlo, si queremos calcular una longitud de una circunferencia de radio diferente, simplemente cambiamos el valor de la variable radio, sin embargo, el valor de la variable pi nunca cambiará, ya que es una constante matemática racional. Ahora veremos el mismo programa cambiando la variable pi por una constante, a la que llamaremos PI.

Código:

#include <stdio.h> 

#define PI 3.1416

int main()
{
     float radio = 5;
     float longitud = 2 * radio * PI;
     printf(“Longitud: %d\n”,longitud);
     return 0;
}

El programa hará lo mismo, pero ahora no corremos el riesgo de cambiar accidentalmente el valor, cosa que puede pasar en programas más complicados. Si recuerdas la primera entrega, en la que hablábamos del proceso de creación de un programa, en un momento de preprocesado decíamos que se sustituían los #define, esto que quiere decir, que cada vez que se llega a un #define, se ve su valor, se recorre el programa en busca de los lugares donde se utilice y se cambia, para borrar el define a continuación. El código quedaría así:

Código:

#include <stdio.h> 
int main()
{
      float radio = 5;
      float longitud = 2 * radio * 3.1416;
      printf(“Longitud: %d\n”,longitud);
      return 0;
}

Hasta aquí este capítulo, para cualquier duda ver en blog la sección Contactos y enviarme un email o preguntar por aquí. Este capítulo puede ser muy denso si es la primea vez que se oye hablar de esto, así que tómate tu tiempo y prueba cosas, inventa programas simples que usen variables a ver qué has aprendido.
Licencia de Creative Commons

Manual de C by http://whitehathacking.wordpress.com is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License.[/code]