Clase1 c

Fundamentos de
Programación en C
(I Parte)

Prof. Mariela J. Curiel
Universidad Simón Bolívar
Caracas, Venezuela

•05/06/2011 •1

Copyright, 1996 © Universidad Sim‟on Bol‟ivar

 Características del Lenguaje
 Estructura de un programa en C.
 Conceptos Básicos: tipos básicos de
datos, expresiones, operadores
 Estructuras de Control
 Arreglos
 Otros tipos de datos derivados

Contenido
•05/06/2011 •2

 Funciones
 Apuntadores
 Asignación de memoria dinámica
y estructuras de datos
 Entrada/Salida
 Desarrollo de programas en
varios módulos.

Contenido
•05/06/2011 •3

 Es un lenguaje pequeño con pocas
palabras reservadas.
 Es portable.
 Tiene un conjunto muy poderoso de
operadores.
 Soporta la modularidad pero no obliga
a programar modularmente.

Características del lenguaje
•05/06/2011 •4

Estructura de un programa en
C
 Los programas C consisten de módulos o
piezas que se denominan funciones.
 Los programadores aprovechan una gran
cantidad de funciones existentes, que se
conoce como Librería Estándar de C.
 Una función llamada main es el punto
donde comienza la ejecución del
programa.

•05/06/2011 •5

#include <stdio.h> Librería estándar de C
#include “estructuras.h" Función main,
punto donde comienza el programa
int main() {

emple miemp[MAXEMP];
void imprimir(emple *emp, int cuantos) char line[MAXLIN], nom[MAXNOMBRE];
{
FILE *fp;
int i, edad=0, tiempo=0;
int i;

for(i=0; i < cuantos; i++) fp = fopen(argv[1], "r");
printf("%d %d %sn", i = 0;
emp[i].edad, emp[i].ttrabajo, emp[i].nombre);
while (getline(line, sizeof(line), fp) > 0) {
sscanf(line, "%d %d %s", &miemp[i].edad,
&miemp[i].ttrabajo,miemp[i].nombre);
}
i++;

}
imprimir(miemp, i);

Función realizada por
fclose(fp);
El usuario

}
•05/06/2011 •6

Conceptos Básicos
(Variables, Constantes,
Declaraciones)
 Variables

◦ Dan nombres únicos a varios objetos dentro
del programa. Representan una localidad
en la memoria del computador.
◦ Sus nombres pueden estar formados por
letras, dígitos y ´´_´´ (underscores), pero
no pueden comenzar con dígitos. Según el
estándar ANSI sólo se reconocerán los
primeros 31 caracteres.

•05/06/2011 •7

Conceptos Básicos
Declaraciones)
 Las variables deben declararse antes de
utilizarse con un nombre y un tipo de datos.
◦ En una misma línea se pueden declarar varias
variables del mismo tipo.
int a,b,c;
◦ C es case-sensitive: hace distinción de las
minúsculas y mayúsculas.
◦ Las declaraciones sirven para dos propósitos:
 le dicen al compilador qué cantidad de espacio
debe reservar.
 le permiten al compilador instruir a la máquina
para efectuar las instrucciones correctamente.
◦ Las palabras reservadas van en minúsculas

•05/06/2011 •8

Conceptos Básicos
Declaraciones)
int main() {
int integer1 = 2, integer2, sum; /* declaración */
integer2 = 20;
sum = integer1 + integer2;
printf(“La suma de %d y %d es %d”, integer1, integer2,
sum );
return 0; /* indica que el programa
terminó con éxito */
}
•05/06/2011 •9

 Los tipos base se dividen en tres
grandes clases:
◦ Los enteros: int, short int (16 bits),
long int (32 bits), unsigned int.
◦ Números de coma flotante: float,
double o long double
◦ Caracteres: char.

Conceptos Básicos
(Tipos de Datos Fundamentales)
•05/06/2011 •10

Tipos enteros
◦ signed: el bit más significativo se utiliza
para representar el signo y el valor
absoluto del número se codifica en los bits
restantes (15 o 31).
◦ unsigned: sólo se representan números
positivos o (nulos), utilizando todos los bits
disponibles.

