Introducción a “C”Unidad 2

Autor

Isabel Ponce

Unidad 2

Contenido

• Elementos del lenguaje:– Comentarios– Identificadores– Tipos de datos– Modificadores de tipos– Variables

• Clasificación de variables• Modificadores de acceso• Modificadores de almacenamiento• Inicialización

– Constantes– Operadores– Expresiones– Conversión de tipos

Elementos del Lenguaje

• Aunque el lenguaje C es un lenguaje pequeño, tiene un conjunto de elementos que permiten crear programas muy potentes.

• Como la mayoría de los lenguajes imperativos, C permite manipular la memoria mediante variables y constantes que tienen sus propios identificadores.

Comentarios

• El lenguaje C maneja dos tipos de comentarios:

<comentario_de_una_línea> ::= // <comentario>

<comentario_de_una_o_varias_líneas> ::=/* <línea_de_comentario> [<línea_de_comentario>*] */

• Ejemplo:/* ********* Programa: Prueba.C* Autor: Pedro Picapiedra* Objetivo: Mostrar el uso de comentarios* Fecha: 01/01/01******** */

x = x + 1; //incrementa x en 1

Literales

• Las literales permitidas son:– Enteras– Reales– De carácter– De cadena– Nulos

• Ejemplo#include <stdio.h>#include <conio.h>

#define ENTERO 1234#define LARGO 123456l#define CORTO 10#define SIN_SIGNO 1234u#define HEXA 0x123a#define OCTAL 01234

#define REAL 12345678.5f#define DOBLE 123456789012345.5#define DOBLE_LARGO 12345678901234567890.5

Literales

#define CARACTER 'M'#define SALTO '\n'#define CADENA "Hola Mundo "#define NULO NULLvoid main () {

clrscr(); //clear screen (limpiar pantalla)printf(" Entero decimal: %d", ENTERO);printf("\n Entero largo: %ld", LARGO);printf("\n Entero corto: %d", CORTO);printf("\nEntero sin signo: %u", SIN_SIGNO);printf("\n Hexadecimal: %X", HEXA);printf("\n Octal: %o", OCTAL);printf("\n Flotante: %f", REAL);printf("\nFlotante formato: %5.1f", REAL);printf("\n Doble: %lf", DOBLE);printf("\n Doble largo: %e", DOBLE_LARGO);printf("\n Caracter: %c", CARACTER);printf("\n Cadena: %s", CADENA);printf("\n Nulo: %s", NULO);printf("%c%c%c%c Cadena: %s", SALTO, SALTO, SALTO, SALTO, CADENA);getch();

}

Identificadores

• Las reglas para nombrar a los identificadores son:

– La longitud puede variar (1-31)– El primer caracter debe ser

alfabético o subrayado.– Los siguientes pueden ser

alfabéticos, dígitos o subrayado.– Son sensibles a minúsculas y

mayúsculas.– Deben ser únicos.– No pueden ser palabras

reservadas.– No se permiten caracteres

especiales como espacios, acentos o guiones.

Palabras reservadas

• Las palabras reservadas del lenguaje son:

auto double int struct

break else long switch

case enum register typedef

char extern return union

const float short unsigned

continue for signed void

default goto sizeof volatil

do if static while

Tipos de datos

• Existen 5 tipos de datos básicos: char, int, float, double y void.

• El tamaño y rango de los tipos varía en cada procesador y compilador.

• No existe el tipo lógico.Tipo Tamaño Rangochar 8 -128 a 127unsigned char 8 0 a 255signed char 8 -128 a 127int 16 -32768 a 32767unsigned int 16 0 a 65535signed int 16 = intshort int 16 = intunsigned short int 16 = intsigned short int 16 = short intlong int 32 +-2147483647signed long int 32 +-2147483647unsigned long int 32 0 a 4294967295float 32 6 dígitos precisióndouble 64 10 dígitos precisiónlong double 80 10 dígitos precisión

Modificadores de Tipos

• Los modificadores pueden alterar el significado de los tipos.

• En algunos casos poner un modificador puede ser redundante.

• Algunos compiladores permiten unsigned float.

• Los modificadores son:

Modificadores Tipo

