Este documento presenta una introducción a los elementos del lenguaje C, incluyendo comentarios, identificadores, tipos de datos, modificadores de tipos, variables, constantes, operadores y expresiones. Explica los diferentes tipos de variables, modificadores y operadores permitidos en C, así como las reglas para su uso.

1. Introducción a “C”
Unidad 2
Autor
Isabel Ponce

2. Unidad 2
Contenido
• Elementos del lenguaje:
– Comentarios
– Identificadores
– Tipos de datos
– Modificadores de tipos
– Variables
• Clasificación de variables
• Modificadores de acceso
• Modificadores de almacenamiento
• Inicialización
– Constantes
– Operadores
– Expresiones
– Conversión de tipos

3. Elementos del Lenguaje
• Aunque el lenguaje C es un
lenguaje pequeño, tiene un
conjunto de elementos que
permiten crear programas muy
potentes.
• Como la mayoría de los
lenguajes imperativos, C
permite manipular la memoria
mediante variables y constantes
que tienen sus propios
identificadores.

4. Comentarios
• El lenguaje C maneja dos tipos de
comentarios:
<comentario_de_una_línea> ::=
// <comentario>
<comentario_de_una_o_varias_líneas> ::=
/* <línea_de_comentario>
[<línea_de_comentario>*] */
• Ejemplo:
/* ********
* Programa: Prueba.C
* Autor: Pedro Picapiedra
* Objetivo: Mostrar el uso de comentarios
* Fecha: 01/01/01
******** */
x = x + 1; //incrementa x en 1

5. Literales
• Las literales permitidas son:
– Enteras
– Reales
– De carácter
– De cadena
– Nulos
• Ejemplo
#include <stdio.h>
#include <conio.h>
#define ENTERO 1234
#define LARGO 123456l
#define CORTO 10
#define SIN_SIGNO 1234u
#define HEXA 0x123a
#define OCTAL 01234
#define REAL 12345678.5f
#define DOBLE 123456789012345.5
#define DOBLE_LARGO 12345678901234567890.5

6. Literales
#define CARACTER 'M'
#define SALTO 'n'
#define CADENA "Hola Mundo "
#define NULO NULL
void main () {
clrscr(); //clear screen (limpiar pantalla)
printf(" Entero decimal: %d", ENTERO);
printf("n Entero largo: %ld", LARGO);
printf("n Entero corto: %d", CORTO);
printf("nEntero sin signo: %u", SIN_SIGNO);
printf("n Hexadecimal: %X", HEXA);
printf("n Octal: %o", OCTAL);
printf("n Flotante: %f", REAL);
printf("nFlotante formato: %5.1f", REAL);
printf("n Doble: %lf", DOBLE);
printf("n Doble largo: %e", DOBLE_LARGO);
printf("n Caracter: %c", CARACTER);
printf("n Cadena: %s", CADENA);
printf("n Nulo: %s", NULO);
printf("%c%c%c%c Cadena: %s", SALTO,
SALTO, SALTO, SALTO, CADENA);
getch();
}

7. Identificadores
• Las reglas para nombrar a los
identificadores son:
– La longitud puede variar (1-31)
– El primer caracter debe ser
alfabético o subrayado.
– Los siguientes pueden ser
alfabéticos, dígitos o subrayado.
– Son sensibles a minúsculas y
mayúsculas.
– Deben ser únicos.
– No pueden ser palabras
reservadas.
– No se permiten caracteres
especiales como espacios,
acentos o guiones.

8. Palabras reservadas
• Las palabras reservadas del
lenguaje son:
auto double int struct
break else long switch
case enum register typedef
char extern return union
const float short unsigned
continue for signed void
default goto sizeof volatil
do if static while

9. Tipos de datos
• Existen 5 tipos de datos básicos:
char, int, float, double y void.
• El tamaño y rango de los tipos varía
en cada procesador y compilador.
• No existe el tipo lógico.
Tipo Tamaño Rango
char 8 -128 a 127
unsigned char 8 0 a 255
signed char 8 -128 a 127
int 16 -32768 a 32767
unsigned int 16 0 a 65535
signed int 16 = int
short int 16 = int
unsigned short int 16 = int
signed short int 16 = short int
long int 32 +-2147483647
signed long int 32 +-2147483647
unsigned long int 32 0 a 4294967295
float 32 6 dígitos precisión
double 64 10 dígitos precisión
long double 80 10 dígitos precisión