Conceptos Básicos
•05/06/2011 •11

Tipos coma flotante
La zona utilizada para el número se
descompone en tres partes:
◦ un bit reservado para el signo
◦ un espacio para el exponente: 8 bits en el
float, 11 bits en el double, 14 en el long
double.
◦ el resto para la mantisa: 23 bits en el float,
52 bits en el double, 64 en el long double.

Conceptos Básicos
•05/06/2011 •12

int edad i, j = 3;
signed long a,x;
float z, temperatura;
char c1, c2;

Ejemplos (declaraciones)
•05/06/2011 •13

 C manipula varias clases de valores
enteros (29, 1234, etc), reales (3.14,
1.0e-5) que son ejemplos de
constantes.
 ´a’, ´b’, etc, son constantes tipo
caracter.
 Una secuencia de 0 o más caracteres
encerrados entre comillas (“Yo estoy
aquí”) es una constante de cadena o
cadena literal.

Conceptos Básicos (Constantes)
•05/06/2011 •14

Las líneas:

#define SIZE 10

#define PI 3.14159

definen constantes simbólicas. Una
constante simbólica es un identificador
que es reemplazado por el prepocesador,
antes que el programa sea compilado.

Conceptos Básicos
(constantes)
•05/06/2011 •15

 El uso de constantes hace el programa
más comprensible.
 Si una constante se ha definido a
través de #define y se usa en todo el
programa, es mas fácil cambiar su
valor posteriormente.

Conceptos Básicos
(constantes)
•05/06/2011 •16

 Escritura de constantes en coma flotante
◦ Decimal: 12.43 -0.38 -.38 4.
◦ Exponencial: 4.24E4 48e13 542.7E-33
-3e13
Por defecto, todas las constantes de coma
flotante son creadas por el compilador del tipo
double. Sin embargo es posible imponerle el
tipo: 1.25E03f (float)
1.0L (long double)

Conceptos Básicos
(Constantes)
•05/06/2011 •18

 Escritura de constantes tipo caracter:
◦ Los caracteres imprimibles se escriben
entre apóstrofes:´a’, ´y’ ´¿’ ´$’.
◦ Los no imprimibles se imprimen usando el
caracter “”. Ejemplos:
n LF (Line Feed) Salto de Línea
t HT (Horizontal Tab) Tabulación Horizontal
v VT (Vertical Tab) Tabulación Vertical

f FF (Form Feed) Salto de Página

Conceptos Básicos
(Constantes)
•05/06/2011 •19

 Los operadores aritméticos son: +, -, *,
/, %
 Son todos operadores binarios.
 El cociente entre 2 enteros devuelve un
entero, pero el cociente de dos números
en coma flotante es un número en coma
flotante.
5/2 = 2, pero 5./2. = 2.5

Conceptos Básicos (Operadores
aritméticos, relacionales, etc.)
•05/06/2011 •20

 Reglas de precedencia (consultar
bibliografía)
 Ejemplos
m=a+b+c+d+e (álgebra)
5

m = (a + b + c + e)/5 (Lenguaje C)