signed, unsigned char, int

short int

long int, double

Constantes

• Aunque puede emplearse el modificador const para las variables, es más común emplear directivas del preprocesador para declarar constantes:

#define <identificador> <literal>

• Nótese que las directivas del preprocesador no requieren punto y coma al final.

• Tampoco se usa el operador = para asignar el valor de la constante.

#define UNO 1

#define MS_E “Error de entrada”

#define MAXIMO 100

#define VERDADERO 1

Variables

• La sintaxis general para declarar una variable es:

<tipo> <identificador>* [= <valorInicial>];

• El tipo puede ser alguno de los tipos elementales o alguno definido por el usuario.

• Ejemplos:

int i, j, k;

short int eCorto;

unsigned int eSinSigno;

double balance, beneficio, perdida;

Inicialización de Variables

• Para asignar un valor inicial a una variable al momento de declararla, basta con colocar el operador de asignación = después del nombre de la variable y el valor literal deseado.

• Ejemplo:

char cCaracter = ‘a’;

int ePrimero = 0;

float fBalance = 123.23f;

Variables

#include <stdio.h>

#include <conio.h>

void main() {

char caracter = 'm';

signed char caracterConSigno = 'e';

unsigned char caracterSinSigno = 'd';

char* cadena ="Hola Mundo";

int entero = 32123;

signed int enteroConSigno = 32123;

unsigned int enteroSinSigno = 65123;

short int enteroCorto = 32123;

signed short int enteroCortoConSigno = 32123;

unsigned short int enteroCortoSinSigno = 32123;

long int enteroLargo = 1234567890;

signed long int enteroLargoConSigno = 1234567890;

unsigned long int enteroLargoSinSigno = 4234567890;

int octal = 0123456;

int hexadecimal = 0x123A;

float real = 1234567.1f;

double doble = 1234567890123456.1;

long double dobleLargo = 12345678901234567890.1;

Variables

clrscr();

printf("\n Caracter: %c", caracter);

printf("\n Caracter Con Signo: %c", caracterConSigno);

printf("\n Caracter Sin Signo: %c", caracterSinSigno);

printf("\n Cadena: %s", cadena);

printf("\n\n Entero: %d", entero);

printf("\n Entero con signo: %d", enteroConSigno);

printf("\n Entero sin signo: %u", enteroSinSigno);

printf("\n\n Entero corto: %d", enteroCorto);

printf("\nEntero corto c/signo: %d", enteroCortoConSigno);

printf("\nEntero corto s/ signo: %d", enteroCortoSinSigno);

printf("\n\n Entero largo: %ld", enteroLargo);

printf("\nEntero largo c/signo:%ld",enteroLargoConSigno);

printf("\nEntero largo s/signo: %lu", enteroLargoSinSigno);

printf("\n\n Octal: %o", octal);

printf("\n Hexadecimal: %X", hexadecimal);

printf("\n\n Real: %f", real);

printf("\n Doble: %lf", doble);

printf("\n Doble largo: %.20LG\n\n", dobleLargo);

getch();

} //main

Clasificación de variables

• Las variables pueden clasificarse dependiendo de su alcance o el lugar donde se declaran en:

– Globales– Locales– Parámetros de funciones (los

parámetros se verán más adelante)

Variables Globales

• Las variables globales se declaran en cualquier lugar fuera de las funciones.

• Se conocen a lo largo de todo el programa, por lo que se pueden usar en cualquier lugar.

• Mantienen su valor durante toda la ejecución del programa.

#include <stdio.h> #include <conio.h>int cuenta;

void func1(); //prototipos devoid func2(); //funciones

void main(){cuenta = 100;func1();getch();

}

Variables globales

void func1(){

int temp;

temp = cuenta;

func2();

printf(“cuenta = %d”, cuenta);

//imprime 100

}

void func2(){

int cuenta;

for (cuenta = 1; cuenta < 10;

cuenta++) {

putchar(‘*’);

}

}

Variables locales

• Las variables locales se declaran dentro de las funciones.

• También pueden llamarse automáticas ya que pueden usar el modificador auto.

• Sólo pueden emplearse dentro del bloque donde se declaran.

