Programación 1: tipos básicos de datos en C

Programación 3
Tipos básicos de datos en C
Angel Vázquez-Patiño
angel.vazquezp@ucuenca.edu.ec
Departamento de Ciencias de la Computación
Universidad de Cuenca
17 de abril de 2017

17/04/17 Angel Vázquez-Patiño 2/52
Objetivos
1. Conocer los tipos básicos de datos en C
2. Conocer cómo se manejan constantes en C
3. Conocer los principales operadores en C
4. Usar funciones/librerías predefinidas de C

Contenido
Tipos básicos de datos
Manejo de constantes
Operadores unarios
Prefix y postfix
Datos lógicos
Caracteres
Librería <math.h>
Otras funciones

Statically-typed
● Todas las variables deben primero ser
declaradas antes de ser usadas. Se debe
especificar el tipo de la variable y el nombre:
int miVariable = 1;
● El tipo de dato de una variable determina el
valor que esta puede contener, además indica
las operaciones que se pueden hacer con/en
esta
¿Cómo se debe nombrar una variable?

Gustedt,2017

Eficiencia
● Los datos enteros ocupan menos memoria que
los datos reales
● Las operaciones entre datos enteros suelen ser
mucho más rápidas (¿Y con los CPUs
actuales?)

Constante
● Variable que mantiene un valor inmutable a lo
largo de toda la vida del programa
Definición
#define NOMBRE valor
#define PI 3.14
#define TAMANIO 100
#define CARACTER 'u'

//Inclusión de cabeceras
#include <stdio.h>
//Definición de constantes. No se termina con ;
#define CONSTANTE1 16
#define CONSTANTE2 20
void main()
{
//Declaración de variables
int variable1=123, variable2=456;
char caracter1='a';
float f;
}

#include <stdio.h>
#define D_SEM 7
#define D_LAB 5
int main()
{
printf("Días de la semana: %dn", D_SEM);
printf("Días laborables: %dn", D_LAB);
return 0;
}

Operadores unarios

Operadores unarios
Definición
● Requieren sólo un operando

Operadores unarios
Operador Descripción
+ operador unario más; indica un valor
positivo (números son positivos sin el
operador)
- operador unario menos; niega una
expresión
++ operador de incremento; incrementa un
valor en 1
-- operador de decremento; decrementa
un valor en 1
! operador lógico de complemento;
invierte un valor booleano

Operadores unarios
#include <stdio.h>
int main()
{
int r = +1;
// r contiene 1
printf("%dn", r);
r--;
// r contiene 0
printf("%dn", r);
r++;
//r contiene 1
printf("%dn", r);
r = -r;
// r contiene -1
printf("%dn", r);
_Bool exitoso = 0;
// falso
printf("%dn", exitoso);
printf(exitoso?"Truen":"Falsen");
// true
printf("%dn", !exitoso);
printf(!exitoso?"True":"False");
}

Operadores unarios
Prefix y postfix
● Los operadores de incremento y decremento
pueden ser aplicados antes (prefix) o después
(postfix) del operando. Ambas versiones tienen
el mismo resultado final; sin embargo, por
ejemplo, ++res es evaluado con el valor
incrementado y res++ con el valor original

Operadores unarios
¡Importante!
Si se usa el incremento o decremento en una
operación simple, no importa la versión usada.
Pero, puede haber una diferencia significativa en
una expresión más larga

Operadores unarios
#include <stdio.h>
int main()
{
int i = 3;
i++;
printf("%dn", i); // 4
++i;
printf("%dn", ++i); // 6
printf("%dn", i++); // 6
}

Precedencia de operadores
Operador Operación Orden de evaluación
op++ op-- posfijos Primero
++op --op
+op -op !
unarios Segundo
* Multiplicación Tercero. Si hay varios
operadores de este tipo,
son evaluados de izq a der
/ División
% Residuo
+ Adición Cuarto. Si hay varios
operadores de este tipo,
son evaluados de izq a der
- Sustracción
< > <= >= Relacional Quinto
= Asignación Evaluado al final

Operadores unarios
1) int x = -3 + 2 * 4 – 12 / 6 + 5 ;
2) int y = -3 + 2 * (14 – 2) / 6 + 5 ;
3) int i = 10; int n = i++ % 5; printf(n); n =
++i % 5; printf(n);
4) X = 7 % 2;
5) X = 8 % 3;
6) int x=5; y=5; int z; z=x++;
7) z=++y;
8) int i = 1; printf(i); printf(++i);
printf(i);
9) i = 1; printf(i); printf(i++); printf(i);

Datos lógicos

Datos lógicos
● True o False
● 1 o 0
Operadores lógicos
● And (&&)
● Or (||)
● Not (!)

Datos lógicos
Declaración, asignación e impresión
_Bool boolVar;
boolVar = 1;
// boolVar: True
printf("boolVar: %dn", boolVar);
// boolVar: False
printf("boolVar: %dn", !boolVar);

Datos lógicos
Operador ternario
_Bool boolVar;
boolVar = 1;
printf(boolVar ? "True":"False");
printf(!boolVar ? "True":"False");

Datos lógicos
Operadores de comparación
● Evaluación de datos
● Devuelve valor lógico
_Bool boolVar;
boolVar = 2<3;
printf("¿2<3?: %dn", boolVar);
printf("¿4=5?: %dn", 4==5);

Datos lógicos
Operador algebraico Operador C Condición C de
ejemplo
Operadores de igualdad
= == x == y
≠ != x != y
Operadores relacionales
> > x > y
< < x < y
≥ >= x >= y
≤ <= x <= y