Si se omiten los paréntesis, la expresión se calcula como:
m = a + b + c + e/5
Conceptos Básicos (Operadores •05/06/2011 •21


EXPRESIONES, INSTRUCCIONES Y ASIGNACION
- Las expresiones son combinaciones de constantes,
variables, operadores y llamadas a funciones. Ejm:
a + b
3.0 * x - 9.66553
3+ sum(x,y)
- La mayoría de las expresiones tienen un valor.
- Si al final de una expresión se coloca un ´´;´´ la
expresión se convierte en una proposición:
I = 7;
z = 3+ sum(x,y);

-
•05/06/2011 •22

Conceptos Básicos
(Operadores aritméticos,
relacionales, etc.)
EXPRESIONES, INSTRUCCIONES Y ASIGNACION
• Las { } se emplean para agrupar declaraciones o
proposiciones en una declaración compuesta o bloque.
while (x == 1) { ....}
• El operador de asignación es el signo ´´=´´
I = 7;
la expresión como un todo toma el valor 7

• El operador ´´=´´ se asocia de derecha a izquierda,
de modo que:
x = y = z = 0 se resuelve
x = (y = (z = 0));
•05/06/2011 •23

int b = 5;
a = b; int b = 5;
if (a = 1) { a= b;
.... if (a == 1) {
} ....
}

•05/06/2011

•24

 Operadores de Incremento y
Decremento
-Son operadores unarios.
-Pueden aplicarse a variables, pero
no a constantes o expresiones.
-Pueden usarse como
-prefijos: ++a (preincremento), --a
(predecremento)
-sufijos: a++ (postincremento), a--
(postdecremento).
•05/06/2011 •25

int n = 5;
x = n++; /* asigna 5 a x
y el valor final de
n = 6 */

x = ++n; /* asigna 6 a x
n = 6 */

•05/06/2011 •26

Operadores RELACIONALES y de
IGUALDAD
 Son operadores binarios. Toman dos
expresiones como operandos y
producen el valor entero 0 ó 1.

•05/06/2011 •27

 Los operadores relacionales tienen el
mismo nivel de precedencia y se asocian
de izquierda a derecha.
 Los operadores de igualdad tienen un
nivel de precedencia menor que los
operadores relacionales. También se
asocian de izquierda a derecha.
a < b == c < d se interpreta como:
(a < b) == (c < d)

•05/06/2011 •28

Precedencia de operadores aritméticos y
relacionales (consultar material de
apoyo)
x + y < a + 2
es equivalente a:
(x+y) < (a + 2)

•05/06/2011 •29

Operadores Lógicos
 && || y !: cuando se aplican a las
expresiones producen los valores enteros
0 ó 1.
 La negación lógica puede aplicarse a una
expresión arbitraria.
 Si una expresión tiene el valor 0 o 0.0, su
negación producirá el valor entero 1. Si la
expresión tiene un valor distinto de 0 su
negación producirá el valor entero 0.

•05/06/2011 •30

Conceptos Básicos
relacionales, etc.)

 Ejemplo
!(2*(x+a)-3 - ’z’)
 Existen la tablas de la verdad para los
operadores && y ||.
 En la evaluación de las expresiones
que contienen && y ||, el proceso de
la evaluación termina tan pronto se
conoce el valor de la expresión
•05/06/2011 •31

Conceptos Básicos
relacionales, etc.)
 Ejemplo:
while (a < b && c > 0)
/* hacer algo */
 Reglas de precedencia (MA).
a < b && c < d
equivale a
(a < b) && (c < d)

•05/06/2011 •32

Operador de asignación ampliada:
La operación:
c = c + 3
puede escribirse de forma abreviada
utilizando el operador de asignación ampliada,
como:
c += 3

•05/06/2011 •33


En general, cualquier enunciado de la forma

variable = variable operador (expresion)

puede escribirse de la forma:

variable operador = expresion

•05/06/2011 •34

Conceptos Básicos
relacionales, etc.)
Operador de asignación ampliada:
k *= 3 + x
Es equivalente a:
k = k * (3 + x)
y no a:
k = k * 3 + x

•05/06/2011 •35

 Ejemplo: en qué orden se calcula la
siguiente expresión:

a * b + c/d – e

1. a*b -> x
2. c/d -> y
3. x + y -> z
4. z-e

Precedencia de Operadores
•05/06/2011 •36

Estructuras de Control

•05/06/2011 •37

 La estructura de selección if

Ejecuta la acción indicada sólo
cuando la condición es verdadera,
de lo contrario la acción es
pasada por alto.
if (nota >= 10) {
printf (“Aprobo el curso”);
aprobados++;
}

(Condicionales)

(Condicionales)

if (Condición)
Acción;

o en caso de un cuerpo compuesto

if(Condición)
{
Acción1;
Acción2;
...
}

 La estructura de selección if/else
permite que el programador
especifique acciones distintas cuando
la condición es verdadera o falsa.
if (nota >= 10) {
printf (“Aprobo el curso”);
aprobados++;
} else
reprobados++;

(Condicionales)

#include <stdio.h>
int main()
{ Ejemplo
int N;
printf("Ingrese el valor N: ");
scanf("%d", &N);
if((N % 2) == 1)
printf("El numero %d es IMPARn", N);
else
printf("El numero %d es PARn", N);
return 0;
}

