Apuntesc PDF

UNIVERSIDAD TECNICA FEDERICO SANTA MARIA
DEPARTAMENTO DE ELECTRONICA
ELO311 Estructuras de Computadores
C
Contenidos
1.- Características del lenguaje
2.- Modelo de Máquina
3.- Declaraciones
4.- Punteros
5.- Expresiones
6.- Estructura de Acciones
Características
• Portabilidad
• Reemplaza Assembler
• Compilación Eficiente
• Bibliotecas
• Control de Flujo estructurado
• Conjunto amplio de operadores
• Punteros. Aritmética de direcciones
• Funciones. Paso por valor
• Arreglos y Punteros
• Tipos simples
• Capacidad de crear Estructuras de Datos
• Clases de Almacenamiento
• Preprocesador
Compilación (Ambiente)
fuentes estándar → fuentes

↓ ← preprocesador
preprocesado
↓ ← compilador
assembler
↓ ← ensamblador
objeto
objetos estándar → ↓ ← ligador
ejecutable
Profesor Leopoldo Silva Bijit 18-07-02 Lenguaje de Programación C. 1

Compilación Separada
m1.c m2.c m3.c
main(...)
cc -o ejec m1.c m2.c m3.c
cc -c m2.c
cc -o ejec m1.c m2.o m3.o
En lugar de comandos individuales, puede crearse un proyecto, el cual organiza en

forma automática el proceso.
Sintaxis
Se emplean los siguientes metasímbolos:
* indica la repetición de una o más veces.
[ ] indica que el elemento es opcional.
| indica elementos alternativos.
Programa :
/* comentario */
#include <archivo estándar>
#include “archivo local”
#define IDENTIFICADOR constante
definición de datos *
función *
Definición de datos :
external declaración [ iniciación ]; 

static declaración [ iniciación ];
Función :
tipo nombre(tipo a1, tipo a2) /*argumentos*/

{ declaración * /* variables locales */
acción *
}

• Acciones
acción:
expresión ;
acción nula:
;
acción rotulada:
rótulo : acción ;
bloque:
{
acción *
}
alternativa:
if (expresión)
acción1
[ else
acción2 ] /*expresión = 0 se efectúa acción 2*/
alternativas mutuamente excluyentes:
if (e1)
a1
else if (e2)
a2
else if (e3)
a3
else
a4
switch:
switch (exp)
{
case const1:
acción *
break;
.
.
default :
acción *
break;
}
Iteración:
while (expresión )
acción *

Lazo For:
for (inicio; condición; reinicio) bloque
inicio;
while (condición) {
bloque;
reinicio;
}
Ejemplo típico de for: for ( i=0 ; i<N ; i++ )
Repetición:
do
bloque
while (exp);
Control:
continue;
break;
goto rótulo;
return;
Retorno:
return (expresión);
• Expresiones
Llamado a función:
función ( [ exp [, exp ] * ] )
Acceso a valor de componente:

arreglo[ exp ]
Acceso indirecto:
*puntero
Variable:
variable
Constante:
constante
• Operadores :
Expresión <op. Diádico> expresión
<op. Monádico> expresión /*prefix */
expresión <op. Monádico> /*postfix */

Precedencia: Operadores reciben operandos en orden de menor precedencia.
Ejemplo : X + Y * Z es equivalente a (X + (Y*Z))

El operador + recibe operandos después de *.
()
-
Menor
*/
Precedencia
+-
Nota: Si se deseara primero la suma, debe emplearse paréntesis:

(X+Y)*Z
Asociatividad
Operadores diádicos: Si son de igual precedencia se asocian de Izquierda a

Derecha.
Ejemplo:
X*Y*Z es equivalente a (( X * Y ) * Z )
Operadores monádicos y asignación: Se aplica asociatividad de Derecha a

Izquierda.
X=Y=Z es equivalente a ( X = (Y = Z ))
Operadores Aritméticos
X+Y
X-Y
X*Y
X/Y
X%Y Módulo
Operadores Monádicos
-X Negativo
X++ Toma valor de X y después incrementa a X.
X-- Toma valor de X y después decrementa a X.
++X Incrementa a X y después toma valor de X.
--X Decrementa a X y después toma valor de X.
Nota : X debe ser un lvalue. (left-value indica una variable en la cual se puede
almacenar información; por ejemplo, x+1 no es un l-value.)

