Make your own free website on Tripod.com
UNIVERSIDAD DE OCCIDENTE

COMPUTACION VIII


UNIDAD II.- ELEMENTOS DE LENGUAJE "C"



2.1.- Variables 2.2.- Tipos y tamaños de datos 2.3.- Constantes 2.4.- Tipos de operadores 2.5.- Arreglos 2.6.- Variables string 2.7.- Palabras reservadadas


UNIDAD II.- ELEMENTOS DEL LENGUAJE C


2.1. VARIABLES

Las variables se almacenan en la memoria y cuando estas reciben un valor que se guarda en memoria, en el espacio que se le ha asignado. En C se deben declarar las variables antes de usarse, por lo que el compilador debe saber que tipo de dato va en cada una antes compilar otras instrucciones relacionadas con la variable. El nombre de la variable puede ser alfanumérico, se pueden usar mayúsculas o minúsculas, también pueden llevar el guión de subrayar ( _ ). Se recomienda inicializar las variables. Ej: int total_dias; char respuesta = "S"; float promedio;

REGRESAR AL PRINCIPIO DEL TEMA
REGRESAR

2.2. TIPOS Y TAMAÑOS DE DATOS

El tipo de dato es un conjunto de valores que representa una variable en memoria. Los tipo de datos : char (caracter) int (entero) float (real de simple precisión) double (real de doble precisión) void (valor nulo) Los tipos de dato CHAR son caracteres no numéricos. Ej. /**************** Uso de char ****************/ #include int main() { char op=´z´; printf("La opcion es:%c",op); getch(); return 0; } Los tipos de datos ENTERO que no contienen punto decimal puede ser positivo o negativo int 2 bytes -32,768 al 32,767 short 2 bytes -128 al 128 long 4 bytes -2,147,483,648 al 2,147,483,648 Ej. /*************** Uso de enteros ***************/ #include int main() { int x; x=456; printf("El valor de x es :%d\n",x); getch(); return 0; } Los tipos de dato FLOAT se usan cuando en el programa requiere componentes fraccionales o cuando la aplicación requiere números extremadamente largos o muy pequeños. +38 - 38 float 4 bytes 3.4 x 10 3.4 x 10 +308 - 308 double 8 bytes 1.7 x 10 1.7 x 10 +4932 - 4932 long 8 bytes 3.4 x 10 3.4 x 10 Ej. /************** Uso de float **************/ #include int main() { float promedio; float ps1,ps2; printf("\nPrimer peso:"); scanf("%f",&ps1); printf("\nSegundo peso"); scanf("%f",&ps2); promedio=(ps1+ps2)/2; printf("\nEl peso promedio es:%f",promedio); getch(); return 0; }


REGRESAR AL PRINCIPIO DEL TEMA
REGRESAR

2.3. CONSTANTES

Son identificadores que no pueden cambiar durante la ejecución del programa existen 4 tipos de constantes: - Literales - Definidas - Declaradas - Enumeradas Las constantes se parecen al identificador # define, pero las constantes son más fáciles de usar en el proceso de depuración, El que aún se use # define, es porque C original no contemplaba las constantes. CONSTANTES LITERALES Son los tipos de datos ya predefinidas. Ej. - int - float - char - double Para declarar una constante se utiliza la palabra reservada CONST, seguida por el identificador. Ej. const int edad=21; const char op=´S´; const float pi=3.1415927; CONSTANTES DEFINIDAS #DEFINE le indica al compilador que el indicador que le sigue tendrá el valor que tendrá durante toda la ejecución del programa. Ej. #define PI 3.1415927 #define X 10 CONSTANTES DECLARADAS Permite dar nombres simbólicos a constantes al modo de otros lenguajes, como Pascal. Ej. const int meses = 12; const char cadena[15] = "curso de C"; const float x = 10.55; CONSTANTES ENUMERADAS Es un conjunto de constantes enteras que especifica los valores que una variable de cierto tipo debe tener, cuando se procesa, el compilador asigna un valor iniciando en cero a cada elemento e incrementando en uno la asignación de los valores. Ej. enum dias {lunes,martes,miercoles,jueves, viernes, sábado, domingo}; Para inicializarlos: enum dias {lunes=10,martes=20,miercoles,jueves, viernes, sábado, domingo}; Incrementado: lunes=10; martes=20; miercoles=21; jueves=22; viernes=23; sábado=24; domingo=25;