• Un bloque empieza con una llave abierta { y terminan al cerrar la llave }.

• Se declaran antes de cualquier sentencia del bloque.

• Se crean al iniciar la ejecución del bloque y se destruye al salir de él.void func1() {

int x;

x = 10;

}

Modificadores de acceso

• Existen dos modificadores de acceso a las variables:

• El modificador const evita que el valor de una variable pueda modificarse.

const int a = 10;

• El modificador volatil define que el valor de una variable puede modificarse por medios externos al programa, por ejemplo, si se asume que Ox30 es el valor de un puerto que cambia por una condición externa exclusivamente, se puede indicar:

volatil unsigned char *puerto = Ox30;

Modificadores de almacenamiento

• Los modificadores de almace-namiento permiten especificar cómo almacenar las variables.

• Debe preceder al resto de la declaración.

• Los modificadores de almacenamiento son:

extern

static

register

auto

• El modificar auto define variables locales.

Modificador extern

• El modificador extern permite especificar variables globales declaradas en programas compilados separadamente.

Archivo 1

int x, y;

void main(){

...

}

Archivo 2

extern int x, y;

func22() {

x = y / 10;

}

Modificador static

• El modificador static permite especificar variables perma-nentes.

• Una variable estática local es una variable local que retiene su valor entre llamadas de funciones. Por ejemplo una variable que genera una serie de números basadas en el valor anterior.

int serie(){

static int eNum = 100;

eNum = eNum + 1;

return eNum;

}

Variable estática global

• Una variable estática global es una variable conocida únicamente en el archivo en el que se declara. Otros archivos no la pueden alterar, está libre de efectos secundarios

static int eNum;void iniciarSerie(int eSemilla);void serie();

int serie(){eNum = eNum + 1;return eNum;

}void iniciarSerie(int eSemilla) {

eNum = eSemilla;}

Modificador register

• El modificador register permite especificar una variable que se almacena en los registros de CPU en vez de la memoria, lo que hace que su acceso sea más rápido.

• Este modificador sólo se puede usar en variables locales.

• Al no estar guardada en memoria, esta variable no tiene dirección.

• Son muy usadas para el control de ciclos.

potencia () {

register int temp;

...

}

Modificadores

• En resumen tenemos tres tipos de modificadores:– De tipo

• signed• unsigned• short• long

– De acceso

• const• volatil

– De almacenamiento

• extern• static• register• auto

Operadores

• El lenguaje C es rico en operadores.

• Los tipos de operadores en C son:

– Aritméticos– Lógicos– Relacionales– De asignación– Asociativos– A nivel de bits– Otros operadores

Operadores Aritméticos

• Los operadores +, -, * y / funcionan en C igual que en la mayoría de los lenguajes de programación.

• Al aplicar / sobre enteros, se trunca el resultado.

• El operador % obtiene el residuo de la división.

• El menos monario (-) multiplica su único operando por -1.

• El operador de autoincremento (++) adiciona 1 a su operando.

• El operador de autodecremento (--) disminuye 1 a su operando.

• Ambos se pueden usar antes o después del operando.

Operadores Lógicos

• Los operadores lógicos son:

&& - and

|| - or

! - not

• No existe el operador XOR

Operadores Relacionales

• Los operadores relacionales son:

> - mayor

>= - mayor o igual

< - menor

<= - menor o igual

== - igual

!= - diferente

Operadores de Asignación

• Los operadores de asignación son:

= el resultado de la expresión derecha se lo asigna a la

variable de la izquierda.+= suma y asigna-= resta y asigna*= multiplica y asigna/= divide y asigna%= obtiene residuo y asigna

• Es posible hacer asignaciones múltiples:x = y = z = 0;

Operadores de Asociación

• Los paréntesis ( ) aumentan la precedencia de los operadores.

x = (a + b) * c;

• Los corchetes [ ] permiten indexar arreglos.

arreglo[3] = 5;

• Las llaves { } engloban un bloque de código.

if (a< b) {

….

}

Operadores a Nivel de Bits

• Ya que C se diseñó para sustituir a ensamblador debe permitir hacer las operaciones que éste realiza.

• Las operaciones a nivel de bits se refieren a la comprobación, asignación o desplazamiento de los bits que componen un byte.