Operador de Asignación
X=Y Y se convierte al tipo de X. X toma el valor de Y.

lvalue=exp.
X op = Y Equivalente a X = X op Y
op puede ser + , - , * , / , %, | , ^ , & , >> ,<<.
Nota : X debe ser un lvalue.
Jerarquía de Tipos
double ← float
Ç
long
Ç
unsigned
Ç
int ← char, short
Ç conversión automática (implícita).
Operaciones Lógicas ( Al bit )

X&Y and
X|Y or
X^Y xor
∼ X Complemento uno. Operador monádico
X << Y Desplazamiento a la izquierda
X >> Y Desplazamiento a la derecha.
Operandos se tratan como palabras (enteros)
Operaciones Lógicas ( Resultado Booleano )

X && Y and Con cortocircuito
X || Y or Con cortocircuito
!X not Negación. Operador monádico
Operaciones Relacionales:
Valor 1 si la expresión es verdadera.
X>Y
X<Y
X>=Y
X<=Y
X==Y Iguales
X!=Y Diferentes
Condicional:
X?Y:Z X ≠ 0 ⇒ Y; X=0⇒ Z

Secuencia:
X,Y Asegura ejecutar primero X, luego Y.
Cast ( Conversión Explícita de tipo) :
( tipo ) X
Modelo de Memoria
ejec.out
Código
PC (text) Funciones
Datos Externas
Variables
iniciada con valores
Estáticas
iniciada en cero
Dinámica
SP Argumentos Variables
automáticas
FP Variables Locales
Stack
internas
Registros

Manejo Dinámico (Frames)

espacio de f2
SP main()
{
FP f.p. int V1,V2;
d.r. .
.
a 1 f1( 3,V1+V2 );
.
b 2 .
}
c 3
espacio de f1
f1(x,y)
int x,y;
m a
f.p. {
d.r. char m='a';
.
.
x 3 f2(1,2,3);
.
y 6 .
}
espacio del main
V2 2 f2(a,b,c)
V1 4 int a,b,c;
f.p. {
.
dir. retorno .
}

Objetos Manejo Estático
Segmento Datos Segmento Código
a 0 f1
1
arreglo
funciones
n-1 f2
s
string
0 \0
e
estructura
u
unión
p
puntero
Los nombres de las funciones y de las estructuras: arreglos, struct, string, union son
punteros.