REGRESAR AL PRINCIPIO DEL TEMA
REGRESAR

2.4.TIPOS DE OPERADORES

OPERADORES Son simbolos que le indican al compilador que llevará a cabo manipulaciones específicas matemáticas o lógicas que causan que las variables modifiquen su valor durante la ejecución del programa. TIPOS DE OPERADORES: - Asiganación - Aritméticos - Lógicos - Relacionales - Unitarios ASIGNACIÓN El operador de asignación en C es un solo signo igual, C permite utilizar el operador de asignación en expresiones que contengan operadores relacionales o lógicos. Ej. x = y; if( (producto = x * y ) > 0 ) printf ( ); else printf ( ); ARITMÉTICOS Permiten ejecutar operaciones matemáticas básicas. Ej. ( + ) suma ( - ) resta ( * ) multiplicación ( / ) división ( % ) módulo(residuo de la división) Los operadores deben representar valores numéricos. Se requiere que en la división,el segundo operando, no sea cero. En el uso del porciento se requiere de operandos enteros. Ej. área = pi * radio * radio; valor = 99 - x; LÓGICOS Los operandos lógicos en C son NOT(!), AND(&&), OR(||). El operador lógico ! (not, no) proporcina el valor de falso, o verdadero. El operador lógico && (and, y) proporciona e l valor de verdadero sólo si ambos operadores son verdaderos. El operador lógico || (or, o) produce verdadero si cualquier a de los operadores es verdadero, y produce falso sólo si ambos operadores son falsos. AND y OR Trabaja con dos operandos. NOT Trabaja con un sólo operando. Tabla de verdad: AND OR NOT 0 0 = 0 0 0 = 0 0 = 1 0 1 = 0 0 1 = 1 1 = 0 1 0 = 0 1 0 = 1 1 1 = 1 1 1 = 1 NOTA: 1 es igual verdad, 0 es igual a falso. Ej. /************************ Uso de operadores lógicos ************************/ #include int main() { int a,b; a=1; b=2; printf("Valores iniciales"); printf("\n a = %d, b=%d"a,b); printf("\n Prueba"); printf("\n a == 1 es %d",a==1); printf("\n b != 1 es %d", b!=1); getch(); return 0; } RELACIONALES Compara dos valores, si la comparación es correcta de acuerdo con el operador, la expresión se considera verdadera, en caso contrario, es falsa. La expresión resultante, representa a un valor de tipo entero. True(verdadero) = 1 False(falso) = 0 Operador : Mayor que == Igual a (Comparación) != No igual a <= Menor o igual que>= Mayor o igual que Ej. /***************************** Uso de operadores relacionales *****************************/ #include int main() { int x; x=9; printf("\n X es :%d",x); printf("\n X <5 es :%d",x<5); printf("\n X> 4 es :%d",x>4); printf("\n X == 9 es :%d",x==9); printf("\n X != 5 es :%d",x!=5); printf("\n X != 8 es :%d",x!=8); printf("\n X <= 7 es :%d",x<="7);" printf("\n X>= 6 es :%d",x>=6); getch(); return 0; } UNITARIOS Incrementa o decrementa en uno la variable. ++ Incrementa -- Decrementa Equivale a: int i; i = 5; i = i+1; i = i-1; Si el operador precede al operando (++i), el valor del operando se modificara antes de usarse, en la instrucción (prefijo). Si el operando precede al operador (i++), el valor de la variable cambiará después de usar la variable (sufijo). Ej. /***************** Uso del decremento Uso del incremento *****************/ #include int main() { int x; x=10; printf("\n x = %d",x); printf("\n x = %d",--x); printf("\n x = %d",x); printf("\n x = %d",x--); printf("\n x = %d",x); printf("\n x = %d",x++); printf("\n x = %d",x); printf("\n x = %d",++x); getch(); return 0; }

