Iurlek – Igor Urraza

Buenas noches señores y señoras, compañeros y compañeras, niños y niñas… Avanzamos un nuevo pasito y empezamos a conocer los operadores y expresiones tan ricos que nos aporta nuestro amigo, llamémosle C.

Hay cuatro clases principales de operadores: Aritméticos, relacionales, lógicos, y a nivel de bits además de operadores especiales que iremos mostrando en el siguiente código…

/*Operadores Aritméticos: existen 5, y permiten operaciones aritméticas
básicas.
Los datos sobre los que actúan los operadores se denominan operandos.
Algunos operadores requieren 2 operandos (binarios), mientras que otros
actúan sobre 1 (unarios).
*/

int valor1 = 10;
int valor2 = 5;

//Suma : +
printf ( "Resultado = %i\n", valor1 + valor2); //r:15
//Resta : -
printf ( "Resultado = %i\n", valor1 - valor2); //r:5
//Multiplicación : *
printf ( "Resultado = %i\n", valor1 * valor2); //r:50
//División: /
printf ( "Resultado = %d\n", valor1 / valor2); //r:2
//División entera : % (operador módulo)
//Sólo admite operadores enteros. Segundo operando nunca puede ser nulo.
printf ( "Resultado = %d\n", valor1 % valor2); //r:0
//Jugando con decimales
printf ( "Resultado = %f\n", (12.5 / 2.0)); //r:6.25
//Jugando con caracteres
printf ( "Resultado = %i\n", 'p' + 'T'); //r:196

//Jugando con enteros negativos
valor1 = 10;
valor2 = -2;
printf ( "Resultado = %i\n", valor1 + valor2); //r:8
printf ( "Resultado = %i\n", valor1 - valor2); //r:12
printf ( "Resultado = %i\n", valor1 * valor2); //r:-20
printf ( "Resultado = %i\n", valor1 / valor2); //r:-5

//Jugando con operados coma en flotante de diferentes signos
float f_valor1 = -0.90;
float f_valor2 = 6.8;
printf ( "Resultado = %f\n", f_valor1 + f_valor2); //r:5.9
printf ( "Resultado = %f\n", f_valor1 - f_valor2); //r:-7.7
printf ( "Resultado = %f\n", f_valor1 * f_valor2); //r:-6.12
printf ( "Resultado = %f\n", f_valor1 / f_valor2); //r:-0.13

/*el resultado de 2 operandos con precisión distinta se
expresa con el de mayor precisión.
Si un operando esta en coma flotante y el otro es char o int
este último este se convierte a tipo coma flotante
*/

printf ( "Resultado = %f\n", 8 + 2.0); //r:10,00
printf ( "Resultado = %i\n", 5 + 'A'); //r:70

/*CAST - Conversión del valor resultante de una expresión
Cuando en una expresión se mezclan constantes y variables de
distintos tipos, todo se convierte a un tipo único.
El compilador convierte todos los operandos al tipo de mayor
operando (promoción de tipo)
*/

printf ( "Resultado = %i\n", ((int) (5 + 12.6) % 5)); //r:2

//OPERADORES UNARIOS o MONARIOS
//Actúan sobre un solo operando para producir un nuevo valor
//+ Unario Signo positivo
//- Unario Signo negativo

int a = 5;

/*Si el operador ++ o -- se coloca a la izquierda,
se llama preincremento o predecremento, respectivamente.
Si se coloca a la derecha, se llama postincremento o postdecremento.
*/

a++; //Aumenta en 1 el valor de a (a=a+1)
++a; //Aumenta en 1 el valor de a (a=a+1)
a--; //Disminuye en 1 el valor de A (a=a-1)
--a; //Disminuye en 1 el valor de A (a=a-1)

//OPERADORES RELACIONALES
valor1=1;
valor2=2;

//> Binario Mayor
printf ( "Resultado = %i\n", valor1 > valor2); //r:0
//>= Binario Mayor o igual
printf ( "Resultado = %i\n", valor1 >= valor2); //r:0
//< Binario Menor
printf ( "Resultado = %i\n", valor1 < valor2); //r:1
//<= Binario Menor o igual
printf ( "Resultado = %i\n", valor1 <= valor2); //r:1

//OPERADORES DE IGUALDAD
//== Binario Igual
printf ( "Resultado = %i\n", valor1 == valor2); //r:0
//!= Binario Distinto
printf ( "Resultado = %i\n", valor1 != valor2); //r:1

/*
OPERADORES LÓGICOS
&& Binario AND - Y - Cierta si Exp1 y Exp2 son ciertas
|| Binario OR - o Cierta si Exp1 o Exp2 son ciertas
! Unario NOT - Cierta si Exp1 es falsa. Falsa si Exp1 es cierta
*/

printf ( "Resultado = %i\n", (valor1 >=3) && (valor2 == 1)); //r:0
printf ( "Resultado = %i\n", (valor1 >=3) || (valor2 >= 2)); //r:1