Alcance y visibilidad
En m1.c se define x En m2.c se declara x
m1.c m2.c
int x; /*definición*/ extern int x; /*declaración*/
f1(); f3();
{ {
.... int x;
} ...
int y; }
f2()
{
int z:
...
}
Se reserva espacio en la definición.
Declaraciones.
{
Alcance
Identificador Declaración Clase Almacenamiento
Tipo
Escalar: [clase] tipo nombre

Arreglo: [clase] tipo nombre[constante]; nombre[];
Función: [clase] tipo nombre();
Puntero: tipo *nombre;
arreglo punteros: tipo *nombre[constante];
Punteros
Variable que contiene la dirección de un objeto.
Definición :
x variable de tipo T
T x;
p
T *p;
Operadores :
&x dirección de x
*p indirección. Objeto apuntado por p

Fijar Puntero :
p x
p=&x
Declaraciones Recursivas
Ejemplo Declaraciones :
int x;
int *pi;
int **ppi;
pi x
pi = &x 5
ppi
ppi =&pi
La declaración recuerda como usar la variables en expresiones:
*pi = 5;
**ppi = 5;
Declaraciones Recursivas :
int *fpi(); función que retorna puntero a entero
int (*pfi)(); puntero a función que retorna int
int *(*pfpi)(); puntero a función que retorna puntero a entero
Declaraciones Abstractas :
char *pc;
float *pf;
int *(*pfpi)( );
Cast :
pf=(float *) pc;
pc=(char *) pf;
pfpi=(int *(*)( ))pc; /*algunas son difíciles de interpretar*/

Diseño de funciones. Comunicación vía variables externas
int x; /* definición */
char c;
f1(...)
{
out x
f
1
x = ...;
...
in x
f
1
= .... + x ;
}
f2(...)
...
{ extern int x; /* declaración */
x =... ;
}
Comunicación vía variables externas
f2 f1
f2(...); /*escribe en x*/

f1(...); /*lee desde x*/
Comunicación vía argumentos
T1 a[10]; /* definición */
T2 x;
.
.
.... = f(a,b); /* invocación */
.
.
f(T1 b[10], T2 y) /* definición función */
{
.
.
}
Al llamar a la función se le pasan valores. Paso por Valor .

Funciones que no retornan valores enteros

1.- En definición :
T f(tipo a)
{
.
.
return( valor con tipo T );
}
2.- Dentro de función que invoque a f :
c(...)
{
T f( ); /* declaración */
...
... f(5); /* invocación */
}
Arreglos
Definición :
int a[10];
a[0]
a[1]
a[2]
a[3]
a[4]
..
..
a[9]
char línea[80]; /* definición */

char *mensaje;
mensaje="hello world\n";
Arreglos de Caracteres
int f(char s[ ])
/*declaración tamaño desconocido*/
{
int i = 0;
while (s[i]!= '\0') i++;
return(i);
}
/*ejemplo invocación*/
largo = f(línea);

Arreglos y Punteros
El nombre de un arreglo es un puntero.
char a[100];
char *pa=a;
pa a
pa = &a[0] es equivalente a pa=a

↑
puntero constante.
pa + i es la dirección de a[i]
Arreglos y Punteros
Contenidos Direcciones
a[0] *pa &a[0] pa

. .
. .
. .
. .
a[i] *(pa+i) &a[i] pa+i
Arreglos Punteros
Aritmética de Punteros
a) puntero + entero
Si pa = a , entonces
pa + i es la dirección de a[i]
No importando el tipo, i es multiplicado por el tamaño del objeto a que pa

apunta y luego sumado a pa.
b) Comparaciones y Relaciones con punteros
Si p y q apuntan al mismo arreglo pueden:

- b1). Compararse
p<q p>=q p!=q p==q
- b2). Restarse
0
1 q
2
. p
.
p-q es el número de componentes entre p y q .
Expresiones con Punteros

px x
*px + 1 x+1
*px = 0 x=0
*px += 1 x++
(*px)++ x++
*px++ toma valor de x y además px=px+1
*(px+1) contenido celda siguiente a x
py = px copia punteros
Precedencia de * y & es alta. Se evalúan de derecha a izquierda.

px++ apunta al siguiente
px+=i apunta i elementos sobre el corriente
*++px incrementa px, luego trae valor
*++px decrementa px, luego trae valor
*px++ trae valor, luego incrementa puntero
Llamado por Referencia

T a, b, c; /* Objetos de tipo T */
T *p; /* Puntero
f(T *p) /* Función sobre objeto de tipo T */