10. Modificadores de Tipos
• Los modificadores pueden
alterar el significado de los tipos.
• En algunos casos poner un
modificador puede ser
redundante.
• Algunos compiladores permiten
unsigned float.
• Los modificadores son:
Modificadores Tipo
signed, unsigned char, int
short int
long int, double

11. Constantes
• Aunque puede emplearse el
modificador const para las
variables, es más común emplear
directivas del preprocesador para
declarar constantes:
#define <identificador> <literal>
• Nótese que las directivas del
preprocesador no requieren punto y
coma al final.
• Tampoco se usa el operador = para
asignar el valor de la constante.
#define UNO 1
#define MS_E “Error de entrada”
#define MAXIMO 100
#define VERDADERO 1

12. Variables
• La sintaxis general para declarar
una variable es:
<tipo> <identificador>* [= <valorInicial>];
• El tipo puede ser alguno de los tipos
elementales o alguno definido por el
usuario.
• Ejemplos:
int i, j, k;
short int eCorto;
unsigned int eSinSigno;
double balance, beneficio, perdida;

13. Inicialización de Variables
• Para asignar un valor inicial a una
variable al momento de declararla,
basta con colocar el operador de
asignación = después del nombre
de la variable y el valor literal
deseado.
• Ejemplo:
char cCaracter = ‘a’;
int ePrimero = 0;
float fBalance = 123.23f;

14. Variables
#include <stdio.h>
#include <conio.h>
void main() {
char caracter = 'm';
signed char caracterConSigno = 'e';
unsigned char caracterSinSigno = 'd';
char* cadena ="Hola Mundo";
int entero = 32123;
signed int enteroConSigno = 32123;
unsigned int enteroSinSigno = 65123;
short int enteroCorto = 32123;
signed short int enteroCortoConSigno = 32123;
unsigned short int enteroCortoSinSigno = 32123;
long int enteroLargo = 1234567890;
signed long int enteroLargoConSigno = 1234567890;
unsigned long int enteroLargoSinSigno = 4234567890;
int octal = 0123456;
int hexadecimal = 0x123A;
float real = 1234567.1f;
double doble = 1234567890123456.1;
long double dobleLargo = 12345678901234567890.1;

15. Variables
clrscr();
printf("n Caracter: %c", caracter);
printf("n Caracter Con Signo: %c", caracterConSigno);
printf("n Caracter Sin Signo: %c", caracterSinSigno);
printf("n Cadena: %s", cadena);
printf("nn Entero: %d", entero);
printf("n Entero con signo: %d", enteroConSigno);
printf("n Entero sin signo: %u", enteroSinSigno);
printf("nn Entero corto: %d", enteroCorto);
printf("nEntero corto c/signo: %d", enteroCortoConSigno);
printf("nEntero corto s/ signo: %d", enteroCortoSinSigno);
printf("nn Entero largo: %ld", enteroLargo);
printf("nEntero largo c/signo:%ld",enteroLargoConSigno);
printf("nEntero largo s/signo: %lu", enteroLargoSinSigno);
printf("nn Octal: %o", octal);
printf("n Hexadecimal: %X", hexadecimal);
printf("nn Real: %f", real);
printf("n Doble: %lf", doble);
printf("n Doble largo: %.20LGnn", dobleLargo);
getch();
} //main

16. Clasificación de variables
• Las variables pueden
clasificarse dependiendo de su
alcance o el lugar donde se
declaran en:
– Globales
– Locales
– Parámetros de funciones (los
parámetros se verán más
adelante)

17. Variables Globales
• Las variables globales se declaran
en cualquier lugar fuera de las
funciones.
• Se conocen a lo largo de todo el
programa, por lo que se pueden usar
en cualquier lugar.
• Mantienen su valor durante toda la
ejecución del programa.
#include <stdio.h>
#include <conio.h>
int cuenta;
void func1(); //prototipos de
void func2(); //funciones
void main(){
cuenta = 100;
func1();
getch();
}

18. Variables globales
void func1(){
int temp;
temp = cuenta;
func2();
printf(“cuenta = %d”, cuenta);
//imprime 100
}
void func2(){
int cuenta;
for (cuenta = 1; cuenta < 10;
cuenta++) {
putchar(‘*’);
}
}

19. Variables locales
• Las variables locales se declaran
dentro de las funciones.
• También pueden llamarse
automáticas ya que pueden usar el
modificador auto.
• Sólo pueden emplearse dentro del
bloque donde se declaran.
• Un bloque empieza con una llave
abierta { y terminan al cerrar la llave }.
• Se declaran antes de cualquier
sentencia del bloque.
• Se crean al iniciar la ejecución del
bloque y se destruye al salir de él.
void func1() {
int x;
x = 10;
}

