learnxinyminutes-docs/es-es/c-es.html.markdown

---
language: c
filename: learnc.c
contributors:
    - ["Adam Bard", "http://adambard.com/"]
translators:
    - ["Francisco Garc<72>a", "http://flaskbreaker.tumblr.com/"]
lang: es-es
---

<EFBFBD>Ah!, C. Aun hoy en d<>a sigue siendo el lenguaje por excelencia de la 
computaci<EFBFBD>n moderna de alto rendimiento.

C es el lenguaje de m<>s bajo nivel que la mayor<6F>a de los programadores
llegar<EFBFBD>n a usar, pero lo compensa de sobra con pura velocidad. Solo
ten en cuenta el manejo manual de memoria y te llevar<61> tan lejos como
necesites.

```c
// Los comentarios de una sola l<>nea comienzan con //

/*
Los comentarios multil<69>nea tienen este aspecto.
*/

// Importa cabeceras con #include
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// Declara por adelantado las armaduras de las funciones en un archivo .h,
// o al principio de tu archivo .c .
void function_1();
void function_2();

// El punto de entrada de tu programa es una funci<63>n llamada main con
// retorno de tipo entero (integer).
int main() {

// Muestra la salida usando printf, para el "formato print"
// %d es un entero, \n es una nueva l<>nea
printf("%d\n", 0); // => Muestra 0
// Todas las sentencias deben terminar con un punto y coma.

///////////////////////////////////////
// Tipos
///////////////////////////////////////

// Tienes que declarar una variable antes de usarla. La declaraci<63>n de una
// variable necesites que especifiques su tipo; el tipo de una variable
// determina su tama<6D>o en bytes.

// 'ints' (enteros) son normalmente de 4 bytes
int x_int = 0;

// 'shorts' son normalmente de 2 bytes
short x_short = 0;

// 'chars' son fijo de 1 byte
char x_char = 0;
char y_char = 'y'; // Los caracteres literales se entrecomillan con ''

// 'longs' son a menudo de 4 a 8 bytes; 'long longs' son fijo de por lo
// menos 64 bits
long x_long = 0;
long long x_long_long = 0; 

// 'floats' son normalmente n<>meros de coma flotante de 32 bits
float x_float = 0.0;

// 'doubles' son normalmente n<>meros de coma flotante de 64 bits
double x_double = 0.0;

// Todos los tipos enteros pueden ser 'unsigned'. Esto significa que no
// pueden ser negativos, pero el valor m<>ximo de una variable 'unsigned'
// es mayor que el de una no 'unsigned' del mismo tama<6D>o.
unsigned char ux_char;
unsigned short ux_short;
unsigned int ux_int;
unsigned long long ux_long_long;

// Todos menos 'char', que es siempre de 1 byte, var<61>an el tama<6D>o 
// dependiendo de tu m<>quina. sizeof(T) te dice el tama<6D>o de una variable
// de tipo T en bytes por lo que podemos expresar el tama<6D>o de estos tipos
// portatilmente.
// Por ejemplo,
printf("%lu\n", sizeof(int)); // => 4 (en m<>quinas con 'words' de 4 bytes)

// Los arrays deben ser inicializados con un tama<6D>o concreto.
char my_char_array[20]; // Este array ocupa 1 * 20 = 20 bytes
int my_int_array[20]; // Este array ocupa 4 * 20 = 80 bytes
                      // (suponiendo que tenemos 'words' de 4-byte)


// Puedes inicializar un array a 0 as<61>:
char my_array[20] = {0};

// Indexar un array es como en otros lenguajes -o, m<>s bien, otros
// lenguajes son como C-
my_array[0]; // => 0

// Los arrays var<61>an; <20>son s<>lo memoria!
my_array[1] = 2;
printf("%d\n", my_array[1]); // => 2

// Las cadenas (strings) son s<>lo arrays de 'chars' (caracteres)
// terminados en un byte NUL (0x00), representado en las cadenas como el car<61>cter especial '\0'.
// (No tenemos porqu<71> a<>adir el byte nulo en cadenas literales; el
//  compilador lo a<>ade al final por nosotros.)
char a_string[20] = "Esto es una cadena";
printf("%s\n", a_string); // %s se sutituye por una cadena.

/*
Te habr<62>s dado cuenta de que a_string es solo de 18 caracteres.
El 'char' #19 es el byte nulo. 
El 'char' #20 es de valor indefinido.
*/

printf("%d\n", a_string[18]); // => 0

///////////////////////////////////////
// Operadores
///////////////////////////////////////

int i1 = 1, i2 = 2; // Forma corta de declaraci<63>n m<>ltiple
float f1 = 1.0, f2 = 2.0;

// La aritm<74>tica es sencilla
i1 + i2; // => 3
i2 - i1; // => 1
i2 * i1; // => 2
i1 / i2; // => 0 (0.5, pero es truncado tras el 0)

f1 / f2; // => 0.5, m<>s o menos <20>psilon
// M<>dulo est<73> tambi<62>n
11 % 3; // => 2

// Los operadores de comparaci<63>n te resultaran familiares, pero no hay
// booleanos en C. Usamos enteros (ints) en su lugar. 0 es falso,
// cualquier otra cosa es verdadero. (Los operadores de comparaci<63>n 
// siempre devuelven 0 o 1)
3 == 2; // => 0 (Falso)
3 != 2; // => 1 (Verdadero)
3 > 2; // => 1
3 < 2; // => 0
2 <= 2; // => 1
2 >= 2; // => 1

// La l<>gica funiona en enteros
!3; // => 0 (not l<>gico)
!0; // => 1
1 && 1; // => 1 (and l<>gico)
0 && 1; // => 0
0 || 1; // => 1 (or l<>gico)
0 || 0; // => 0

// <20>Operadores de bits!
~0x0F; // => 0xF0 (Negaci<63>n)
0x0F & 0xF0; // => 0x00 (AND)
0x0F | 0xF0; // => 0xFF (OR)
0x04 ^ 0x0F; // => 0x0B (XOR)
0x01 << 1; // => 0x02 (desplazar hacia la izquierda (por 1))
0x02 >> 1; // => 0x01 (desplazar hacia la derecha (por 1))

///////////////////////////////////////
// Estructuras de Control
///////////////////////////////////////

if (0) {
  printf("Yo nunca ocurro\n");
} else if (0) {
  printf("Yo tampoco ocurro nunca\n");
} else {
  printf("Yo me muestro\n");
}

// Mientras el bucle exista
int ii = 0;
while (ii < 10) {
    printf("%d, ", ii++); // ii++ incrementa ii en uno, despu<70>s de usar su valor.
} // => muestra "0, 1, 2, 3, 4, 5, 6, 7, 8, 9, "

printf("\n");

int kk = 0;
do {
    printf("%d, ", kk);
} while (++kk < 10); // ++kk incrementa kk en uno, antes de usar su valor.
// => muestra "0, 1, 2, 3, 4, 5, 6, 7, 8, 9, "

printf("\n");

// Bucles 'for' tambi<62>n
int jj;
for (jj=0; jj < 10; jj++) {
    printf("%d, ", jj);
} // => muestra "0, 1, 2, 3, 4, 5, 6, 7, 8, 9, "

printf("\n");

///////////////////////////////////////
// Cambios de Tipo
///////////////////////////////////////

// Cada valor en C tiene un tipo,  pero tu puedes ingresar un valor en
// otro tipo si quieres.

int x_hex = 0x01; // Puedes asignar hexadecimales a variables

// El cambio de tipos intentar<61> mantener sus valores num<75>ricos
printf("%d\n", x_hex); // => Muestra 1
printf("%d\n", (short) x_hex); // => Muestra 1
printf("%d\n", (char) x_hex); // => Muestra 1

// Los tipos se desbordan sin aviso
printf("%d\n", (char) 257); // => 1 (El valor m<>ximo de un 'char' es 255)

// Los tipos enteros puden cambiarse a tipos de coma flotante, y viceversa
printf("%f\n", (float)100); // %f se sustituye por un 'float'
printf("%lf\n", (double)100); // %lf se sustituye por un 'double'
printf("%d\n", (char)100.0);

///////////////////////////////////////
// Punteros
///////////////////////////////////////

// Un puntero es una variable declarada para almacenar una direcci<63>n de 
// memoria. Su declaraci<63>n adem<65>s nos dir<69> el tipo de dato al que apunta. 
// Puedes obtener la direcci<63>n de memoria de tus variables, y despu<70>s
// enlazarlas con ellos.

int x = 0;
printf("%p\n", &x); // Usa & para obtener la direcci<63>n de una variable.
// (%p se sustituye por un puntero)
// => Muestra alguna direcci<63>n de memoria;

// Los tipos de puntero terminan con * en su declaraci<63>n
int* px; // px es un puntero a un 'int'
px = &x; // Almacena la direcci<63>n de x en px
printf("%p\n", px); // => Muestra alguna direcci<63>n de memoria

// Para obtener el valor de la direcci<63>n a la que apunta un puntero, pon
// * delante para desreferenciarle. 
printf("%d\n", *px); // => Muestra 0, el valor de x y de la direcci<63>n a la
                     //    que apunta px

// Tambi<62>n puedes cambiar el valor al que est<73> apuntando el puntero.
// Tenemos que meter la desreferencia entre par<61>ntesis porque ++ tiene
// prioridad frente a *.
(*px)++; // Incrementa el valor al que apunta px en 1
printf("%d\n", *px); // => Muestra 1
printf("%d\n", x); // => Muestra 1

int x_array[20]; // Los arrays son una buena manera de distribuir bloques
int xx;          // continuos de memoria.
for (xx=0; xx<20; xx++) {
    x_array[xx] = 20 - xx;
} // Inicializa x_array a 20, 19, 18,... 2, 1

// Declara un puntero de tipo 'int' y lo inicializa para apuntar a x_array
int* x_ptr = x_array;
// x_ptr ahira apunta al primer elemento del 'array' (el entero 20).
// Esto funciona porque las 'arrays' actualmente son solo punteros a su
// primer elemento.

// Los 'arrays' son punteros a su primer elemento.
printf("%d\n", *(x_ptr)); // => Muestra 20
printf("%d\n", x_array[0]); // => Muestra 20

// Los punteros aumentan y disminuyen en funci<63>n de su tipo.
printf("%d\n", *(x_ptr + 1)); // => Muestra 19
printf("%d\n", x_array[1]); // => Muestra 19

// Puedes tambi<62>n asigner dinamicamente bloques contiguos de memoria con
// la funci<63>n malloc de la librer<65>a est<73>ndard, que toma un entero como
// argumento representando el n<>mero de bytes a asignar de la pila.
int* my_ptr = (int*) malloc(sizeof(int) * 20);
for (xx=0; xx<20; xx++) {
    *(my_ptr + xx) = 20 - xx; // my_ptr[xx] = 20-xx funcionar<61>a tambi<62>n aqu<71>
} // Inicializa la memoria a 20, 19, 18, 17... 2, 1 (como 'ints')

// Desreferenciando la memoria que no has asignado te dar<61> resultados
// impredecibles
printf("%d\n", *(my_ptr + 21)); // => Prints who-knows-what?

// Cuando hallas acabado con el bloque de memor<6F>a malloc, necesitas 
// liberarlo o sino nadie m<>s podr<64> usarlo hasta que tu programa se cierre
free(my_ptr);

// Las cadenas pueden ser 'arrays' de chars, pero normalmente se
// representan con punteros 'char':
char* my_str = "This is my very own string";

printf("%c\n", *my_str); // => 'T'

function_1();
} // fin de la funci<63>n main

///////////////////////////////////////
// Funciones
///////////////////////////////////////

// Sintexis de la declaraci<63>n de funciones:
// <tipo de retorno> <nombre>(<argumentos>)

int add_two_ints(int x1, int x2){
    return x1 + x2; // Usa 'return' para dar una salida
}

/*
Las funciones son de paso por valor, pero puedes hacer tus propias 
referencias con punteros de manera que las funciones puedan cambiar sus 
valores.

Ejemplo: invertidor de cadenas in-situ
*/

// Una funci<63>n 'void' no retorna valor
void str_reverse(char* str_in){
    char tmp;
    int ii=0, len = strlen(str_in); // Strlen es parte de la librer<65>a 
    for(ii=0; ii<len/2; ii++){      // est<EFBFBD>ndard
        tmp = str_in[ii];
        str_in[ii] = str_in[len - ii - 1]; // ii-th <20>ltimo 'char'
        str_in[len - ii - 1] = tmp;
    }
}

/*
char c[] = "Esto es una prueba.";
str_reverse(c);
printf("%s\n", c); // => ".abeurp anu se otsE"
*/

///////////////////////////////////////
// Definici<63>n de tipos y estructuras
///////////////////////////////////////

// Los 'Typedefs' pueden ser utilizados para crear alias de tipos.
typedef int my_type;
my_type my_type_var = 0;

// Las estructuras son s<>lo grupos de datos.
struct rectangle {
    int width;
    int height;
};


void function_1(){

    struct rectangle my_rec;

    // Utiliza los miembros de una estructura con .
    my_rec.width = 10;
    my_rec.height = 20;

    // Puedes declarar punteros a estructuras
    struct rectangle* my_rec_ptr = &my_rec;

    // Usa la desreferencia para modificar sus miembros...
    (*my_rec_ptr).width = 30;

    // ... o usa la abreviatura ->
    my_rec_ptr->height = 10; // Lo mismo que (*my_rec_ptr).height = 10;
}

// Puedes aplicar un 'typedef' a una estructura por convenienc<6E>a.
typedef struct rectangle rect;

int area(rect r){
    return r.width * r.height;
}

///////////////////////////////////////
// Punteros a Funciones
///////////////////////////////////////
/*
En tiempo de ejecuci<63>n,  las funciones se localizan en unas direcciones de
memoria concretas. Los punteros a funciones son como cualquier otro 
puntero (almacenan una direcci<63>n de memoria), pero pueden ser usados para 
utilizar funciones directamente, o para pasar 'handlers' (o funciones 
'callback') por todos lados.
Sin embargo, la sintaxis de definici<63>n parecera confusa al principio.

Ejemplo: usar str_reverse desde un puntero
*/
void str_reverse_through_pointer(char * str_in) {
    // Define un puntero a una funci<63>n, llamado f.
    void (*f)(char *); // La armadura debe coincidir exactamente con al funci<63>n objetivo.
    f = &str_reverse; // Assigna la direcci<63>n de la funci<63>n (determinado en tiempo de ejecui<75>n)
    (*f)(str_in); // Llamando la funci<63>n desde el puntero
    // f(str_in); // Esta es una alternativa para llamarla pero con una sintaxis igual de v<>lida.
}

/*
Tanto tiempo como las armaduras de las funciones coincidan, podr<64>s asignar
cualquier funci<63>n al mismo puntero.
Los punteros a funciones  son normalmente envueltos en 'typedef' para
simplificar su legibilidad, como sigue:
*/

typedef void (*my_fnp_type)(char *);

// Es usado para declarar la variable puntero actual:
// ...
// my_fnp_type f; 

```

## Otras lecturas

Lo mejor que puedes en contrar es una copia de [K&R, aka "The C Programming Language"](https://en.wikipedia.org/wiki/The_C_Programming_Language)

Otro buen recurso es [Learn C the hard way](http://c.learncodethehardway.org/book/)

Aparte de eso, Google es tu amigo.