Datos lógicos
Operador Asociatividad Tipo
* / % Izquierda a derecha Multiplicativo
+ - Izquierda a derecha Aditivo
< <= > >= Izquierda a derecha Relacional
== != Izquierda a derecha Igualdad
= Derecha a izquierda Asignación
Precedencia y asociatividad de los operadores

Datos lógicos
Operador Asociatividad
( )
not Derecha
and Izquierda
xor Izquierda
or Izquierda
Precedencia y asociatividad de los operadores

Datos lógicos
Ejemplo
● not p se evalúa p y después se aplica la
negación
● p and q se evalúa p y después se evalúa p and
q
● not p or q se evalúa (not p) or q ya que el
operador not tiene más prioridad que el
operador or

Datos lógicos
Con a=5, b=e, c=-12
1) a > 3
2) b < c
3) b != c
4) a == 3
5) a * b == -30
6) c/b < a
7) (a+b==8) && (a-b==2)
8) a > 3 && b > 3 && c < 3
1) True
2) False
3) True
4) False
5) False
6) True
7) True
8) False

Caracteres

Caracteres
American Standard Code for Information Interchange
● Un tipo de dato caracter contiene sólo un elemento
como su valor. Elementos establecidos y
normalizados por el estándar llamado ASCII, el cual
establece cuáles son los elementos y el orden de
precedencia entre los mismos. Los elementos son
las letras (mayúsculas y minúsculas), números (0-9)
y símbolos especiales (e.g., !, @, #, $, %)
disponibles en el teclado de la computadora y
algunos otros elementos gráficos. El código ASCII no
es único, pero es el más utilizado internacionalmente

Caracteres
Declaración, asignación e impresión
char ch;
ch = 'a';
printf("Caracter:t %cn", ch);
printf("ASCII:tt %dn", ch);
printf("ASCII + 2:t %dn", ch+2);
printf("Caracter:t %cn", ch+2);

Caracteres
Ejercicio
● Imprimir en pantalla todos los caracteres ASCII

Caracteres
Lectura de un carácter desde teclado
char ch1, ch2;
printf("Caracter 1: ");
scanf("%c", &ch1);
printf("Caracter: %cn", ch1);
printf("Caracter 2: ");
ch2 = getchar();
printf("Caracter: %cn", ch2);

Type casting

Type casting
Type casting
● Una forma de convertir un tipo de dato a otro
Cast operator
(type_name) expression

Type casting
Cast operator
int sum = 17, count = 5;
double mean;
mean = (double) sum / count;
printf("Media: %fn", mean);

Type casting
Promoción entera
● Proceso mediante el cual los valores enteros
“más pequeños” que int o unsigned int son
convertidos a int o unsigned int
int i = 17;
char c = 'c'; // valor ascii: 99
int sum = i + c;
printf("Suma: %dn", sum);

Type casting
Conversiones aritméticas usuales
● Son implícitamente realizadas para convertir
sus valores a un tipo común
● El compilador primero realiza la promoción
entera
● Si los operandos aún tienen diferentes tipos,
son convertidos al tipo que aparece en lo más
alto de la siguiente jerarquía

Type casting
● Las conversiones
aritméticas usuales
no son realizadas por
los operadores de
asignación ni para los
operadores lógicos
&& y ||
long double
double
float
unsigned long long
long long
unsigned long
long
unsigned int
int

Type casting
int i = 17;
char c = 'c'; // valor ascii: 99
float sum = i + c;
printf("Suma: %fn", sum);
● C primero convierte c a int pero como el valor
final es doble, se aplica la conversión aritmética
usual y el compilador convierte i y c en float
y los añade obteniendo un resultado float

Librería <math.h>

Librería <math.h>
● double acos(double x): arco coseno de x
en radianes
● double asin(double x)
● double atan(double x)
● double atan2(double y, double x):
arco tangente en radianes de y/x basado en los
signos de ambos valores para determinar el
cuadrante correcto
● double exp(double x): ex

Librería <math.h>
● double log(double x): logaritmo natural
(base e) de x
● double log10(double x)
● double pow(double x, double y)
● double sqrt(double x)
● double ceil(double x): el valor entero
más pequeño mayor o igual a x
● double fabs(double x): ABS. Para
enteros: int abs(int x), <stdlib.h>

Librería <math.h>
● double floor(double x): el valor más
grande menor o igual a x
● double fmod(double x, double y):
residuo de x/y
● double round(double x)
● float roundf(float x)
● long double roundl(long double x)
● Constante pi: M_PI
● Más: https://goo.gl/eEnRiY

Otras funciones

Otras funciones
Números aleatorios
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
int main()
{
srand(time(NULL));
printf("Aleatorio[0,6]: %dn", rand()%7);
}

Conceptos y términos importantes

Conceptos y términos importantes
● Librerías
● Type casting
● Tipos básicos
● Operadores
● Reglas de precedencia

Referencia
● Gustedt, J., 2017. Modern C. France.
● C Programming Operators,
https://goo.gl/7wHPax
● C - Type Casting, https://goo.gl/VOh2pV
● Más funciones:
http://www.tutorialspoint.com/c_standard_library
/

Preguntas

Programación 1: tipos básicos de datos en C

Programación 1: tipos básicos de datos en C

Más contenido relacionado

La actualidad más candente (20)

Similar a Programación 1: tipos básicos de datos en C (20)

Más de Angel Vázquez Patiño (20)

Último (20)

Programación 1: tipos básicos de datos en C