if (nota >= 85)
nota_5 = 5; if (nota >= 85)
else nota_5 = 5;
else if (nota >= 70)
if (nota >= 70) nota_5 = 4:
nota_5 = 4; else if (nota >= 50)
else nota_5 = 3;
else nota_5 = 2;
if (nota >=
50)
nota_5 = 3;
else
nota_5 = 2;
(Condicionales)

 El operador condicional “?” es el único
operador ternario

Expre1 ? Expr2 : Expr3

nota >= 50 ? printf(“aprobado”): printf(“reprobado”)

I operando II operando III operando
Se evalúa Expre1, si es verdadera se evalúa Expre2
y éste es el resultado de la expresión, de lo contrario se
evalúa Expre3
(Condicionales)

La estructura de selección múltiple switch
switch(expresion)
{ Expresión entera
case constante_1: [serie de instr.1]
case constante_2: [serie de instr.2]
.... Expresión const. tipo entero
case constante_n: [serie de instr. n]
default: [serie de instr.]
}
(Condicionales)

(Condicionales)
La instrucción switch
Es una forma de tomar decisiones múltiples de
manera bien estructurada, sólo puede usarse en
ciertos casos:
-Cuando se chequea una sola variable; todas las
posibilidades deben depender del valor de esta variable.
La variable debe ser de tipo entero (int, long, short, char).
-Cada posible valor de la variable puede controlar una única
rama (u opción). Una rama por defecto „default‟ puede
capturar los todos los casos no especificados.

#include <stdio.h>
int main() /* Escribe el día de la semana */{
int dia;
printf("Introduce el día: "); Ejemplo
scanf("%d",&dia);
switch(dia){
Impide que se ejecuten
case 1: printf("Lunes"); break;
case 2: printf("Martes"); break;
el resto de instrucciones
case 3: printf("Miércoles"); break; del switch
case 4: printf("Jueves"); break;
case 5: printf("Viernes"); break;
case 6: printf("Sábado"); break;
case 7: printf("Domingo"); break;
}
}