20. Modificadores de acceso
• Existen dos modificadores de
acceso a las variables:
• El modificador const evita que el
valor de una variable pueda
modificarse.
const int a = 10;
• El modificador volatil define que
el valor de una variable puede
modificarse por medios externos
al programa, por ejemplo, si se
asume que Ox30 es el valor de un
puerto que cambia por una
condición externa
exclusivamente, se puede indicar:
volatil unsigned char *puerto = Ox30;

21. Modificadores de
almacenamiento
• Los modificadores de almace-
namiento permiten especificar
cómo almacenar las variables.
• Debe preceder al resto de la
declaración.
• Los modificadores de
almacenamiento son:
extern
static
register
auto
• El modificar auto define variables
locales.

22. Modificador extern
• El modificador extern permite
especificar variables globales
declaradas en programas
compilados separadamente.
Archivo 1
int x, y;
void main(){
...
}
Archivo 2
extern int x, y;
func22() {
x = y / 10;
}

23. Modificador static
• El modificador static permite
especificar variables perma-
nentes.
• Una variable estática local es
una variable local que retiene su
valor entre llamadas de funciones.
Por ejemplo una variable que
genera una serie de números
basadas en el valor anterior.
int serie(){
static int eNum = 100;
eNum = eNum + 1;
return eNum;
}

24. Variable estática global
• Una variable estática global es
una variable conocida únicamente
en el archivo en el que se declara.
Otros archivos no la pueden
alterar, está libre de efectos
secundarios
static int eNum;
void iniciarSerie(int eSemilla);
void serie();
int serie(){
eNum = eNum + 1;
return eNum;
}
void iniciarSerie(int eSemilla) {
eNum = eSemilla;
}

25. Modificador register
• El modificador register permite
especificar una variable que se
almacena en los registros de CPU
en vez de la memoria, lo que
hace que su acceso sea más
rápido.
• Este modificador sólo se puede
usar en variables locales.
• Al no estar guardada en memoria,
esta variable no tiene dirección.
• Son muy usadas para el control
de ciclos.
potencia () {
register int temp;
...
}

26. Modificadores
• En resumen tenemos tres tipos de
modificadores:
– De tipo
• signed
• unsigned
• short
• long
– De acceso
• const
• volatil
– De almacenamiento
• extern
• static
• register
• auto

27. Operadores
• El lenguaje C es rico en
operadores.
• Los tipos de operadores en C
son:
– Aritméticos
– Lógicos
– Relacionales
– De asignación
– Asociativos
– A nivel de bits
– Otros operadores

28. Operadores Aritméticos
• Los operadores +, -, * y /
funcionan en C igual que en la
mayoría de los lenguajes de
programación.
• Al aplicar / sobre enteros, se
trunca el resultado.
• El operador % obtiene el residuo
de la división.
• El menos monario (-) multiplica su
único operando por -1.
• El operador de autoincremento (+
+) adiciona 1 a su operando.
• El operador de autodecremento
(--) disminuye 1 a su operando.
• Ambos se pueden usar antes o
después del operando.

29. Operadores Lógicos
• Los operadores lógicos son:
&& - and
|| - or
! - not
• No existe el operador XOR

30. Operadores Relacionales
• Los operadores relacionales
son:
> - mayor
>= - mayor o igual
< - menor
<= - menor o igual
== - igual
!= - diferente

31. Operadores de Asignación
• Los operadores de asignación
son:
= el resultado de la expresión
derecha se lo asigna a la
variable de la izquierda.
+= suma y asigna
-= resta y asigna
*= multiplica y asigna
/= divide y asigna
%= obtiene residuo y asigna
• Es posible hacer asignaciones
múltiples:
x = y = z = 0;

32. Operadores de Asociación
• Los paréntesis ( ) aumentan la
precedencia de los operadores.
x = (a + b) * c;
• Los corchetes [ ] permiten indexar
arreglos.
arreglo[3] = 5;
• Las llaves { } engloban un bloque
de código.
if (a< b) {
….
}

33. Operadores a Nivel de Bits
• Ya que C se diseñó para sustituir
a ensamblador debe permitir
hacer las operaciones que éste
realiza.
• Las operaciones a nivel de bits se
refieren a la comprobación,
asignación o desplazamiento de
los bits que componen un byte.
Operador Acción
& AND
| OR
^ XOR
~ NOT
<< Desplazamiento izquierda
>> Desplazamiento derecha

