Lenguaje C ( programación)

declaran para el resto del archivo que "sp" es un entero, y "val" es un arreglo double (cuyo tamaño se fija en otro lugar), pero no se crean las variables ni se les asigna memoria.
Variables estáticas
Las variables estáticas son accesibles solo dentro del archivo donde son definidas. Y pueden ser definidas dentro o fuera de una función.
Ej. Si las 2 variables y las 2 funciones siguientes se compilan
en un archivo con:

static char buf[BUFSIZE]; /* buffer para "ungetch" */
static int bufp=0; /* sig. pos. libre en "buf" */
getch() {...}
ungetch() {...}
el resto de las funciones de los otros archivos no tendrá acceso ni a "buf" ni a "bufp". Por lo anterior, no habrá conflictos si los mismos nombres son usados en otros programas.
Una función estática es inaccesible fuera del archivo donde se declara (y define, por supuesto).
Variables registro.
Las variables registro sólo pueden ser las variables automáticas y los parámetros formales de la función.
Las variables registro son usadas para variables muy usadas. El compilar coloca las variables registro en los registros de la CPU de la máquina, siempre y cuando sea posible.
NO ES POSIBLE obtener la dirección de una variable estática.
Se declaran de la siguiente manera:
register int x;
register char c;
Y la declaración para parámetros formales de función, es:
f(register int c,n)
{
...
}
Estructura de bloques
Se tienen las siguientes características:
- No se pueden definir funciones dentro de funciones. Si embargo si se pueden declarar funciones dentro de funciones. Esta declaración hace referencia a funciones que se encuentran en otro parte.
- Las declaraciones o definiciones (incluyendo inicializaciones), se colocan dentro de las llaves que introduce cualquier sentencia compuesta.
Por ejemplo:
if (n>0)
{
/* se declara una variable nueva "i" */
int i;
for (i=0; i
...
Inicialización
La inicialización tiene las siguientes consideraciones:
- Si no se inicializan explicitamente las variables, se tiene:
- Las variables externas y estáticas tendrán cero.
- Las variables automáticas y registro tendrán basura.
- Las variables simples, que no son arreglos ni estructuras, se inicializan así:
int x;
char squoute = '\'';
long day=60*24; /* minutos del día */
- Las variables externas estáticas se inicializan una vez en tiempo de compilación; las variables automáticas y registro, cada vez que se entra a la función.
- Las variables automáticas y registro se pueden inicializar con valores definidos previamente, incluso llamadas a función. Por ejemplo:
int low=0;
int high=n-1; /* n definida anteriormente */
int mid;
..
}
- Los arreglos automáticos no pueden ser incializados.
- Los arreglos externos y estáticos se inicializan con valores separados por ',' y entre llaves. Por ejemplo, el programa siguiente para contar dígitos, espacios y otros:
/* cuenta dígitos, espacios y otros */
main()
{
int c,i,nwhite,nother;
int ndigit[10];
nwhite=nother=0;
for (i=0; i<10; i++)
ndigit[i]=0;
...
}
puede ser escrito como:
/* cuenta dígitos, espacios y otros */
int nwhite=0;
int nother=0;
/* inicialización con 10 0's */
int digit[10]={0,0,0,0,0,0,0,0,0,0,0};
main()
{
int c,i;
...
}
- Se pueden inicializar arreglos de caracteres de 2 maneras:
- Como cadena de caracteres
char pattern[]="the";
- Como arreglo de caracteres
char pattern[]={'t','h','e','\0'};
Recursividad
- Las funciones en C pueden llamarse a si mismas, es decir pueden ser recursivas.
- Una función puede llamarse a si misma, directa o indirectamente. Por ejemplo:

/* imprime n en decimal (recursivamente) */
void printd(int n)
{
int i;
if (n<0)
{
putchar('-');
n=-n;
}
if ((i=n/10) != 0)
printd(i);
putchar(n%10+'0');
}

El preprocesador de C
Inclusión de archivos (include):
Una línea de la forma
#include "nombre"
indica al preprocesador de C, substituir la línea con el contenido del archivo "nombre", de trayectoria absoluta.
Una línea de la forma
#include <nombre>
indica al preprocesador de C, substituir la línea con el contenido del archivo "nombre", de la trayectoria PREDEFENIDA para los archivos "include".
Los "include"s pueden ser anidados.
Los "include"s son recomendables para tener las mismas definiciones en varios programas fuentes.
Sustitución de Macros
Para sustituir SI por 1, usamos la línea siguiente.
#define SI 1
aquí, las cadenas "SI=" no serán sustituidas.
Para usar una sintaxis similar al PASCAL, usamos las líneas
#define then
#define begin {
#define end }
y podríamos escribir después
if (i>0) then
begin
a=1;
b=2
end
Podemos usar parámetros en la sustitución de macros. Por ejemplo:
#define max(A,B) ( (A)>(B) ? (A) : (B) )
y usarla como
x=max(p+q,r+s);
que sería sustituida por
x=((p+q)>(r+s) ? (p+q) : (r+s));
NOTAS:
- Es necesaria utilizar paréntesis en la definición de macros, para evitar resultados erróneos debido a la prioridad de las operaciones aritmÚticas.
- Con una MACRO se puede crear una sola función para varios tipos de argumentos.
- Las MACROS con parámetros son más eficientes que las llamadas a funciones, ya que son una expansión en línea. Por ejemplo, las funciones "getchar()" y "putchar()" están definidas como MACROS de las funciones "putc()" y "getc()", usando la salida estándard (stdout) y entrada estándard (stdin) respectivamente.

Los símbolos * y & pueden ser usados para el contenido y la dirección de una variable, respectivamente. Por ejemplo,
si "x" es una variable de tipo "int"
y "y" es una variable de tipo "int"
y "px" es una variable de tipo "apuntador a int"
entonces, se podría hacer lo siguiente:
Asignar la dirección de "x" al apuntador "px"
px = &x;
Aumentar en 1, el valor apuntado por "px" (es decir, el valor de "x") y asignarlo a la variable "y".
y = *px+1;
Aumentar en 1, el valor del apuntador "px" (es decir, el valor de una variable desconocida) y asignarlo a la variable "y".
Aumentar en 1 el valor apuntado por "px" (es decir, el valor de "x").
*px+=1;
o bien
(*px)++;
notar que en este último ejemplo es necesario usar parÚntesis, debido a que, aunque la prioridad de "*" y "++" es igual, la asociatividad es de DERECHA a IZQUIERDA. Así, sin los parÚntesis, la expresión "*px++;" se entendería como: "*(px++);".

APUNTADORES Y ARREGLOS
Se definimos el arreglo de 10 enteros de la siguiente manera:
int a[10];
podemos referenciar a[0] a[1] .. a[9].
Si además definimos el apuntador a entero "pa"
int *pa;
y le asignamos la dirección del primer elemento del arreglo "a",
pa=&pa[0]; o bien pa=a;
entonces, el contenido de "a[i]" puede ser visto con
*(pa+i)
En apuntadores a arreglos de caracteres, las 2 siguientes declaraciones son equivalentes:
char s[];
char *s;
AritmÚtica de direcciones.
Son posibles las siguientes operaciones con apuntadores:
- Sumar y restar un entero a un apuntador.
- Restar y comparar 2 apuntadores.
- Comparar un apuntador con NULL.
Apuntadores a caracteres y a funciones.
En el siguiente ejemplo, la variable "mensaje" es SOLO UN APUNTADOR.
char *message="now is the time";
No se debe comfundir el envío de un APUNTADOR a un arreglo de caracteres con el envío del ARREGLO de caracteres. Por ejemplo, en la siguiente función se envían los apuntadores a 2 arreglos de caracteres (cuya memoria fue asignada en otra parte del programa).
strcpy(s,t) /* copia t a s, con apuntadores */
{
while (*s++=*t++)
;
}
Arreglos Multidimensionales
En C, los arreglos de 2 dimensiones se implementan como arreglos unidimensionales. Donde cada elemento es, a su vez, un arreglo unidimensional. Por lo anterior, la sintaxis en C es
day_tab[i][j]; /* [renglón] [columna] */
en lugar de:
day_tab[i,j]; /* INCORRECTO */
Los arreglos de 2 dimensiones pueden ser inicializados como sigue:
static int day_tab[2][13] =
{
{0,31,28,..,31},
{0,31,29,..,31},
};
Arreglo de apuntadores. Apuntadores a apuntadores.
Inicialización de arreglos de apuntadores:
static char *name[]=
{
"mes ilegal",
"enero",
...
"diciembre",
};
Diferencia entre apuntadores y arreglos multidimensionales.
No se debe confundir las declaraciones:
int a[10][20]; /* matriz de 10*20=200 enteros */
int *b[10]; /* vector de 10 apuntadores a enteros */
/* o 10 apuntadores a arreglos a enteros */
Si consideramos que en los 2 arreglos anteriores, usamos
[renglón] [columna]
Entonces tenemos 2 diferencias básicas:
1. En el arreglo "a" el número de columnas (elementos) x renglón es 20 para todos los renglones. En el arreglo "b" podemos tener un número diferente de columnas x renglón para cada renglón. Por ejemplo 2 elementos en el renglón 0; 5 en el renglón 1; e incluso una matriz de 4x4 en el renglón 3, etc.
2. La memoria ocupada por los 2 arreglos es diferente. Inclusive en el caso de que los apuntadores del arreglo "b" apuntaran a un arreglo de 20 elementos por renglón, la memoria ocupada por los 2 arreglos sería diferente.
Para el arreglo "a", 200 enteros.
Para el arreglo "b", 200 enteros + 10 apuntadores.
Argumentos de la línea de comandos.
Al correr el programa ejecutable producido por un programa fuente escrito en C, podemos agregar argumentos en la línea de comandos. Estos argumentos pueden ser usados para producir efectos diferentes al correr el mismo programa. Así, podríamos usar opciones como las usadas en los sistemas operativos:
C:> copy
C:> copy a:\arch1 b:
C:> copy a:\arch1 b:\arch2
El procesamiento de los argumentos de la línea de comandos se puede ejemplificar con el siguiente programa en C, que simplemente escribe los argumentos en la salida estándard.

/* escribe los argumentos en la salida estándard */
main(int argc, char *argv[])
{
while(--argc>0)
printf("%s%c",*++argv,(argc>1)?' ':'\n');
}

"argc" y "argv" son palabras predefinidas. "argc" indica el número de argumentos (incluyendo el nombre del programa ejecutable). "argv" es un arreglo de apuntadores a arreglos de caracteres. "argv[i]" es un apuntador al arreglo de caracteres del argumento i.
Por ejemplo, si "echo.exe" es un programa ejecutable producido por un programa escrito en C, entonces al ser corrido con:
echo hello world
los valores que tomarían "argc" y "argv" en caso de haber sido usados son:
argc=3 *argv[0]=echo *argv[1]=hello *argv[2]=world
Apuntadores a funciones
En la definición:
/* compara 2 cadenas */
int strcmp();
En la declaración:
/* apuntador a función que devuelve un entero */
int (* comp)();

/* función que devuelve apuntador a entero */
int *comp();

. ESTRUCTURAS

. ENTRADA Y SALIDA

Acceso a la biblioteca estándard
La línea siguiente se coloca al principio de un programa fuente. Define ciertas macros y variables empleadas por la biblioteca estándard de E/S.
#include
Se usa < >, en vez de "", para que el archivo sea buscado en el directorio de información estándard, por ejemplo:
/usr/include ---> en UNIX
\TURBOC2.0\INCLUDE ---> en MS-DOS

Entrada y salida estándard: putchar(), getchar()
El uso de la entrada y salida estándard permite hacer redireccionamiento de y hacia archivos.
prog < arch_ent
prog > arch_sal
o bien procesamiento entubado, como en:
prog | otr_prog
otr_prog | prog
Por ejemplo, el siguiente programa copia la entrada estándard (teclado) a la salida estándard (monitor).

#include <stdio.h>
main()
{
int c;

/* lectura y almacenamiento */
pini=pfin=NULL
if (c=getchar()!=EOF) do c=getchar();
for (pini=pfin=NULL; (c=getchar())!=EOF; )
pfin=(struct scar *) malloc(sizeof(struct scar))
if (pfin=NULL)
puts("No hay memoria",stderr);
else
pini->car=c, pini->psig=NULL)
while (c!=EOF);