{
f
out
*p = ......
.
f
in
...=....*p

Ejemplos de invocación. Se pasa la dirección de la variable.

f(&a); /* opera sobre a */
f(&b); /* opera sobre b */
Diseño con arreglos Diseño con punteros
void strcpy(char s[ ],char t[ ]) void strcpy(char *s,*t)

{ {
int i;
i=0; while((*s=*t)!='\0')
while( (s[i]=t[i]) !='\0') { s++;t++}
i++; }
}
El ejemplo muestra que el código puede ser difícil de leer.

char *pl1(char *p) /* retorna puntero al último carácter de un string */
{ while (*p != '\0') p++; return (p-1); }
Considerando que el único carácter que toma valor cero(falso) es el nulo, puede
modificarse el diseño según:
char *pl2(char *p) /* puntero al último carácter de un string */
{ while (*p) p++; return (--p); }
El post decremento permite escribir:

{ while(*p++); return (p-2);} /*pero debe modificarse el valor de retorno*/
Y el siguiente código introduce un error serio en el diseño.

{ while((*p)++) ; return (p-2);}
Modifica el primer carácter del string, cuando pasa de 0xFF llega a 00 y sale
retornando un puntero que apunta a algo fuera del string.
Las funciones anteriores deben ser refinadas para tratar el caso de strings nulos.
Matrices
int m[2][4];
2x4
Se almacenan por renglones :

m[0][0]
m[0][3]
m[1][0]
m[1][3]
Índice más derechista varía más rápido si se accesa según el orden de

almacenamiento.
Se inicializan por listas :

int m[2][4]={{0,1,2,3},{4,5,6,7}};
Matrices como argumentos.

Si se pasa una matriz a una función, la declaración del argumento debe incluir la
dimensión de la columna. La dimensión del renglón es irrelevante, ya que se pasa un
puntero.
f(int m[ ] [4]) f(int (*m)[4])

{ {
... ...
} }
(paréntesis obligatorio:
[ ] tiene mayor precedencia que *.
( Ver K.R apéndice A. Pto. 8.6)
Arreglo de punteros
Definición:
to *ap[n];
ap
0
1
objetos de tipo to
n-1
Notación:
ap[i] es puntero a objeto tipo to
*ap[i] es el objeto de tipo to

Declaración:
f(to *s[ ])
{
.....
}
Ej. Ver : Iniciación de arreglo estático K.R. 5.9
Uso en tablas de string de largo variable
Arreglo de Punteros v/s Arreglo Multidimensional

b
p lo lo
lo: largo
objeto i i
Acceso: p + i*lo b + i*lo + j*lo
Espacio: Requiere espacio adicional
Largo: Variable Constante
Ej. Argumentos de la línea de comandos.Ver K.R. 5.11
main(int argc, char *argv[ ])

/* argc: número de argumentos */
/* argv: arreglo de punteros */
{...
}
argv[0] es el nombre del programa
argv[1] es el primer argumento
argv[argc-1] es el último argumento. Si argc es 1, no hay argumentos.
Paso de Funciones . Puntero a función
Sea una función entera f.

int f(...); /* es la dirección de f. */
/* No es necesario el &. Ver K.R.14.2*/
g(f); /* Se llama a f. Se genera puntero a f. */
.... /* (se toma la dirección de f) */
/* es diferente g(f()) */

Entonces en la definición de g :
g(int (*fp)() )
/* *fp es la función. */
{... /* fp es el puntero a una */
/* función que retorna entero */
(*fp)(...); /* (*fp)(...) es el llamado a la */
/* función con argumentos ... */
...
}
Función que retorna un puntero a entero.

int *f( ); /*es equivalente a: int *(f( )) */
Cuando se use : Se llama a f y luego se aplica indirección, a través del puntero, para
obtener el entero.
Ejemplo con punteros.

int a[ ]={0,1,2,3,4};
int *p[ ]={a,a+1,a+2,a+3,a+4};
int **pp=p;
Visualización del espacio de variables :
pp
a 0 1 2 3 4
p es arreglo de punteros a enteros

pp contiene la dirección de p
*pp es p[0]; dirección de a[0]
**pp es a [0]; valor de a[0]
p dirección de arreglo p
*p dirección de a[0]
**p valor de a[0]
a dirección arreglo
*a valor de a[0]
Después de pp++ determinar valores de :

pp - p, *pp - a, **pp

pp
a 0 1 2 3 4
Respuesta :
pp apunta a p[1]; su valor es p+1. Por lo tanto: pp-p=(p+1)-p=1
*pp dirección de a[1]; su valor es a +1. Por lo tanto *pp-a = (a+1)-a =1
**pp es el contenido de a[1]; es 1
Ejemplo : Continuación
pp pp
p p
*pp++
a 0 1 2 3 4 a 0 1 2 3 4
es *(pp++)
++*pp Habría sido igual con:

*++pp *(++pp)
pp
p
es ++(*pp)
a 0 1 2 3 4
Tipos Estructurados
struct registro cartesiano. Agrupa componentes de diferente tipo.

union unión discriminada (registro con variantes)
Declaración o molde:
nombre del objeto
struct colección {
tipo1 miembro1;
tipo2 miembro2;
..
} ;
si se pone lista de variables,

se las define de tipo colección.

Definición:
struct colección x,y,z; /*define tipo a variables x,y,z */
Iniciación: (de estructuras estáticas o externas )

Se colocan valores en una lista, separada por comas, y entre paréntesis cursivos.
Ver K.R. 8.6 Apéndice A.
Observaciones:
- No se puede tomar dirección de los miembros (no hay punteros a los miembros; si
a la estructura)
- Pueden ser recursivas
- Pueden anidarse estructuras
- Se puede pasar (o sacar) estructuras de funciones (En C de K.R. no se puede y
deben pasarse (o escribirse) punteros)
- Se puede asignar o copiar una estructura como unidad. (En Ansi C. No en C de
K.R.)
- En C++ el concepto está refinado aún más, y es el modelo del objeto.
Ejemplo:
struct nodo {
char palabra[20];
int cuenta;
struct nodo *izq;
struct nodo *izq;
};
struct nodo s, *sp;
objeto puntero a objeto
nodo
palabra
cuenta

Manipulación
1.- Tomar su dirección con &

2.- Acceso a miembros
2.1.- Acceso directo
(se usa selector . igual que Pascal)
Expresiones :
s.cuenta accesa al entero
s.izq acceso al puntero izq
2.3.- Acceso indirecto (vía puntero)

(*sp).cuenta el . tiene mayor precedencia que el *
Se usa la siguiente notación :
sp -> cuenta
sp.der -> palabra[0]
Obs. El . y -> se asocian de izq a der:

x.y.z se lee (x.y).z
3.- En funciones
- Se pueden pasar valores de los miembros.
f(s.cuenta,...)
Con : f(int x,....)

...
- Pasar puntero a estructura, como argumento de una función:
En la invocación, con sp puntero a estructura nodo: f(sp)
En la definición de la función:
f(struct nodo *p)
{
....
}
Operadores y Significados
Con :
struct { p x y
int x;
int *y;
} *p;
++p->x se interpreta: ++(p->x) incrementa x

(++p)->x incrementa p antes de accesar x
(p++)->x incrementa p después de accesar x
*p->y es: *(p->y) trae lo que apunta y
*p->y++ es: *(p->(y++)) accesa lo que y apunta luego incrementa y

(*p->y)++ incrementa lo que y apunta

*p++->y es: *((p++)->y) accesa lo que y apunta, luego incrementa p
*p++ es: *(p++)
Fields: Campos en C
Se empaquetan varios objetos en una palabra de memoria.
a) Implementación con operadores al bit.
Ver K.R. 6.7 se definen máscaras para posiciones
b) Con estructuras
Se definen un conjunto adyacente de bits, dentro de un entero.(se especifica
el ancho en bits)
struct {
unsigned is_keyword:1;
unsigned is_extern:1;
}
c) La unión es importante en compiladores cruzados, a través de ella puede mapearse
los registros y bits de un microprocesador.
Observaciones:
- Dependen de la implementación (hardware)
- Pueden tenerse campos sin nombre (para relleno)
- La suma de largos de campos, no debe exceder el largo del entero. (en caso de
hacerlo, los campos siempre se alinean)
palabra
Si se tiene:
Queda:
se pierde espacio
- Se manipulan como estructuras
Unión
Variable que en diferentes tiempos almacena objetos de diferente tipo.
Espacio reservado es el del tipo que ocupe más espacio.
Es responsabilidad del programador, el tipo de dato que está corrientemente
almacenado.
Acceso similar a estructuras.