//OPERADORES DE ASIGNACIÓN

a=2;
int b;
b=a+1;
a+=b; //a=a+b
printf ( "Resultado = %i\n", a); //r:5
a-=b; //a=a-b
printf ( "Resultado = %i\n", a); //r:2
a*=b; //a=a*b
printf ( "Resultado = %i\n", a); //r:6
a/=b; //a=a/b
printf ( "Resultado = %i\n", a); //r:2
a%=b; //a=a%b
printf ( "Resultado = %i\n", a); //r:2

/*
FUNCIONES DE BIBLIOTECA
C se acompaña de cierto numero de funciones de biblioteca
que realizan varias operaciones i - int, d double, u void

abs(i) , ceil(d) , cos(d), cosh(d), exp(d),
fabs(d), fllor(d), fmod(d1,d2), getchar(),
log(d), pow(d1,d2), printf(....), putchar(c),
rand(), sin(d), sqrt(d), srand(u),scanf(...), tan(d)
toascii(c)), tolower(c),toupper(c)

OPERADORES A NIVEL DE BITS

Recordar que los operadores relacionales y lógicos
siempre producen un resultado que es cierto o falso,
pero las operaciones entre bits producen cualquier
valor arbitrario de acuerdo con la operación especifica.

|  	OR (O)
& 	AND (Y)
^ 	XOR (O exclusivo)
~ 	Complemento a uno o negación
>> 	Desplazamiento a la derecha
<< 	Desplazamiento a la izquierda

*/

a = 7;
printf ( "Resultado = %i\n", a=a<<1); //r:14
printf ( "Resultado = %i\n", a=a<<3); //r:112
printf ( "Resultado = %i\n", a=a<<2); //r:448 printf ( "Resultado = %i\n", a=a>>1); //r:224
printf ( "Resultado = %i\n", a=a>>2); //r:56

/*/OPERADORES ESPECIALES
[ Arrays : Llevan a cabo el indexamiento de los arrays.
tipo nombre_del_vector [ dimensión ] ;
Ya lo veremos en mas detalle en posteriores artículos pero
para ir haciendo boca....
*/

int matriz [5] ; // Matriz de 5 elementos. Empiezan en el 0 hasta Dimensión -1
matriz [ 1 ] = 10;
printf ( "Resultado = %i\n", matriz [ 1 ]); //r:10

//Matrices de dos o más dimensiones:
//tipo matriz [ dimensión1 ] [ dimensión2 ] ... ;
//matriz[i,j] no es correcto pero no dará error = matriz[j]
//C no detecta índices fuera del rango
//Si a y b son matrices, a=b no es una expresión correcta

int matriz_dos [2][5] ;
matriz_dos [1][1] = 10;
printf ( "Resultado = %i\n", matriz_dos [1][1]); //r:10

/*Los punteros también los veremos en detalle en posteriores
artículos, pero son una dirección de memoria de una variable
Una variable puntero es una variable específicamente declarada
para contener un puntero a su tipo especifico

* Punteros Devuelve el contenido de un puntero q = *m
& Punteros Devuelve la dirección de un objeto m= &cont;
*/

int destino, origen;
int *m;
origen = 10;
m = &origen;
destino = *m;

printf("&d", destino);

//sizeof Devuelve el tamaño de un objeto
printf( "Tamaño int %i bytes\n", sizeof(int) ); //r:4Bytes

//() Funciones Indica que un objeto de tipo función

int exa_funcion(){return 0;}

//- -> Referencian elementos individuales de las estructuras y de las funciones
//. Cuando se trabaja con la estructura o la unión
//-> Cuando se usa un puntero a una estructura o a una unión

struct empleado
{
    char nombre[80];
    int edad;
    float sueldo;

} emp;

struct empleado *p = &emp;
emp.sueldo = 100.27;
p->sueldo = 100.27;

//? Suele usarse para sustituir ciertas instrucciones de la forma if-then-else

a = 10;
b = a > 9 ? 100 : 200; //r:b=100

//, Como operador permite concatenar varias expresiones
a = (b=2, b + 1); //r:3

/*PRECEDENCIA DE OPERADORES

() [] -> .
! ~ ++ -- (molde) * & sizeof (El * es el de puntero)
* / % (El * de aquí es el de multiplicación)
+ -
<< >>
< <= > >=
== !=
&
^
|
&&
||
?:
= += -= *= /=
,

*/

//EXPRESIONES COMPLEJAS
a=2;
printf ( "Resultado = %i\n", ( a>0 && a<5 ) || a>50); //r:1
printf ( "Resultado = %i\n", 5 - ( a = 12*(b=50)-2 )); //r:-593

/*ESPACIADOS Y PARÉNTESIS
Para incrementar la legitimidad se pueden añadir paréntesis y espacios
*/

a = (b/2) - ((3*b) & 12); //r:21

Enviar a un amigo: