Tipos de Datos Operadores y Expresiones

http://www.mboehara.
com Taller sobre Lenguaje C

03-02. Leyendo sobre tipos de datos, operadores y expresiones
Índice del usuario

Introducción......................................................................................................................................................2
3.1 Variables.....................................................................................................................................................2
3.2 Tipos de datos.............................................................................................................................................2
3.3 Constantes..................................................................................................................................................8
3.3.1 Constantes sin nombre............................................................................................................8
3.3.2 Constantes con nombre...........................................................................................................8
3.4 Declaraciones............................................................................................................................................10
3.5 Operadores aritméticos.............................................................................................................................11
3.6 Operadores relacionales............................................................................................................................12
3.7 Operadores lógicos...................................................................................................................................13
3.8 Operadores de incremento y decremento..................................................................................................14
3.9 Operadores de manejo de bits...................................................................................................................16
3.10 Expresiones.............................................................................................................................................18
3.11 Conversiones de tipo...............................................................................................................................21
3.12 Jerarquía de operaciones.........................................................................................................................23
3.13 Fuentes adicionales de consulta..............................................................................................................25
3.14 Bibliografía.............................................................................................................................................25
3.15 Licencia de uso.......................................................................................................................................26
1/26 José Rojas Dávalos - rojasdavalos@gmail.com Documento PDF

http://www.mboehara.com Taller sobre Lenguaje C
Introducción
Las expresiones dan “vida” a los programas de computadora. Esas expresiones, por
supuesto, se construyen a través de un lenguaje de programación, en este caso el C, y
están constituidas por las operaciones que aplican a los datos para obtener la
información buscada. Por eso, en esta unidad nos estaremos enterando de los tipos de
datos y los operadores, que permiten crear expresiones en el lenguaje C.
3.1 Variables
Algunas consideraciones para nombrar variables en lenguaje C:
➢ Se pueden combinar letras, dígitos y el guión bajo o subrayado: edad_p1.

➢ Debe empezar con una letra: edad_p1.
➢ Una variable en minúsculas es diferente a otra en mayúsculas, cuando se usa la
misma letra: B y b.
➢ Aunque la longitud máxima del nombre de una variable es 256, solamente, los
primeros 31 caracteres son significativos, para el estándar.
➢ Las palabras clave del lenguaje, como int, float, etc. no se pueden usar como
nombres de variables: return no puede ser el nombre de una variable entera.
➢ Que sean nombres auto-descriptivos: promedio.
Los ejemplos:
int edad_p1=4; // Empieza con letra, usa letras, dígitos y guión bajo.
int B=8; // Es diferente a b
int b=9; // Es diferente a B
// int return; // <-- No se puede usar una palabra reservada como nombre de variable
float promedio;// Nombre de variable auto-descriptivo
3.2 Tipos de datos
El lenguaje C maneja los tipos de datos básicos, mostrados en la siguiente tabla:
Tipo Descripción
char Carácter, de tamaño 1
int Entero
float Punto flotante de simple precisión
double Punto flotante de doble precisión
El tipo de dato int, puede recibir los modificadores short y long, que corresponden a
entero corto y entero largo, respectivamente, mientras al double se puede aplicar
long. La presencia o no del signo se indica con las palabras signed y unsigned. Si
no se usa, se asume signed.
El tipo cadena no existe. Se puede simular usando un vector de caracteres. También

se pueden definir arreglos de los tipos numéricos. A continuación ejemplos de

definiciones utilizando diferentes tipos de datos:
char letra; // Caracter de una posición

signed char estado; // Caracter con signo
unsigned int poblacion; // Entero
short antiguedad; // Entero corto
long suma; // Entero largo
float promedio; // Punto flotante de simple precisión
double total_estrellas_en_el_cielo; // Punto flotante de doble precisión
long double cantidad_particulas; // Punto flotante de doble precisión largo
char titulo[20]; // Vector de caracteres de 20 posiciones de tamaño 1, o cadena de 20 caracteres.
char meses[12][10]; // Vector de caracteres con 12 posiciones, donde cada posición tiene tamaño 10
float saldos[100]; // Vector de reales de simple precisión de 100 posiciones
Una mención especial merece el tipo char, que realmente es de tipo entero, pero que
puede almacenar cualquier tipo de carácter. Veamos la ductilidad de este tipo de dato,
con el siguiente ejemplo:
char letra; // Carácter de una posición

int main()
{
system("clear");
letra='A'; // Asigna valor
printf("La letra es %c. Su valor ASCII es %d\n",letra,letra);
return 0;
}
Si ejecutamos el programa el resultado es el siguiente:
La letra es A. Su valor ASCII es 65
A propósito, la tabla ASCII estándar, en la que se basan los códigos numéricos dados a
los caracteres se presenta en el documento, “Aprenda lenguaje ANSI C como si
estuviera en primero”, de la Escuela Superior de Ingenieros Industriales- Universidad
de Navarra, España, con la siguiente imagen:
En el printf() usamos dos formatos para 'A'. El primero es “%c”, para imprimir la letra
tal cual, y el segundo “%d”, con lo que obtenemos el valor numérico de la letra, en

otras palabras su valor ASCII.
Los tamaños en bytes de los tipos de datos básicos se pueden obtener en C, mediante
el operador sizeof(). El siguiente código fuente calcula y muestra los tamaños:
int main()
{
system("clear");
printf("Tamaño de datos básicos\n");
printf("=======================\n");
printf("Tipo\tTamaño en bytes\n");
printf("====\t===============\n");
printf("char\t%ld\n",sizeof(char));
printf("int\t%ld\n",sizeof(int));
printf("float\t%ld\n",sizeof(float));
printf("double\t%ld\n",sizeof(double));
return 0;
}
El resultado de la ejecución:
Tamaño de datos básicos

===============
Tipo Tamaño en bytes
==== ==========
char 1
int 4
float 4
double 8
Los valores mínimo y máximo posibles, dependen del procesador que se esté usando.
Es una de las críticas que se le hace al lenguaje C, en el sentido que el hecho
mencionado crea problemas de portabilidad(llevar de una plataforma a otra) de las
aplicaciones. Los archivos de cabecera <limits.h> y <float.h> del sistema en el cual
se trabaja, proporcionan los valores mencionados, según se ve en las siguientes líneas
de código:
#include <stdio.h>
#include <limits.h>
#include <float.h>
int main()
{
printf("*\n");
printf("Caracter con signo\n");
printf("Mínimo: %d\n",CHAR_MIN);
printf("Máximo: %d\n",CHAR_MAX);
printf("*\n");
printf("Caracter sin signo\n");
printf("Mínimo: 0\n");
printf("Máximo: %u\n",UCHAR_MAX);
printf("*\n");
…
...
Se muestra parte del resultado de la ejecución, en una notebook HP, con procesador
AMD de 64 bits:

*
Caracter con signo
Mínimo: -128
Máximo: 127
*
Caracter sin signo
Mínimo: 0
Máximo: 255
*
*
Entero corto con signo
Mínimo: -32768
Máximo: 32767
*
Entero corto sin signo
Mínimo: 0
Máximo: 65535
*
…
…
Como el C es un lenguaje “artesanal” permite que el programador defina su propio

tipo de datos. Una de las formas es usando la palabra clave typedef, que
sencillamente es una manera de renombrar un tipo de dato ya existente, dándole un
nombre nuevo. Su formato de uso es:
typedef tipo_dato_existente tipo_dato_nuevo;
Los ejemplos:
// Definición de nuevos tipos de datos

typedef short int entero_corto; // Crea tipo de dato entero corto
typedef float real_simple; // Crea tipo de dato punto flotante de simple precisión
typedef char car; // Crea tipo de dato caracter
// Uso de de nuevos tipos de datos
entero_corto nro_corto;
real_simple nro_real;
car letra;
Como se ve en la primera parte se crean los nuevos tipos de datos y más abajo se
definen variables con los tipos de datos creados. El programa fuente completo se ve
así:
#include <stdio.h> // Archivo de cabecera para subrutinas de e/s

#include <stdlib.h> // Archivo de cabecera para subrutinas de utilidades
// Definición de nuevos tipos de datos
typedef short int entero_corto; // Crea tipo de dato entero corto
typedef float real_simple; // Crea tipo de dato punto flotante de simple precisión
typedef char car; // Crea tipo de dato caracter
// Uso de de nuevos tipos de datos
entero_corto nro_corto;
real_simple nro_real;
car letra;
int main()
{ // Inicio
system("clear"); // Limpia pantalla

nro_corto=24;
nro_real=8.2;
letra='G';
printf("Corto: %d Real: %2.1f Letra: %c\n",nro_corto,nro_real,letra);
return 0;
} // Fin de programa
Corto: 24 Real: 8.2 Letra: G
Siguiendo en la línea de los tipos de datos creados por el programador veamos lo que
es una estructura. El concepto básico asociado a su creación y manipulación es el de
registro. Así, el nuevo tipo de dato definido agrupa uno o mas variables de distintos
tipos, conformando una unidad asociada a una persona, hecho o acontecimiento.
Podríamos, por ejemplo, necesitar guardar los datos de un libro en un archivo. Como
archivo es un conjunto de registros relacionados entre si, lo que hacemos es, definir el
formato de cada de los registros, como un nuevo tipo de dato. Posteriormente para
manipular cada registro dentro del programa definimos una estructura asociándola
con el nuevo tipo de dato, como se ve en el ejemplo:
struct elibro { // Crea la estructura del registro

int codigo;
char titulo[20];
char autor[20];
};
struct elibro libro; // Define libro con el tipo de dato elibro
Para el uso de un dato en la parte procedimental del programa, se hace referencia al

nombre de la estructura y el item, como se ve a continuación:
printf("Registro-->: %05d %-20s %-20s\n",libro.codigo,libro.titulo,libro.autor);
Una imagen de la ejecución del programa que usa la estructura definida:
Ingrese el codigo:1
Ingrese el título del libro:Rayuela
Ingrese el nombre del autor:Cortázar
Registro-->: 00001 Rayuela Cortázar
Veamos el código fuente completo:

struct elibro { // Crea la estructura del registro
int codigo;
char titulo[20];
char autor[20];
};
struct elibro libro; // Define libro con el tipo de dato elibro
int main()
{ // Inicio
// Ingresa datos del registro

printf("Ingrese el codigo:");
scanf("%d",&libro.codigo);
printf("Ingrese el título del libro:");
scanf("%s",libro.titulo);
printf("Ingrese el nombre del autor:");
scanf("%s",libro.autor);
// Imprime el registro
printf("Registro-->: %05d %-20s %-20s\n",libro.codigo,libro.titulo,libro.autor);
return 0;
La palabra clave union permite definir un tipo de dato muy similar definido por struct.
En este caso se trata de ahorrar espacio de almacenamiento, utilizando uno común
para guardar dos o más datos diferentes pero de raíz común. Por ejemplo, si sabemos
que el código que identifica a un país(“Paraguay”) es la primera letra de su
nombre('P') podemos almacenar ambos datos en un espacio común como se muestra
en el siguiente ejemplo:
union upais { // Crea la union

char nombre[30];
char codigo;
};
union upais pais; // Define pais con el tipo de dato upais
En la primera parte de crea el nuevo tipo de dato upais, definiendo nombre con 30
caracteres. Esa será la máxima longitud usada, la definición de codigo, con tamaño 1
no ocupa la posición 31 pues hace referencia a la primera posición de nombre, es
decir que la primera posición de nombre es el mismo espacio al que se refiere codigo.
El segundo uso de unión se encarga de definir la estructura pais con el tipo de dato
definido upais. Donde se nota claramente el espacio común que ocupan ambos datos
es en la parte procedimental, pues el único item que se carga es el nombre. Veamos la
ejecución del programa de prueba:
Ingrese el nombre del pais:Paraguay

Pais:Paraguay
Codigo:P
Se ve que se ingresa únicamente el nombre, pero se despliegan ambos datos. Este es

el código fuente:

union upais { // Crea la union
char nombre[30];
char codigo;
};
union upais pais; // Define pais con el tipo de dato upais
int main()
{ // Inicio4
printf("Ingrese el nombre del pais:");
scanf("%s",pais.nombre);
printf("Pais:%-30s\nCodigo:%c\n",pais.nombre,pais.codigo);
return 0;

En este caso también, para hacer referencia a un ítem se le antepone el nombre de la

unión, como se ve en el scanf() y el printf() del listado fuente mostrado.
3.3 Constantes
Una constante es aquel carácter o grupo de caracteres que se usa en forma literal en
la construcción de expresiones dentro de un programa, es decir no está contenida
dentro de una variable. Podemos agruparlas en constantes sin nombre y con nombre.
3.3.1 Constantes sin nombre
La siguiente tabla muestra ejemplos de constantes según tipos de datos:
Tipo de dato Ejemplo Formato de salida

Entero corto 32 %hd
Entero 32 %d
Entero largo 32L %ld
Entero sin signo 32U %u
Punto flotante – simple precisión 12.8F %f
Punto flotante – doble precisión 12.8 %f
Punto flotante – doble precisión extendida 12.8L %lf
Carácter 'A' %c
Cadena “Lenguaje C” %s
Se debe tener en cuenta que:
➢ Un dato tipo punto flotante asume doble precisión a menos que se use
modificador.
➢ Un carácter se delimita con apóstrofos.
➢ Una cadena se delimita con comillas.
Un ejemplo de líneas de código fuente que asocia variables con constantes:
short int entero_corto=32;

int entero=32;
long int entero_largo=32L;
unsigned int entero_sin_signo=32U;
float simple=12.8F;
double doble=12.8;
long double doble_extendido=12.8L;
float notacion_cientifica=4.5e-4;
char caracter='A';
char cadena[10]="Lenguaje C";
3.3.2 Constantes con nombre

Se crean con la directiva #define y facilitan el cambio de valor de una constante,

pues al darle nombre se cambia en un solo lugar sin necesidad de modificar cada
lugar el programa donde se usa, como en el ejemplo:
#include <stdio.h>
#include <stdlib.h>
#define elementos 100
int codigo_libro[elementos];
char nombre_libro[elementos][30];
float precio_libro[elementos];
char autor_libro[elementos][30];
char editorial_libro[elementos][30];
int main()
{
printf("Hay %d libros\n",elementos);
return 0;
}
Como se ve la constante definida es elementos que tiene como valor la dimensión de

5 vectores, también es usada en el procedimiento para imprimir la cantidad de libros.
Si llegara a cambiar la cantidad de libros, no será necesario cambiar el valor en lugar
en 6 lugares. Directamente se cambiaría en un lugar. El valor de elementos no se
puede cambiar en la parte de procedimiento del programa. La ejecución mostraré el
valor de la constante definida:
Hay 100 libros
Otra forma de definir constante con nombre es siguiendo el formato de declaración de

una variable y anteponiéndole la palabra clave const. Se muestra un ejemplo:
#include <stdio.h>
#include <stdlib.h>
const short codigo_postal= 234;
int main()
{
system("clear");
// codigo_postal=432;
printf("Código postal: %d\n",codigo_postal);
return 0;
}
El resultado de la ejecución se ve así:
Código postal: 234
El valor declarado de la constante no se puede cambiar en la parte procedimental del

programa. Si miramos el código fuente vemos una línea comentada que intenta
asignar un nuevo valor a la constantes. Si activamos la línea, quitando el carácter de
comentario y compilamos tenemos el siguiente resultado:

No se generó el ejecutable, pues hay error de compilación por el intento de modificar la constante.
Una modalidad bastante interesante de definir constantes con nombre es usando la llamada constante
de enumeración, de la cual se muestra un ejemplo:
enum {domingo=1,lunes, martes, miercoles, jueves, viernes, sabado} dia; // Define lista ennumerada
La línea precedente, la parte declarativa del programa, muestra la definición de 7 constantes con
nombre, cuyo valor inicial es el 1 asociado a la constante domingo y se agrupan bajo el nombre de dia. Si
no se define otro valor para lunes, tomará el valor 2 y así sucesivamente. Si domingo no se inicializa con
1, toma el valor 0, por lo que, según la progresión sábado tendría el valor 6.
El ejemplo de código fuente:

enum {domingo=1,lunes, martes, miercoles, jueves, viernes, sabado} dia; // Define lista
ennumerada
int main()
{ // Inicio
dia=viernes; // Asigna el valor 6 a dia
printf("Al viernes le corresponde el dia %d\n",dia);
return 0;
Al ejecutar se muestra:
Al viernes le corresponde el día 6
3.4 Declaraciones
En lenguaje C, es requisito declarar las variables a ser usadas. La forma general es:
[modificador] tipo_dato variable;
Un ejemplo con modificador:
short int edad;
Sin modificador:
int edad;
Se puede asociar un tipo de dato con una o varias variables:
char vocal, consonante;
Ó utilizar una línea por cada variable:

char vocal; // Para guardar una vocal

char consonante; // Para guardar una consonante
Esta última forma aunque ocupe más espacio ayuda a hacer un comentario por cada
variable facilitando la auto-documentación y legibilidad del programa fuente.
También se puede asociar valores iniciales a las variables:
int B=8; // Es diferente a b

int b=9; // Es diferente a B
char saludo[5]=”Hola”;
char letra='A';
3.5 Operadores aritméticos
La tabla mostrada a continuación se refiere a los operadores aritméticos binarios,

llamados así por tener dos operandos:
Operador Descripción Ejemplo Operadores Resultado

+ Suma o adición 4+2 Entero + entero 6, entero
- Resta o diferencia 4–2 Entero - entero 2, entero
* Multiplicación o producto 4*2 Entero * entero 8, entero
/ División o cociente 4/2 Entero / entero 2, entero
4 / 3.0 Entero / real 1.33, real
% Resto o módulo 4%2 Entero % entero 0, entero
4%3 Entero % entero 1, entero
Cabe realizar algunas consideraciones:
➢ El operador % denominado resto o módulo, devuelve 0 (cero) en el caso de los

operandos 4 y 2, y 1(uno) en el caso de 4 y 3.
➢ Cuando se dividen los enteros 4 y 3 el resultado es 1.33 de tipo real. En el caso
de que la variable receptora de la operación sea entera, el resultado será truncado a
1.
El código fuente de ejemplo:
#include <stdio.h>
#include <stdlib.h>
short a,b,c;
float b1,c1;
int main()
{
system("clear");
a=4;
b=2;
printf("Suma\n");
c=a+b; // Suma o adición
printf("\t%d + %d = %d\n",a,b,c);
printf("Resta\n");

c=a-b; // Resta o diferencia

printf("\t%d - %d = %d\n",a,b,c);
printf("Multiplicación\n");
c=a*b; // Multiplicación o producto
printf("\t%d * %d = %d\n",a,b,c);
printf("División\n");
c=a/b; // División o cociente tipo entero
printf("\t%d / %d = %d\n",a,b,c);
b1=3.0;
c1=a/b1; // División o cociente tipo real
printf("\t%d / %3.2f = %3.2f\n",a,b1,c1);
printf("Resto\n");
c=a%b; // Resto o módulo
printf("\tEl resto de %d/%d es %d\n",a,b,c);
b=3;
c=a%b; // Resto o módulo
printf("\tEl resto de %d/%d es %d\n",a,b,c);
return 0;
}
Suma
4+2=6
Resta
4-2=2
Multiplicación
4*2=8
División
4*2=2
4 / 3.00 = 1.33
Resto
El resto de 4/2 es 0
3.6 Operadores relacionales
Los operadores relacionales y su uso, se resumen en el siguiente cuadro:
Operador Descripción Ejemplo Resultado Valor lógico

== Igual a 2 == 2 1 Verdadero
'A' == 'a' 0 Falso
!= Distinto a 2 != 2 0 Falso
'A' != 'a' 1 Verdadero
> Mayor a 'a' > 'Z' 1 Verdadero
'Z' > 'a' 0 Falso
>= Mayor o '1' >= '1' 1 Verdadero
igual a 4 >= 5 0 Falso
< Menor a 'Z' < 'a' 1 Verdadero
'a' < 'Z' 0 Falso
<= Menor o 6 <= 6 1 Verdadero
igual a 8 <= 7 0 Falso

El programa de ejemplo arroja los siguientes resultados:
2 == 2 devuelve 1 que implica verdadero

'A' == 'a' devuelve 0 que implica falso
2 != 2 devuelve 0 que implica falso
'A' != 'a' devuelve 1 que implica verdadero
'a' > 'Z' devuelve 1 que implica verdadero
'Z' > 'a' devuelve 0 que implica falso
'1' >= '1' devuelve 1 que implica verdadero
4 >= 5 devuelve 0 que implica falso
'Z' < 'a' devuelve 1 que implica verdadero
'a' < 'Z' devuelve 0 que implica falso
6 <= 6 devuelve 1 que implica verdadero
8 <= 7 devuelve 0 que implica falso
Veamos el código fuente:

int main()
{ // Inicio
printf("2 == 2 devuelve %d que implica verdadero\n",2==2);
printf("'A' == 'a' devuelve %d que implica falso\n",'A'=='a');
printf("2 != 2 devuelve %d que implica falso\n",2!=2);
printf("'A' != 'a' devuelve %d que implica verdadero\n",'A'!='a');
printf("'a' > 'Z' devuelve %d que implica verdadero\n",'a'>'Z');
printf("'Z' > 'a' devuelve %d que implica falso\n",'Z'>'a');
printf("'1' >= '1' devuelve %d que implica verdadero\n",'1'>='1');
printf(" 4 >= 5 devuelve %d que implica falso\n",4>=5);
printf("'Z' < 'a' devuelve %d que implica verdadero\n",'a'>'Z');
printf("'a' < 'Z' devuelve %d que implica falso\n",'Z'>'a');
printf("6 <= 6 devuelve %d que implica verdadero\n",6<=6);
printf("8 <= 7 devuelve %d que implica falso\n",8<=7);
return 0;
3.7 Operadores lógicos
Los operadores de negación(!), de conjunción(&&) y de disyunción(||), trabajan sobre

operandos que son proposiciones lógicas y se basan en las llamadas tablas de verdad.
Repasemos esas tablas:
Negación
A No A
V F
F V
Conjunción
A B AyB
V F F

F V F
F F F
V V V
Disyunción
A B AoB
V F V
F V V
V V V
F F F
Se muestran los operadores lógicos en lenguaje C, con ejemplos:
Operador Descripción Ejemplo Resultado Valor lógico

! Negación !(1!=1) 1 Verdadero
!(1 == 1) 0 Falso
&& Conjunción 1 == 1 && 2 == 2 1 Verdadero
1 == 1 && 2 == 3 0 Falso
|| Disyunción 1 == 1 || 2 == 3 1 Verdadero
1 != 1 || 2 == 3 0 Falso
El código fuente de prueba:

int main()
{ // Inicio
printf("!(1 != 1) devuelve %d que implica verdadero\n",!(1 != 1));
printf("!(1 == 1) devuelve %d que implica falso\n",!(1 == 1));
printf("1 == 1 && 2 == 2 devuelve %d que implica verdadero\n",1 == 1 && 2 == 2);
printf("1 == 1 && 2 == 3 devuelve %d que implica falso\n",1 == 1 && 2 == 3);
printf("1 == 1 || 2 == 3 devuelve %d que implica verdadero\n",1 == 1 || 2 == 3);
printf("1 != 1 || 2 == 3 devuelve %d que implica falso\n",1 != 1 || 2 == 3);
return 0;
Una imagen de la prueba:
!(1 != 1) devuelve 1 que implica verdadero

!(1 == 1) devuelve 0 que implica falso
1 == 1 && 2 == 2 devuelve 1 que implica verdadero
1 == 1 && 2 == 3 devuelve 0 que implica falso
1 == 1 || 2 == 3 devuelve 1 que implica verdadero
1 != 1 || 2 == 3 devuelve 0 que implica falso
3.8 Operadores de incremento y decremento

Existen 2 operadores, el de incremento que se representa con ++(más más) y el de

decremento simbolizado por - - (menos menos). A su vez estos operadores pueden ser
usados en las posiciones sufijo, es decir antes de la variable a ser incrementada, o
postfijo, después de la variable a ser incrementada. En ambos casos el operador
incrementa la variable objeto en 1, pero:
➢ En el caso de uso como sufijo, por ejemplo, en ++a el valor de a se incrementa

en el momento de la operación. Por eso, en este caso, se dice que a se incrementa
antes de su uso.
➢ Sin embargo, si se usa como postfijo, como en a++ el valor de a, en el
momento de la operación, no cambia. Recién en el siguiente uso de a, se verá
reflejado el incremento. En esta situación se habla de que a se incrementa después
de su uso.
De acuerdo a lo expuesto, podemos tener:

➢ Si a=10 y b=++a, entonces, b=11.
➢ Si a=10 y b=a++, entonces, b=10.
➢ Si a=10 y b=- -a, entonces, a=9.
➢ Si a=10 y b=a- -, entonces a=10.
La ejecución del programa de prueba, confirma lo afirmado:
Valor inicial de a = 10
Valor de a en el momento de hacer la operacion ++a = 11
Valor de a después de hacer ++a = 11
Valor de a en el momento de hacer la operación a++ = 10
Valor de a después de hacer a++ = 11
Valor de en el momento de hacer la operación --a = 9
Valor de a después de hacer --a = 9
Valor de a en el momento de hacer la operación a-- = 10
Valor de a después de hacer a-- = 9
La prueba se realizó mediante el siguiente código fuente:

short a,b;
int main()
{ // Inicio
a=10;
printf("Valor inicial de a = %hd\n",a);
b=++a;
printf("Valor de a en el momento de hacer la operacion ++a = %hd\n",b);
printf("Valor de a después de hacer ++a = %hd\n",a);
a=10;
b=a++;
printf("Valor de a en el momento de hacer la operación a++ = %hd\n",b);
printf("Valor de a después de hacer a++ = %hd\n",a);

a=10;
b=--a;
printf("Valor de en el momento de hacer la operación --a = %hd\n",b);
printf("Valor de a después de hacer --a = %hd\n",a);
a=10;
b=a--;
printf("Valor de a en el momento de hacer la operación a-- = %hd\n",b);
printf("Valor de a después de hacer a-- = %hd\n",a);
return 0;
Ambos operadores, pueden aplicarse a variables, no así a expresiones. Es decir se

puede hacer x++ pero no ++(x+5).
3.9 Operadores de manejo de bits
Cuando se trata de programación a bajo nivel, es decir, aquella que está más “cerca”
del hardware, es algo usual que se recurra a la manipulación de bits u operaciones bit
a bit (bitwise), como sería el caso de software para controlar microcontroladores, con
requerimientos de configurar los registros para usar el hardware, incluido el acceso a
puertos de comunicación, realizar operaciones más eficaces y eficientes, y validar los
datos de entrada/salida, entre otras prestaciones.
Desde la programación en C, tanto los parámetros como el resultado de las

operaciones de manejo de bits, se expresan como números decimales, pues las
conversiones se realizan en forma interna, transparentes para el usuario. En el caso de
las operaciones con dos operandos, el operador compara los bits que se corresponden
en posición dentro de cada operando, para generar un resultado. Si se trata de
operaciones con un operando, el operador actúa sobre cada bit del único operando. El
comportamiento de los operadores y los resultados generados se describen a
continuación:
AND: En el caso de que ambos bits comparados tengan valor 1 el resultado es 1(uno).
En todas las otras combinaciones se genera 0(cero). El formato general es:
z=x&y
donde & es el operador, x e y son los dos números decimales comparados y el
resultado se carga en z, que es el nuevo número generado.
OR: Si ambos bits comparados tienen valor 0(cero) el resultado es 0(cero). En los
casos restantes el valor es 1(uno). La forma general de uso:
z=x|y
siendo | el operador, x e y son los números decimales comparados generando z.
XOR: También conocido como OR exclusivo. Si los bits comparados tienen igual valor,
el resultado es 0(cero). En situación contraria se genera 1(uno). El esquema de uso se
muestra a continuación:
z=x^y
donde ^ es el operador, x e y son los números decimales comparados almacenándose
el resultado en z.

Desplazamiento a la derecha: Desplaza los bits menos significativos, que se van

perdiendo a medida que ocurre el corrimiento, de izquierda a derecha. Aparte de
proporcionarse el número decimal sobre el cual se realiza la operación, se define la
cantidad de bits a ser desplazados, que se reemplazan con ceros a la izquierda. La
forma general es:
z = x >> n
donde z recibirá el resultado de desplazar a la derecha n bits de x, mediante el
operador >>.
Desplazamiento a la izquierda: Desplaza los bits más significativos, que se van

perdiendo a medida que ocurre el corrimiento, de derecha a izquierda. Aparte de
proporcionarse el número decimal sobre el cual se realiza la operación, se define la
cantidad de bits a ser desplazados, que se reemplazan con ceros a la derecha. La
forma general es:
z = x << n
donde z recibirá el resultado de desplazar a la derecha n bits de x, mediante el
operador <<.
Complemento de a uno: Invierte los valores de los bits de la expresión numérica

involucrada en el proceso de manipulación. El formato del uso del operador es:
z=~x
donde z es el resultado de invertir los valores de los bits de x, a través del operador ~.
Para ilustrar mejor, resumimos lo que se puede hacer con los operadores de este tipo
en la siguiente tabla:
Ejemplos
Operación Resultado
Operador Nombre Decimal Binario Decimal Binario
& AND 5&6 101 & 110 4 100
| OR 5|6 101 | 110 7 111
^ XOR 5^6 101 ^ 110 3 011
>> Desplazamiento a la derecha 5 >> 1 101 >> 1 2 0010
<< Desplazamiento a la izquierda 5 << 1 101 << 1 10 1010
~ Complemento a uno ~5 ~00000101 -6 11111010
Reforzamos la ilustración mostrando la ejecución del programa de prueba:
AND: 5 & 6(101 & 110) = 4(100)

OR: 5 | 6(101 | 110) = 7(111)
XOR: 5 ^ 6(101 ^ 110) = 3(011)
Desplazamiento a la derecha: 5 >> 1(101 >> 1) = 2(0010)
Desplazamiento a la izquierda: 5 << 1(101 << 1) = 10(1010)
Complemento a uno: ~5(~00000101) = -6(11111010)
A continuación el código fuente del programa de prueba:


char x,y,z;
int main()
{ // Inicio
x=5;
y=6;
z=x&y; // AND
printf("AND: %d & %d(101 & 110) = %d(100)\n",x,y,z);
z=x|y; // OR
printf("OR: %d | %d(101 | 110) = %d(111)\n",x,y,z);
z=x^y; // XOR
printf("XOR: %d ^ %d(101 ^ 110) = %d(011)\n",x,y,z);
z=x>>1; // Desplazamiento a la derecha
printf("Desplazamiento a la derecha: %d >> 1(101 >> 1) = %d(0010)\n",x,z);
z=x<<1; // Desplazamiento a la izquierda
printf("Desplazamiento a la izquierda: %d << 1(101 << 1) = %d(1010)\n",x,z);
z=~x ; // Complemento a uno
printf("Complemento a uno: ~%d(~00000101) = %d(11111010)\n",x,z);
return 0;
3.10 Expresiones
La conjunción de operadores y operandos, permiten construir las expresiones en

lenguaje C. Una expresión como c = 1 es una asignación, pues el valor 1 se está
asignando o cargando en la variable c. Entonces, podemos decir que en una
asignación es imprescindible tener una variable receptora a la izquierda del signo
igual y un valor que se asocia a la derecha de la igualdad. El valor asociado puede ser
una constante como en este caso, otra variable o una operación. De acuerdo al tipo de
dato del valor asignado a la variable, la expresión puede ser numérica, carácter,
cadena o lógica. Así podemos podemos tener:
Expresiones aritméticas, como c = a + b, suponiendo a,b y c de tipo entero, Las

expresiones de este tipo se construyen con datos tipo int o float, e incluso con char
que sabemos, internamente se manejan como entero. Otros ejemplos son 5 % 2 o 8.2
* 4. La siguiente porción de código fuente constituye un ejemplo del uso de
expresiones aritméticas:
a=4;
b=2;
printf("Suma\n");
c=a+b; // Suma o adición
printf("\t%d + %d = %d\n",a,b,c);
Veamos el resultado de la ejecución de un programa con varias expresiones

aritméticas:
Suma
4+2=6
Resta
4-2=2
Multiplicación
4*2=8

División
4/2=2
4 / 3.00 = 1.33
Resto
Expresiones lógicas, que son consecuencia del uso operadores relacionales. Por
ejemplo, las expresiones a > b, a < b y a == b, son de tipo lógico, pues tienen dos
resultados posibles: que sea verdadero o falso. La comparación retorna 0 si la
expresión es falsa o un valor distinto de cero si es verdadera. Veamos ejemplos:
Valor de a:7
Valor de b:5
Para a = 7 y b = 5
7 > 5 devuelve 1
7 < 5 devuelve 0
7 == 5 devuelve 0
La implementación en código fuente:

int main()
{ // Inicio
int a,b; // Enteros a ser leidos por teclado
int c; // Para guardar resultado de la comparación
printf("Valor de a:");
scanf("%d",&a); // Lee valor de a
printf("Valor de b:");
scanf("%d",&b); // Lee valor de b
printf("Para a = %d y b = %d\n",a,b);
c = a > b;
printf("%d > %d devuelve %d\n",a,b,c);
c = a < b;
printf("%d < %d devuelve %d\n",a,b,c);
c = a == b;
printf("%d == %d devuelve %d\n",a,b,c);
return 0;
Expresiones carácter, que son aquellas de tipo char. Por ejemplo:
letra = 'A';
Expresiones cadena, construidas por grupos de caracteres, ya que en el lenguaje C

no existe el tipo “string” o cadena. Un ejemplo:
strcpy(saludo,”Buenos”);
Esta expresión es equivalente a escribir saludo = “Buenos”, pero en que C no se

puede hacer. Otra expresión que involucra a una operación aproximada a la
concatenación de otros lenguajes de programación se construye mediante la función
strcat. Suponiendo que queremos añadir la cadena “ días” al valor de la variable

saludo, haríamos:
strcat(saludo," dias");
Con esto, si se despliega el valor de saludo, se vería así:
Buenos dias
Mostramos el programa fuente completo que hace uso de las expresiones cadena:

#include <string.h> // Archivo de cabecera para funciones cadena
int main()
{ // Inicio
char saludo[12]; // Define variable cadena
strcpy(saludo,"Buenos"); // Asigna valor a cadena
strcat(saludo," dias"); // Agrega constante cadena a variable
printf("%s\n",saludo); // Muestra cadena nueva
return 0;
Las expresiones condicionales, ayudan a simplificar el código desde un punto de

vista, pues una expresión condicional del tipo si...sino...finsi, se puede implementar en
una línea. Suponiendo que quiero comparar x e y, queriendo saber cual es menor,
podría escribir:
z=(x < y) ? x:y; // Carga menor entre x e y en z
La condición x < y es la que va entre paréntesis, la expresión que viene después de ?

es la que determina el valor de z. Si la condición es verdadera se cargará x en z, sino z
tomará el valor de y. Una aplicación interesante de esta característica del lenguaje c,
podría ser determinar si x es par. Veamos una primera forma:
t=(x % 2 == 0) ? 'p':'i'; // Carga 'p' en t, sino carga 'i'

printf("%d es %s\n",x,(t=='p') ? "par":"impar"); // De acuerdo a que t sea 'p' o 'i', muestra "par" o "impar"
Siendo t una variable tipo char, se cargará en ella 'p' si es par o 'i' en caso contrario.
En el printf() se vuelve a usar una expresión condicional, pero ya para imprimir “par” o
“impar” de acuerdo a que t sea 'p' o 'i'. Pero podemos simplificar las dos líneas de
código en una, escribiendo:
printf("%d es %s\n",x,(x % 2 == 0) ? "par":"impar"); // Si x % 2 == 0 retorna 1(verdadero) muestra "par",

sino "impar"
Como se ve, se pregunta directamente por el valor del resto de x/2 para construir la
expresión condicional y retornar el mensaje adecuado a la situación. Veamos algunos
ejemplos de ejecución:
El menor entre 9 y 7 es 7
9 es impar
10 es par

El código fuente de ejemplo:

#include <string.h> // Archivo de cabecera para funciones cadena
int main()
{ // Inicio
int x,y,z; // A ser usadas en la condición y resultado de la expresión
char t; // Guarda resultado de expresión
system("clear");
x=9; // Miembro 1 de la comparación
y=7; // Miembro 2 de la comparación
z=(x < y) ? x:y; // Carga menor entre x e y en z
printf("El menor entre %d y %d es %d\n",x,y,z); // Muestra resultado de la expresión condicional
t=(x % 2 == 0) ? 'p':'i'; // Carga 'p' en t, sino carga 'i'
printf("%d es %s\n",x,(t=='p') ? "par":"impar"); // De acuerdo a que t sea 'p' o 'i', muestra "par" o
"impar"
x=10; // Carga x para analizar si es par o impar
printf("%d es %s\n",x,(x % 2 == 0) ? "par":"impar"); // Si x % 2 == 0 retorna 1(verdadero)
muestra "par", sino "impar"
return 0;
Finalmente, debemos tener en cuenta que:
➢ Los paréntesis no son necesarios para delimitar la condición, pero es altamente

recomendable para mejorar la legibilidad.
➢ Hablando de legibilidad, aunque esta facilidad ayuda a escribir menos líneas de
código, no hace mucho a la legibilidad, pues para empezar no responde a lo se
aprende en Algorítmica en cuando a expresiones condicionales. Y si uno piensa en que
otra persona podría revisar y modificar sus programas, lo recomendable es usar las
expresiones condicionales “tradicionales”, pues, aunque implique escribir más,
siempre es más entendible con el primer “golpe de vista”.
3.11 Conversiones de tipo
En este apartado vamos a ver como convertir datos de un tipo a otro. Existen dos
formas de convertir datos. Una de ellas es la implícita y la otra la explicita, también
llamada casting, en inglés. En el caso de las conversiones implícitas partamos de un
caso práctico. Quiero sumar los números 4 y 2.2. Como se ve 4 es entero y 2.2 real.
Teniendo las siguientes declaraciones:
int x=4; // Sumando 1

float y=2.2; // Sumando 2
float z; // Resultado real
int u; // Resultado entero
Realizamos la siguiente operación:
z=x+y; // Conversión implicita sin perdida de datos
El resultado:

4 + 2.2 = 6.2
¿Qué sucedió? Para realizar la conversión se realizó una verificación de cual de los
operandos tenía mayor jerarquía de tipo de datos. En este caso el float de y es de
mayor jerarquía que el int de x. Por lo tanto, el resultado en z es de tipo float. Es decir
se realizo la conversión implícita a float. La jerarquía usada en la conversión se da de
acuerdo de la siguiente lista, de mayor a menor:
long double, double, float, unsigned long, long, unsigned int, int, char
donde long double es el de mayor jerarquía y char el de menor.
Otro caso interesante se presenta cuando la variable receptora es de un tipo de dato

de menor jerarquía que la expresión asignada. Por ejemplo, tenemos la definición:
int u; // Resultado entero
y la asignación:
u=x+y; // Conversión implícita con perdida de datos
La variable receptora u es explícitamente de tipo entero y la expresión asignada es

implícitamente de tipo real, hecho dado por la jerarquía de tipos de datos. El resultado
es:
4 + 2.2 = 6
Como se ve hay una perdida de datos, por lo que hay extremar cuidados con este tipo
de conversión.
En cuanto a conversión explícita, vamos a suponer que tenemos la siguiente

asignación:
y=2.0; // Nuevo valor
Realizamos la siguiente operación:
u=x+(int)y; // Conversión explicita
Tenemos el siguiente resultado:
4 + 2.0 = 6
Acabamos de convertir explícitamente y a entero, durante la operación de suma. Hay

que tener en cuenta que y no perdió su tipo de dato original hecho que se notó en el
resultado y también en la siguiente línea de código:
printf("%d + %2.1f = %d\n",x,y,u);
Otra forma de conversión explicita es realizarla usando funciones predefinidas del

lenguaje, como se muestra en los siguientes ejemplos:

printf("Cadena: \"%s\" a punto flotante: %7.2f\n","12345.50",atof("12345.50")); // atof()

printf("Cadena: \"%s\" a entero: %d\n","12345",atoi("12345")); // atoi()
printf("Cadena: \"%s\" a entero largo: ld\n","12345679012334",atol("12345679012334")); // atol()
El resultado del uso:
Cadena: "12345.50" a punto flotante: 12345.50

Cadena: "12345" a entero: 12345
Cadena: "12345679012334" a entero largo: 12345679012334
El código fuente completo:

int main()
{ // Inicio
int x=4; // Sumando 1
float y=2.2; // Sumando 2
float z; // Resultado real
int u; // Resultado entero.
z=x+y; // Conversión implicita sin perdida de datos
printf("%d + %2.1f = %2.1f \n",x,y,z);
u=x+y; // Conversión implicita con perdida de datos
printf("%d + %2.1f = %d\n",x,y,u);
y=2.0; // Nuevo valor
u=x+(int)y; // Conversión explicita
printf("%d + %2.1f = %d\n",x,y,u);
// Conversiones explícitas mediante funciones}
printf("Cadena: \"%s\" a punto flotante: %7.2f\n","12345.50",atof("12345.50")); // atof()
printf("Cadena: \"%s\" a entero: %d\n","12345",atoi("12345")); // atoi()
printf("Cadena: \"%s\" a entero largo: %ld\n","12345679012334",atol("12345679012334")); //
atol()
return 0;
3.12 Jerarquía de operaciones
Las operaciones de una expresión se rigen por la jerarquía que tienen definida los
operadores. Por ejemplo, si tengo la expresión:
5+7*3
Y realizo primero la suma:
(5+7)*3
El resultado es:
36
Sin embargo si hago:
5+(7*3)

Tengo como resultado:
26
Veamos que pasó. En el primer caso le di prioridad a la suma usando paréntesis y

obtuve 36 como resultado. Sin embargo en el segundo caso la prioridad fue para el
producto y obtuve 26. ¿Que pasaría si no uso paréntesis para agrupar una de las
operaciones? Averigüemos. Si tengo la siguiente línea de código:
printf("5+7*3 = %d\n",5+7*3);
Se ve que la expresión, cuyo resultado de va a mostrar, no usa paréntesis. Y al

ejecutar, muestra:
5+7*3 = 26
Es evidente que ejecutó el producto en primer lugar. En este caso se puede afirmar
que el producto tiene mayor prioridad que la suma.
En cuanto a la “Precedencia y asociatividad de los operadores de C”, en el documento,

“Aprenda lenguaje ANSI C como si estuviera en primero”, de la Escuela Superior de
Ingenieros Industriales- Universidad de Navarra, España, se muestra el siguiente
cuadro:
El primer grupo(línea 1) de arriba, es el de mayor prioridad, mientras el de la última

línea es de menor jerarquía. A eso se denomina precedencia. Asociando con el
ejemplo de operación que vimos, se puede notar que el producto está una línea antes
que la suma, lo que confirma la validez del resultado de nuestra prueba. También
podemos observar que para los operadores de la misma precedencia o prioridad se
aplica el concepto de asociatividad en el sentido que algunos grupos(líneas) la
jerarquía se da de izquierda a derecha y en otros de derecha a izquierda.

Tomemos la línea:
Vemos las operaciones de producto, cociente y módulo con la misma precedencia,

pero la diferencia se da por la asociatividad de izquierda a derecha lo que implica que
en el caso de una operación que involucre a los 3 operadores, los cálculos se harían en
el orden producto, cociente y módulo. Veamos una prueba:
3*7/3%2 = 1
Si efectuamos según la regla:
3*7=21, 21/3=7, 7%2=1.
Vemos que el resultado es correcto, acorde con las reglas.
Una prueba completa:
Prioridad a suma: (5+7)*3 = 36

Prioridad a producto: 5+(7*3) = 26
Prioridad dada por C: 5+7*3 = 26
Asociatividad dada por C: 3*7/3%2 = 1
Se muestra el programa fuente:

int main()
{ // Inicio
system("clear");
printf("Prioridad a suma: (5+7)*3 = %d\n",(5+7)*3); // Prioridad a suma con paréntesis
printf("Prioridad a producto: 5+(7*3) = %d\n",5+(7*3)); // Prioridad a producto con paréntesis
printf("Prioridad dada por C: 5+7*3 = %d\n",5+7*3); // Prioridad manejada por el lenguaje
printf("Asociatividad dada por C: 3*7/3%%2 = %d\n",3*7/3%2); // Asociatividad izquierda a
derecha manejada por el lenguaje
return 0;
3.13 Fuentes adicionales de consulta
Aprenda lenguaje ANSI C como si estuviera en primero – Páginas 13 al 31

Curso Básico de programación en C – Páginas 11 al 13
El lenguaje de programación C – Páginas 39 al 57
Manipulación de bits en C y aplicaciones
3.14 Bibliografía
Escuela Superior de Ingenieros Industriales- Universidad de Navarra. (1998). APRENDA

LENGUAJE ANSI C como si estuviera en primero. Recuperado de
http://www4.tecnun.es/asignaturas/Informat1/AyudaInf/aprendainf/ansic/leng_c.pdf .

Kernighan B y Ritchie D.(1991). EL LENGUAJE DE PROGRAMACIÓN C(2a edición).

México: PRENTICE-HALL HISPANOAMERICANA, S.A.
Nómadas Electrónicos. (2015). Manipulación de bits en C y aplicaciones. Recuperado

de https://nomadaselectronicos.wordpress.com/2015/03/05/manipulacion-de-
bits-en-c-y-aplicaciones/
Universidad Complutense de Madrid. (s/f). CURSO BÁSICO DE PROGRAMACIÓN EN C.

Recuperado de http://www.sisoft.ucm.es/Manuales/Lenguaje_C.pdf
3.15 Licencia de uso
Este trabajo se libera bajo el tipo de licencia PP, de la expresión guaraní "Pejapo
Pejaposeva" y en castellano sería, "Hagan Lo Que Quieran"(HLQQ). Con una licencia PP
ya saben que pueden copiar "in extenso", duplicar, reutilizar, adaptar, re-mezclar y redistribuir,
sin rubores ni remordimientos. Para mí, un docente que no comparte sus conocimientos, obras
u otros recursos y servicios, y piensa solo en lo que le "costó" adquirir y como "recuperar" eso,
no merece la distinción de llamarse tal. Con eso no digo que se muera de hambre y no cobre
por sus servicios. Pero si empieza a (pensar en) lucrar, ahí ya no nos entendemos.
Fin del documento

Tipos de Datos Operadores y Expresiones

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Tipos de Datos Operadores y Expresiones

Transféré par

Droits d'auteur :

Formats disponibles

http://www.mboehara.

com Taller sobre Lenguaje C

Índice del usuario

1/26 José Rojas Dávalos - rojasdavalos@gmail.com Documento PDF

Algunas consideraciones para nombrar variables en lenguaje C:

➢ Se pueden combinar letras, dígitos y el guión bajo o subrayado: edad_p1.

3.2 Tipos de datos

El lenguaje C maneja los tipos de datos básicos, mostrados en la siguiente tabla:

El tipo cadena no existe. Se puede simular usando un vector de caracteres. También

2/26 José Rojas Dávalos - rojasdavalos@gmail.com Documento PDF

definiciones utilizando diferentes tipos de datos:

char letra; // Caracter de una posición

char letra; // Carácter de una posición

Si ejecutamos el programa el resultado es el siguiente:

La letra es A. Su valor ASCII es 65

3/26 José Rojas Dávalos - rojasdavalos@gmail.com Documento PDF

otras palabras su valor ASCII.

Tamaño de datos básicos

4/26 José Rojas Dávalos - rojasdavalos@gmail.com Documento PDF

Como el C es un lenguaje “artesanal” permite que el programador defina su propio

typedef tipo_dato_existente tipo_dato_nuevo;

// Definición de nuevos tipos de datos

#include <stdio.h> // Archivo de cabecera para subrutinas de e/s

5/26 José Rojas Dávalos - rojasdavalos@gmail.com Documento PDF

Corto: 24 Real: 8.2 Letra: G

struct elibro { // Crea la estructura del registro

Para el uso de un dato en la parte procedimental del programa, se hace referencia al

printf("Registro-->: %05d %-20s %-20s\n",libro.codigo,libro.titulo,libro.autor);

Una imagen de la ejecución del programa que usa la estructura definida:

Veamos el código fuente completo:

#include <stdio.h> // Archivo de cabecera para subrutinas de e/s

6/26 José Rojas Dávalos - rojasdavalos@gmail.com Documento PDF

union upais { // Crea la union

Ingrese el nombre del pais:Paraguay

Se ve que se ingresa únicamente el nombre, pero se despliegan ambos datos. Este es

#include <stdio.h> // Archivo de cabecera para subrutinas de e/s

7/26 José Rojas Dávalos - rojasdavalos@gmail.com Documento PDF

En este caso también, para hacer referencia a un ítem se le antepone el nombre de la

3.3.1 Constantes sin nombre

La siguiente tabla muestra ejemplos de constantes según tipos de datos:

Tipo de dato Ejemplo Formato de salida

Se debe tener en cuenta que:

Un ejemplo de líneas de código fuente que asocia variables con constantes:

short int entero_corto=32;

3.3.2 Constantes con nombre

8/26 José Rojas Dávalos - rojasdavalos@gmail.com Documento PDF

Se crean con la directiva #define y facilitan el cambio de valor de una constante,

Como se ve la constante definida es elementos que tiene como valor la dimensión de

Hay 100 libros

Otra forma de definir constante con nombre es siguiendo el formato de declaración de

El resultado de la ejecución se ve así:

Código postal: 234

El valor declarado de la constante no se puede cambiar en la parte procedimental del

9/26 José Rojas Dávalos - rojasdavalos@gmail.com Documento PDF

El ejemplo de código fuente:

#include <stdio.h> // Archivo de cabecera para subrutinas de e/s

Al viernes le corresponde el día 6

[modificador] tipo_dato variable;

Un ejemplo con modificador:

short int edad;

Se puede asociar un tipo de dato con una o varias variables:

char vocal, consonante;

Ó utilizar una línea por cada variable:

10/26 José Rojas Dávalos - rojasdavalos@gmail.com Documento PDF