Pueden existir dentro de estructuras y arreglos y viceversa.
El compilador trata los tipos, en la unión, con alineación.

Ejemplo: union u{
int i;
float f;
char *p;
} x;
Entonces: x.i extrae el entero

x.f es tratado como real
x.p es un string
*x.p primer carácter del string
Ejemplo: si se sabe que el entero es alinado con una palabra; entonces h estará
siempre alineado correctamente con:
union h{ tipocomplejo c;
int x;
}
Typedef
- Permite definir tipos

- Le da nombre a un tipo existente
- Es interpretado por el compilador.
(#define..) es interpretado por el preprocesador.
- Proporciona buena documentación
- Parametriza un programa contra problemas de portabilidad (por ejemplo conviene
utilizar typedef en tipo que son dependientes de la máquina, solo se requiere cambiar
esas definiciones)
- Conviene emplear para definir estructuras complejas de datos.
Ver K.R. 6.9

Ver en manuales la definición de tipo enumerativo.

Apuntesc PDF

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Apuntesc PDF

Uploaded by

Copyright:

Available Formats

UNIVERSIDAD TECNICA FEDERICO SANTA MARIA

fuentes estándar → fuentes

Profesor Leopoldo Silva Bijit 18-07-02 Lenguaje de Programación C. 1

m1.c m2.c m3.c

cc -o ejec m1.c m2.c m3.c

cc -o ejec m1.c m2.o m3.o

En lugar de comandos individuales, puede crearse un proyecto, el cual organiza en

external declaración [ iniciación ]; 

tipo nombre(tipo a1, tipo a2) /*argumentos*/

Profesor Leopoldo Silva Bijit 18-07-02 Lenguaje de Programación C. 2

Profesor Leopoldo Silva Bijit 18-07-02 Lenguaje de Programación C. 3

Ejemplo típico de for: for ( i=0 ; i<N ; i++ )

Acceso a valor de componente:

Profesor Leopoldo Silva Bijit 18-07-02 Lenguaje de Programación C. 4

Precedencia: Operadores reciben operandos en orden de menor precedencia.

Ejemplo : X + Y * Z es equivalente a (X + (Y*Z))

Nota: Si se deseara primero la suma, debe emplearse paréntesis:

Operadores diádicos: Si son de igual precedencia se asocian de Izquierda a

Operadores monádicos y asignación: Se aplica asociatividad de Derecha a

Profesor Leopoldo Silva Bijit 18-07-02 Lenguaje de Programación C. 5

X=Y Y se convierte al tipo de X. X toma el valor de Y.

Operaciones Lógicas ( Al bit )

Operaciones Lógicas ( Resultado Booleano )

Profesor Leopoldo Silva Bijit 18-07-02 Lenguaje de Programación C. 6

Cast ( Conversión Explícita de tipo) :

Profesor Leopoldo Silva Bijit 18-07-02 Lenguaje de Programación C. 7

Manejo Dinámico (Frames)

Profesor Leopoldo Silva Bijit 18-07-02 Lenguaje de Programación C. 8

Objetos Manejo Estático

Segmento Datos Segmento Código

Profesor Leopoldo Silva Bijit 18-07-02 Lenguaje de Programación C. 9

Se reserva espacio en la definición.

Escalar: [clase] tipo nombre

Profesor Leopoldo Silva Bijit 18-07-02 Lenguaje de Programación C. 10

La declaración recuerda como usar la variables en expresiones:

Profesor Leopoldo Silva Bijit 18-07-02 Lenguaje de Programación C. 11

Diseño de funciones. Comunicación vía variables externas

f2(...); /*escribe en x*/

Profesor Leopoldo Silva Bijit 18-07-02 Lenguaje de Programación C. 12

Funciones que no retornan valores enteros

char línea[80]; /* definición */

Profesor Leopoldo Silva Bijit 18-07-02 Lenguaje de Programación C. 13

pa = &a[0] es equivalente a pa=a

a[0] *pa &a[0] pa

a[i] *(pa+i) &a[i] pa+i

No importando el tipo, i es multiplicado por el tamaño del objeto a que pa

b) Comparaciones y Relaciones con punteros