REGRESAR AL 2.4
REGRESAR

2.5. ARREGLOS

Lista de variables de un tipo relacionado, las variables de un arreglo, tienen un solo nombre común. Cada elemento en el arreglo se accesa con un número entero llamado índice. Se debe especificar el tamaño del arreglo, o cuantos elementos contencrá. Puede tener dos o más dimensiones, se debe especificar el número de dimensiones. Sintaxis: tipo_de_dato variable[#_elementos]; int tabla[4]; Cada elemento está numerado empezando con 0. tabla[0]=1; tabla[1]=2; tabla[2]=3; tabla[3]4; En C no tiene forma de checar que el índice no sobrepase el tamaño del arreglo. Si se pasa, se asignan valores al espacio de memoria de otra variable. Ej. int num[5]={1,2,3,4,5}; ó int num[]={1,24,88,3,7}; Cuando el tamaño del arreglo no esta inicializado, el compilador crea un arreglo con el tamaño adecuado.

ARREGLOS BIDIMENCIONAL

INT DOSDIM[3][5]= { {1,2,3,4,5}, {6,7,8,9,0}, {2,6,9,7,3} }; Donde la primera dimensión son renglones, y la segunda son columnas.
REGRESAR AL 2.5
REGRESAR

2.6. VARIABLES STRING

C no tiene una variable de tipo string, para ello se usan arreglos de caracteres. Un string, es un conjunto de valores de tipo char que termina en un valor nulo (\0). Por ello el arreglo se debe declarar un elemento más grande que el largo de la cadena. sintaxis: char nom[largo_del string]; char nom[]={´p´,´r´,´o´,´g´,´r´,´a´,´m´,´a´}; ó char nom[]="programa"; Ej. /************************* Uso de arreglos Uso de variables string *************************/ #include int main() { int dat[5]={10,9,10,8,10}; char nom[80]; float prom; prom=(dat[0]+dat[1]+dat[2]+dat[3]+dat[4])/5; printf("\n Tecle su nombre: "); scanf("%s",&nom); printf("\n %s Su promedio es: %f", nom,prom); getch(); return 0; }

REGRESAR AL 2.6
REGRESAR

2.7. PALABRAS RESERVADAS

   
    asm	 	    delete	    if		    return		
    do	   	    inline	    short	    typedef		
    duble	    int		    signed	    union		
    long	    sizeof	    unsigned	    catch		
    state	    virtual	    char	    externa			
    void	    class	    float	    private		
    continue	    friend	    public	    this			
    register	    throw	    printf	    scanf	       
    define	    try		    auto	    break	
    main	    case	    else   	    enum		
    new	    	    operator	    struct	    switch
    volatile	    default	    goto	    getch	
    include		    

CONSTANTES ESPECIALES CHAR

´\n´ salto de linea ´\r´ retorno de carro ´\t´ tabulación horizontal ´\v´ tabulación vertical ´\f´ avance de página en la impresión ´\a´ campana ´\\´ backslash(se usa para instrucciones) ´\"´ comillas ´\0´ valor nulo ´\´´ comilla simple ´\?´ interrogación

CÓDIGO DE FORMATO DE SALIDA (PRINTF)

%u entero sin signo %d entero decimal %f número real %o número octal %x número hexadecimal %h número entero corto %l número entero largo %g número real en el campo más pequeño %c un caracter %s una cadena de caracteres %i entero %[^\n] una cadena de caracteres con espacio en blancos

REGRESAR AL 2.7
REGRESAR

IR AL ÍNDICE