Lain and Sakura

Icono

”One byte to rule them all’ – dtmf – old school

Primer Clase

Funciones E/O
El kernel manda una cadena entera y luego
getchar comienza a iterar char by char.
Esto es para ahorrar recursos
getchar()

Empezamos a definir mas tipos de datos.
C tiene tipos PRIMITIVOS
(int, char, etc)

Permite fabricar tipos nuevos (tipos derivados),
uno de ellos es el ARREGLO que esta formado por
n valores de un mismo tipo contiguos en memoria.

Veamos que significa esto:

Ej:
int a; /* es un entero */
int a[5]; /* es un arreglo de 5 caracteres */

en memoria:

4 bytes
|    |    |    |    |    |    |
int    int    int    int

Cada entero ocupa 4 bytes.

Se puede acceder a cada entero individualmente ?
SI
|    |    |    |    |    |    |
a[0]    a[1]    a[2]    a[3]    a[4]    a[5]    a[6]

Cantidad es:
Ej:
int a[5];
comienza de a[0]
cantidad a[5] – 1 /* porque comienza de 0 */

Por supuesto, se puede hacer arreglos con cualquier cosa ya definida.

Nota en C:
/* en java se puede declarar int [5] a; */
Esto en C es un ERROR

Tambien se puede escribir:

int a[5]; b;
el tipo se ‘pega’ al identificador, no al tipo.

  1. ###########################################################

Variables automaticas globales y estaticas.
————————————————————

  • Una variable es automatica cuando esta declarada dentro de un

bloque de codigo. Solo es visible dentro de ese bloque.
Tiene una pequenia excepcion: Los parametros de una funcion,
que son visibles dentro del bloque de esa funcion.
C garantiza (contrato firmado) que una variable automatica tendra
cualquier cosa hasta la primera asignacion.

int a;
/* no se puede hacer ninguna suposicion sobre lo que
hay en a en este momento hasta que no se realiza una
asignacion. Sistemas UNIX llenan de 0 la mem. */

a = getchar()
/* ya tenemos una asignacion */

  • Una variable es GLOBAL si esta declarada fuera de cualquier

bloque.
Ej:

int i; /* var global */

int main(){
int i; /* var local, que encima pisa a la global */
}

Es visible desde su declaracion.
C GARANTIZA que su valor inicial sera cero, excepto que se le asigne
algo.
Ej:
int j; /* j va a venir en 0 */
int k = 3; /* k viene en 3 */
int h[3]; /* todos los valores del arreglo vienen en 0 */

Tiempos de vida.
– Una automatica se crea con el bloque que la contiene. (el bloque
se activa). Cuando se inicia el bloque, se inician las variables
locales a ese bloque)

Ej:
int main(){
int a;
int b;
int c; /* se inicializa al arrancar main, no importa el orden */
}

– Una global ‘vive’ todo el tiempo que ‘vive’ el proceso, como los
dinosaurios de susana gimenez. (chiste de guido).

Existe una categoria intermedia, las variables estaticas. Son locales
(se definen dentro de un bloque y son visibles solo dentro del bloque),
pero duran ‘siempre’, durante el tiempo de vida del proces como las
globales. Como se declaran ?
Ej:
int main(){
int i; /* es automatica, cuando termine main fue */
static int j; /* es intermedia */
}

Es una variable que retiene valores aunque su bloque no este activo.
Ej: hacer una funcion que diga cuantas veces fue llamada anteriormente.
sin usar variables globales. hacer una funcion que diga cuantas veces fue llamada anteriormente.

VER ex2.c
VER ex3.c

  1. #####################################################

Delicias de ++ y –, junto a un error de Java
——————————————————
a++ usa el valor de a y lo incrementa luego. ‘Luego’ es
antes de la sentencia siguiente, en cualquier momento,
cuando se deja librado al compilador.

++a es Incremente y Use.

a– y –a, igual pero decrementa.

Esto significa que si tenemos una funcion f que toma
tres enteros,
int i=1;
f(i++, i++, i++);

f puede recibir segun el compilador 1, 1, 1 o 1, 1, 2 o 1, 2, 3,
en otras palabras, no hacer esto!

Ejercicios:

ex2.c

  1. include <stdio.h>

int cuantas_veces_me_llamaron(){
int i = 0;
return ++i;

} /* esto no funca porque siempre se inicializa
a 0 i, por eso la ponemos estatica */

int working_cuantas_veces_me_llamaron(){
static int i = 0;
return ++i;
}

int main(){

int i;
for(i=0; i<=1000; i++)
printf(“%d \n”, working_cuantas_veces_me_llamaron());

return 0;
}

ex3.c

#include <stdio.h>

int main(){

int i;
for(i=0; i<10; i++){

int j=5; /* cada vez que se ejecuta el for,
j es creada */
static int k = 5; /* static, lero lero */

printf(“%d\t %d \n”, j, k);
j++; k++;

}
return 0;
}

ex4.c

#include <stdio.h>

int main(){
int i=10;
i += i++;
printf(“%d\n”, i);
return 0;
/* esto devuelve 21 en C, en java
devuelve 20 */
}

Archivado en: C With Guido Style