UNIVERSIDAD DE OCCIDENTE
COMPUTACION VIII
UNIDAD II.- ELEMENTOS DE LENGUAJE "C"
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