main() { Entrada del
int n; usuario
printf (“introduzca un entero”);
1
scanf(“%d”, &n);
switch(n) { pequeño
case 0: printf(“nuln”); mediano
break;
case 1: 4
case 2: printf(“pequeño”); mediano
case 3:
case 4: 25
case 5: printf(“mediano”); grande
break;
default: printf(“grande”);
} Salida del programa

 La estructura de repetición WHILE
◦ Permite al programador especificar que se
repita una acción, en tanto cierta condición
se mantenga verdadera.
◦ La instrucción puede ejecutarse cero o más
veces.
while(condición)
Acción;
while(condición){
Acción1;
Acción2;
}

Estructuras de Control (Ciclos)

 La estructura de repetición WHILE
(ejemplo)

product = 2;
while (product <= 1000)
product = 2 * product;


int total, counter, average;
total = 0;
counter = 1; Ejemplo
while (counter <= 10) {
printf(“Introduzca la nota: ”);
scanf(“%d”, &nota);
total = total + nota;
counter += 1;
}
average = total /10;
printf(“El promedio es: %dn”, average);


La estructura de repetición FOR: Maneja
de forma automática los detalles de la
repetición controlada por un contador.
int counter;
for (counter = 1; counter <= 10; counter++)
printf(“%dn”, counter);
int counter = 1;
Son while(counter <= 10){
equivalen printf(“%dn”, counter);
tes ++counter;
}

 La estructura de repetición FOR:

Valor final
de la v. de
Variable de control
control

for (counter = 1; counter <= 10; counter++)

Valor inicial de Incremento de
la variable la v. de control


Ejemplo
int counter,total, average;

for(counter = 1; counter <= 10; counter++) {
}
printf(“class average is %dn”, average);


Ejemplo: ciclo decreciente
int counter,total, average;

for(counter = 10; counter >= 1; counter--) {
}
printf(“class average is %dn”, average);

 La estructura de repetición do-while:

main() {
int counter = 1;
do do {
proposición printf(“%d ”, counter );
while (expresión); } while(++counter <= 10);
return 0;
}

Ejemplo de uso del do-while

#include <stdio.h>
int main() {
int n, error;
do {
printf("Ingrese un número entero entre 1 y 10: ");
scanf("%d", &n);
if (error = (n < 1 || n > 10))
printf("nERROR: Intentelo nuevamente!!nn");
} while(error);/* ahora puedo procesar
el valor ingresado sabiendo que es correcto. */
…
return 0;
} /* fin del main */

(Ciclos)
 break:
◦ Sirve para interrumpir el desarrollo
de un bucle.
◦ En el caso de bucles anidados, break
sale del bucle más interno.

int x;
for (x=1; x <= 10; x++){
if (x == 5) Imprime:
break; 1234
printf(“%dn”, x);
}

(Ciclos)
 continue: Permite pasar
prematuramente a la siguiente
iteración del bucle
int x;
for (x=1; x <= 10; x++){
if (x == 5)
Imprime:
continue;
printf(“%dn”, x); 1 2 3 4 6 7 8 9 10
}

 Un arreglo es un grupo de
posiciones de memoria relacionadas
entre sí: todas tienen el mismo
nombre y son del mismo tipo.
 Declaración:
tipo nombre[num_elementos]

Arreglos

int c [12]; /* Reserva espacio para 12 elementos
del tipo int */

nombre c[0] 4
c[1] 5
c[2] - 15
Posición
o índice
Arreglos
c[11] 78

 Un índice puede tomar la forma de
cualquier expresión aritmética de tipo
entero: t[n-3], t[3*p-2*k]
 La dimensión de un arreglo sólo puede
ser una constante o una expresión
constante
#define N 50
int t[N];
float h[2*N-1];

Arreglos

La declaración de un arreglo se realiza según
la siguiente sintáxis :
tipo_variable nombre[numero_elementos];
ejemplo :
int var1[10]; // arreglo de 10 enteros
char nombre[50]; //se reserva espacio
// para 50 caracteres
float numeros[200]; // 200 floats.
long double cantidades[25];

Arreglos

Arreglos
La inicialización de un arreglo local, puede
realizarse en su declaración:
int numero[8] = {4,7,0,0,0,9,8,7};
Otra posibilidad, que sólo es válida cuando se
inicializan todos los elementos del arreglo, es:
int numero[]={0,1,2,3,4,5,6,7,8,9};
El arreglo contendrá 10 elementos.
También se pueden inicializar parcialmente:
int numero[10] = {1,1,1};

Arreglos
CONJUNTO ORDENADO DE CARACTERES
(STRINGS)
Los strings son arreglos de caracteres que culminan con
el caracter NULL ( ASCII == 0 , simbolizado por la
secuencia de escape 0 ) .
Se puede generar un string , declarando :
char car_str[] = {'A','B','C','D',0};
char car_str[] = {'A','B','C','D','0'};
Hay una forma más compacta de declararlos :
char car_str[] = "ABCD";
char car_str[5] = "ABCD";

Arreglos
 C no posee facilidades para el manejo de
“strings”, de modo que las siguientes
instrucciones son ilegales:

char firstname[50],lastname[50];
firstname = "Arnold"; /* Ilegal */
lastname = "Schwarznegger"; /* Ilegal */
char firstname[] = “Arnold”; /* Ok */

 Para imprimir un string se usa printf con el
carácter de control %s :
printf(``%s'',name);

Arreglos
char firstname[50],lastname[50];
char tempname[50];

strcpy(tempname, firstname);

Otras funciones de la librería standard de
C para el manejo de strings (string.h)
son:

strlen(), strcmp(), strcat(), etc.

int main()
{
int square[100];
int i; /* índice del ciclo*/;
int k; /* El entero a elevar al cuadrado*/

/* Calcular los cuadrados */
for (i = 0; i < 100; i++) {
k = i + 1; /* i va de 0 a 99 */
/* k va de 1 a 100 */
square[i] = k*k;
printf(“El cuadrado de %d es %dn",k,square[i]);
}

return 0;
}

int main()
{ Arreglos de caracteres
char nombre[15], apellidos[30];
int edad;

printf("Introduce tu nombre: ");
scanf("%s",nombre);
printf("Introduce tus apellidos: ");
scanf("%s",apellidos);
printf("Introduce tu edad: ");
scanf("%d", &edad);
printf("Usted es %s %sn",nombre,apellidos);
}

 Los arreglos pueden tener más de una
dimensión, por ejemplo :
int matriz[num_fil][num_col];
 En C, un arreglo de dos dimensiones es
en realidad un arreglo unidimensional,
cada uno de cuyos elementos es un
arreglo.
 Los elementos se almacenan por filas.

Arreglos Multidimensionales

Inicialización:
char dia_de_la_semana[7][8] = {
"lunes","martes","miercoles" ,
"jueves","viernes","sábado",
"domingo"
};
El elemento [0][0] será la "l" de lunes , el
[2][3] la "r" de miercoles , etc. Los
elementos [0][5] , [1][6] ,etc estan
inicializados con NULL; y [0][6] y [0][7],
etc no han sido inicializados.

Arreglos Multidimensionales

int main() {
int array[2][3], i,j;

for (i = 0; i <= 1; i++)
int main() {
for (j=0; j <= 2; j++)
a[i][j] = i + j; int array[2][3], i,j;

for (i = 0; i <= 1; i++)
for (j=0; j <= 2; j++) {
Ejemplos printf(“%d”, a[i][j]);
printf(“n”);
}
}

Nuevos tipos de Datos

•05/06/2011 •74

 C proporciona un facilidad llamada
typedef para crear nuevos tipos de
datos.
Tipo base Nuevo nombre tipo

typedef int Longitud;
Longitud len, maxlen;
typedef int vector[3];
int a[3],b[3];
vector a, b; Son equivalentes

Definición de Nuevos Tipos

Tipos de Datos Derivados
(Estructuras)
 Existe en C un tipo de variable compuesta,
llamada ESTRUCTURA que puede contener
variables de distinto tipo. Ejemplo :

struct empleado {
int edad;
char nombre[50];
float sueldo;
};
struct empleado vendedores, oficinistas;

(Estructuras)
 Las dos instrucciones pueden combinarse en
una sola:
struct empleado {
int edad;
char nombre[50];
float sueldo;
} vendedor , programador;

 Si no fueran a realizarse más declaraciones
de variables de éste tipo, podría obviarse el
nombre de la estructura (empleado).

REGLAS PARA EL USO DE ESTRUCTURAS
 Para dirigirnos a un miembro particular de
una estructura existe un operador que
relaciona al nombre de ella con el de cada
miembro; es el operador ( . ).

nombre_estructura.nombre_del_miembro

(Estructuras)

struct posicion_de {
float eje_x;
float eje_y;
float eje_z;
}fin_recta,inicio_recta = {1.0,2.0,3.0};
fin_recta.eje_x = 10.0;
fin_recta.eje_y = 50.0;
fin_recta.eje_z = 90.0;
if(fin_recta.eje_x == inicio_recta.eje_x)

(Estructuras)

(Estructuras)
Dos estructuras del mismo tipo pueden ser
asignadas o comparadas en forma directa.
fin_recta = inicio_recta;
o también,
fin_recta.eje_x = inicio_recta.eje_x;
fin_recta.eje_y = inicio_recta.eje_y;
fin_recta.eje_z = inicio_recta.eje_z;

(Estructuras)

 Las estructuras pueden anidarse.
 Las estructuras también pueden ser
pasadas a las funciones como
parámetros, y ser retornadas por
éstas, como resultado.

(Estructuras)
Las estructuras se pueden agrupar de forma
ordenada como elementos de un arreglo.
typedef struct {
char material[50];
int existencia;
double costo_unitario;
}item;
item almacen[100];
almacen[50].existencia =1000;
costo_tornillo = almacen[0].costo_unitario;

(Estructuras)
Los arreglos de estructuras pueden inicializarse
de la forma habitual:
item almacen2[] = {
item almacen1[100] ={
{ 'i','t','e','m','1','0' } ,10,1.5,
"tornillos" , 120 , .15 ,
"tuercas" , 200 , .09 , { 'i','t','e','m','2','0' },20,1.0,
”clavos" , 90 , .01 { 'i','t','e','m','3','0' },60,2.5,
}; { 'i','t','e','m','4','0' },40,4.6,
{ 'i','t','e','m','5','0' },10,1.2 ,
};

 Se puede aplicar el operador sizeof, de la
siguiente forma:

tam_base_datos = sizeof(almacen1);
tam_de_item = sizeof(item) ;
num_datos = sizeof(almacen1)/sizeof(item);

(Estructuras)

#define NUM_INTER 100
struct Intervalo {
double Lower, /* Límite inferior del intervalo */
Upper; /* Límite superior del intervalo */
int Counter; /* Cantidad de puntos dentro */
};
int main() { Ejemplo.
struct Intervalo Inter[NUM_INTER];
int i, j;
double Delta = RAND_MAX/NUM_INTER;
/* Inicialización del vector de estructuras */
for (i=0; i<NUM_INTER; i ++) {
Inter[i].Counter = 0;
Inter[i].Lower = Delta*i;
Inter[i].Upper = Delta*(i+1);
}}

(Uniones)
 Una “union” es una variable que puede
almacenar (en momentos diferentes) objetos
de diferentes tamaños y tipos.
 Para este tipo de variables se usa la instrucción
union:
union numero {
short tiposhort;
long tipolong;
double tipofloat;
} minumero
printf("%f",minumero.tipofloat);

struct {
char *name;
int flags;
int utype; if (symtab[i].utype == INT)
union { printf(“%dn”,
int ival; symtab[i].u.ival);)
float fval;
char *sval;
}u;
} symtab[NSYM];

(Uniones)

typedef struct {
typedef union {
int carnet;
profesor prof_id;
}estudiante;
estudiante est_id;
typedef struct {
prof_invitado pin_id;
int cedula;
} tipo_id;
} profesor;
typedef struct { typedef struct {
char pasaporte[30]; int clase_personal;
} prof_invitado; int edad;
tipo_id identif;
personal p; } personal;
if (p.clase_personal == 3)
printf(“%s” , p.identif.pin_id.pasaporte);

Casting
C es uno de los pocos lenguajes que permite
forzar una variable de uno tipo para que sea
de otro tipo (coercion). Esto se logra a través del
operador cast ( ).
int num_entero;
float num_real=9.87;
num_entero=(int)num_real; /* asigna 9
a num_entero */
int num_entero=10;
float floatnumber;
floatnumber=(float)num_entero; /*floatnumber =
10.0. */

Casting
• Puede usarse con cualquiera de los tipos de
datos simples:
int num_entero;
char letra='A';
num_entero=(int)letra; /* asigna 65 (El código
ASCII de `A') a num_entero*/

• Algunas veces se realiza en forma automática.
• Una buena regla es: si tiene duda, coloque el
cast.

Casting
Otro uso del cast es cuando se quiere estar seguro de
que la división retorna el resultado que se desea:

int num_entero, otro_entero;

....

num_real =
(float) num_entero/(float) otro_entero;

/* Asegura que el resultado es real */

Los tipos de datos enumerados
contienen una lista de constantes que
pueden ser direccionadas como
valores enteros.

enum dias {lunes, martes, ...,
domingo} semana;
enum dias semana1, semana2;

Tipos de datos enumerados

 Se pueden definir otros valores:
enum escapes { bell = `a',backspace = `b',
tab = `t', newline = `n', vtab = `v',
return = `r'};
 ... O forzar que el valor inicial no sea el 0 :
enum meses {ene = 1, feb, mar, ..., dic};

Está implícito que feb = 2 etc.


Ejemplo:

enum day {dom, lun, mar, mier, jue, vier, sab}
d1, d2;

d1 = vier;
....
if (d1 == d2) ....


 Brian Kernighan y Dennis Ritchie. El
Lenguaje de Programación C. Prentice
Hall.
 http://www.its.strath.ac.uk/cources/c

Bibliografía
•05/06/2011 •95

Clase1 c

Recomendados

Recomendados

Mais conteúdo relacionado

Mais procurados

Mais procurados (20)

Destaque

Destaque (13)

Semelhante a Clase1 c

Semelhante a Clase1 c (20)

Último

Último (20)

Clase1 c