34. Otros Operadores
• C tiene otros operadores muy
específicos del lenguaje:
? (ternario)
<Exp1> ? <Exp2> : <Exp3>
x = 10;
y = x > 9 ? 100 : 200;
, (coma) encadena expresiones
x = (y = 3, y + 1);
& * de apuntadores
sizeof de tiempo de compilación
. -> de registros y uniones

35. Expresiones
• Las expresiones pueden incluir
cualquier combinación de
operadores.
• El orden de ejecución dependen
de la precedencia de los
operadores y generalmente los
operadores de la misma
precedencia se evalúan de
izquierda a derecha.
• El tipo de dato del resultado
depende de los tipos de datos de
las expresiones de la derecha.

36. Precedencia de
operadores
Mayor () [] ->
! ~ ++ -- * - & sizeof
* / %
+ -
<< >>
< <= > =>
== !=
&
^
|
&&
||
?
= += -= *= /=
Menor ,

37. Conversión de tipos
• Cuando una expresión mezcla
distintos tipos, se convierten a un
solo tipo.
• C realiza promoción de tipos,
donde todos los operandos se
convierten al tipo del operando
mayor.
• Se puede forzar la conversión a
un tipo usando moldes (casting)
• Esto normalmente se hace para
convertir tipos mayores a
menores.
(< tipo>) <expresión>

38. Funciones de Entrada
• En el lenguaje C, todas las
operaciones de E/S se realizan
mediante funciones descritas
en su biblioteca.
• Las funciones de entrada por
teclado más comunes son:
– getch()
– getche()
– getchar()
– gets()
– scanf()

39. getchar()
• getchar() es la función más
sencilla de entrada que lee un
caracter del teclado.
• Esta función espera hasta que se
pulsa una tecla y devuelve su
valor.
• Prototipos: int getchar(void);
#include <stdio.h>
#include <ctype.h>
void main(){
char caracter;
printf("Introducir texto (. = Terminar)n");
do {
caracter = getchar();
putchar(caracter);
} while (caracter != '.');
}

40. getchar()
• Algunas funciones alternativas a
getchar() más comunes son:
• getch() espera un valor del
teclado, lo devuelve pero no lo
muestra.
• getche() espera un valor del
teclado, lo devuelve y lo muestra.
• Prototipos:
int getch(void);
int getche(void);

41. gets()
• Esta función lee una cadena de
teclado y la almacena en la
dirección apuntada por el
argumento de tipo apuntador a un
arreglo de caracteres.
• Los caracteres se almacenan
hasta ingresar <Enter>.
• Prototipo: char *gets(char *cad);
#include <stdio.h>
#include <string.h>
void main(){
char cadena[80];
printf(“Introduzca una cadena:”);
gets(cadena);
printf(“La longitud de la cadena es %d”,
strlen(cadena));
}

42. scanf()
• scanf es una función de entrada de
propósito general. Puede leer todos
los tipos de datos.
• Es prácticamente la función inversa
de la función printf().
• Prototipo:
int scanf(“cadena de control”, &var);
• La cadena de control determina
cómo se leen los valores de las
variables.
#include <stdio.h>
#include <string.h>
void main(){
int numero;
printf(“Introduzca un número:”);
scanf(“%d”, &numero);
printf(“El número es %d”, numero);
}

43. Ejercicios
1. Crear un programa que declare dos
variables enteras y realice las cuatro
operaciones aritméticas con ellas.
2. Escribir un programa que muestre si
el resultado de la suma de dos
variables es mayor, menor o igual a
0.
3. Crear un programa que asigne a
una variable el resultado de la
siguiente expresión y lo muestre:
35 + 12 / 3 * 37 – 18 / 6
4. Escribir un programa que lea el valor
de 2 variables reales y asigne el
resultado de su división a una
variable entera.
5. Definir un programa que declare las
constantes falso y verdadero y
muestre sus valores.

44. Ejercicios
6. Escribir un programa que genere y
muestre el siguiente número de
una serie que inicia en 350.
7. Crear dos archivos separados y
probar el manejo del modificador
extern.
8. Definir un programa que declare
una variable entera con valor inicial
3, le agregue uno, lo muestre, le
reste 3 y lo muestre nuevamente
(usar los operadores ++ y -=).