Si p y q apuntan al mismo arreglo pueden:

Profesor Leopoldo Silva Bijit 18-07-02 Lenguaje de Programación C. 14

Expresiones con Punteros

Precedencia de * y & es alta. Se evalúan de derecha a izquierda.

Llamado por Referencia

f(T *p) /* Función sobre objeto de tipo T */

Profesor Leopoldo Silva Bijit 18-07-02 Lenguaje de Programación C. 15

Ejemplos de invocación. Se pasa la dirección de la variable.

Diseño con arreglos Diseño con punteros

void strcpy(char s[ ],char t[ ]) void strcpy(char *s,*t)

El ejemplo muestra que el código puede ser difícil de leer.

El post decremento permite escribir:

Y el siguiente código introduce un error serio en el diseño.

Profesor Leopoldo Silva Bijit 18-07-02 Lenguaje de Programación C. 16

Índice más derechista varía más rápido si se accesa según el orden de

Se inicializan por listas :

tipo nombre(tipo a1, tipo a2) /argumentos/

f2(...); /escribe en x/

f(T p) / Función sobre objeto de tipo T */

void strcpy(char s[ ],char t[ ]) void strcpy(char s,t)

Acceso: p + ilo b + ilo + j*lo

struct colección x,y,z; /define tipo a variables x,y,z /