Operador Acción

& AND

| OR

^ XOR

~ NOT

<< Desplazamiento izquierda

>> Desplazamiento derecha

Otros Operadores

• C tiene otros operadores muy específicos del lenguaje:

? (ternario)

<Exp1> ? <Exp2> : <Exp3>

x = 10;

y = x > 9 ? 100 : 200;

, (coma) encadena expresiones

x = (y = 3, y + 1);

& * de apuntadores

sizeof de tiempo de compilación

. -> de registros y uniones

Expresiones

• Las expresiones pueden incluir cualquier combinación de operadores.

• El orden de ejecución dependen de la precedencia de los operadores y generalmente los operadores de la misma precedencia se evalúan de izquierda a derecha.

• El tipo de dato del resultado depende de los tipos de datos de las expresiones de la derecha.

Precedencia de operadores

Mayor () [] ->! ~ ++ -- * - & sizeof* / %+ -<< >>< <= > =>== !=&^|&&||?= += -= *= /=

Menor ,

Conversión de tipos

• Cuando una expresión mezcla distintos tipos, se convierten a un solo tipo.

• C realiza promoción de tipos, donde todos los operandos se convierten al tipo del operando mayor.

• Se puede forzar la conversión a un tipo usando moldes (casting)

• Esto normalmente se hace para convertir tipos mayores a menores.

(< tipo>) <expresión>

Funciones de Entrada

• En el lenguaje C, todas las operaciones de E/S se realizan mediante funciones descritas en su biblioteca.

• Las funciones de entrada por teclado más comunes son:

– getch()– getche()– getchar()– gets()– scanf()

getchar()

• getchar() es la función más sencilla de entrada que lee un caracter del teclado.

• Esta función espera hasta que se pulsa una tecla y devuelve su valor.

• Prototipos: int getchar(void);

#include <stdio.h>#include <ctype.h>

void main(){

char caracter;

printf("Introducir texto (. = Terminar)\n");

do {

caracter = getchar();putchar(caracter);

} while (caracter != '.');

}

getchar()

• Algunas funciones alternativas a getchar() más comunes son:

• getch() espera un valor del teclado, lo devuelve pero no lo muestra.

• getche() espera un valor del teclado, lo devuelve y lo muestra.

• Prototipos:

int getch(void);

int getche(void);

gets()

• Esta función lee una cadena de teclado y la almacena en la dirección apuntada por el argumento de tipo apuntador a un arreglo de caracteres.

• Los caracteres se almacenan hasta ingresar <Enter>.

• Prototipo: char *gets(char *cad);

#include <stdio.h>

#include <string.h>

void main(){

char cadena[80];

printf(“Introduzca una cadena:”);

gets(cadena);

printf(“La longitud de la cadena es %d”,

strlen(cadena));

}

scanf()

• scanf es una función de entrada de propósito general. Puede leer todos los tipos de datos.

• Es prácticamente la función inversa de la función printf().

• Prototipo:int scanf(“cadena de control”, &var);

• La cadena de control determina cómo se leen los valores de las variables.

#include <stdio.h>#include <string.h>

void main(){int numero;printf(“Introduzca un número:”);scanf(“%d”, &numero);printf(“El número es %d”, numero);

}

Ejercicios

1. Crear un programa que declare dos variables enteras y realice las cuatro operaciones aritméticas con ellas.

2. Escribir un programa que muestre si el resultado de la suma de dos variables es mayor, menor o igual a 0.

3. Crear un programa que asigne a una variable el resultado de la siguiente expresión y lo muestre:

35 + 12 / 3 * 37 – 18 / 6

4. Escribir un programa que lea el valor de 2 variables reales y asigne el resultado de su división a una variable entera.

5. Definir un programa que declare las constantes falso y verdadero y muestre sus valores.

Ejercicios

6. Escribir un programa que genere y muestre el siguiente número de una serie que inicia en 350.

7. Crear dos archivos separados y probar el manejo del modificador extern.

8. Definir un programa que declare una variable entera con valor inicial 3, le agregue uno, lo muestre, le reste 3 y lo muestre nuevamente (usar los operadores ++ y -=).