Apunte Lenguaje C Resumido1

Lenguaje C
[Sintaxis y Semántica del lenguaje]
Ing. Alvaro Hergenreder Universidad Tecnológica Nacional – FRRO

Ingeniería en Sistemas de Información
Material extraído del apunte de “Lenguaje de Programación C”

– LIC Susana Martín
LIC Mónica JägerSGDB
El lenguaje C: Origen y Versiones
 Origen
El Lenguaje C fue creado en 1972 por Dennis Ritchie en un PDP-11 de Digital Equipment
Corporation bajo el sistema operativo UNIX. Fue el resultado final de un proyecto que comenzó
con un lenguaje llamado BCPL (Basic Combined Programming Language) diseñado por Martin
Richards en 1967, que a su vez estaba influenciado por el lenguaje CPL (Combined
Programming Language) desarrollado por las universidades de Cambridge y Londres. A partir
del BCPL, Ken Thompson creó un lenguaje llamado B, que fue el que condujo al desarrollo del
Lenguaje C.
En 1978 se editó la primera publicación de C por Kernighan y Ritchie.
Con la popularidad de las microcomputadoras se crearon muchas implementaciones de C.
 Versiones
 C
Durante muchos años el estándar para C fue el que se suministraba con la versión 5 de
UNIX. Pero con la creciente popularidad de los microordenadores aparecieron muchas
implementaciones diferentes (Quick C de Microsoft, Turbo C de Borland, etc.) que, aunque
eran altamente compatibles entre sí, tenían algunas diferencias. Por ello, en 1983 se creó
un comité que elaboró el documento que define el estándar ANSI de C.
 C ++
Una evolución de C, el lenguaje C++ (C con clases) que contiene entre otras, todas las
características de ANSI C. Los compiladores más empleados son Visual C++ de Microsoft,
Builder C++ de Imprise (Antigua Borland), C++ bajo Unix y Linux.
 C# (.net)
En el verano del 2000, Microsoft patentó una nueva versión de C++, que es C#, una
evolución del C++ estándar, con propiedades de Java y diseñado para aplicaciones en
línea.
Características del lenguaje
 C se clasifica como un lenguaje de nivel medio porque combina elementos de

lenguajes de alto nivel con la funcionalidad del lenguaje ensamblador.
 El código C es muy portable
 C es un lenguaje estructurado. El principal componente estructural de C es la

función; en C las funciones permiten definir las tareas de un programa y
codificarlas por separado, haciendo que los programas sean modulares.
 Tiene la ventaja de usar compilador en lugar de intérprete, es más rápido.
3
Características del lenguaje
 En C las mayúsculas y las minúsculas son diferentes.
 Las 32 palabras claves del standard ANSI son:
auto break case char const continue default do double else enum extern
float for goto if int long register return short signed sizeof static struct
switch typedef union unsigned void volatile while
 Todos los programas en C consisten en una o más funciones (estándares o

creadas). La única función que debe estar inevitablemente presente es la
denominada main().
Forma de un programa en C
Ejemplo de un programa en C
#include <stdio.h> (1)

/* muestra la suma de 2 números */ (2)
main ( ) (3)
{ (4)
int a, b, c; (5)
a = 10; (6)
b = 15;
c = a + b; (7)
printf (“la suma es c = %d\n”, c); (8)
}
(1) indica al compilador que debe incluir información acerca de la biblioteca estándar de E/S
(Standard Input-Output).
(2) cualquier carácter entre /* y */ es ignorado por el compilador y es tratado como un
comentario, estos pueden aparecer en cualquier lugar dónde se pueda colocar un espacio en
blanco, un tabulador (\t) o un enter (\n).- Para comentar una sola línea  //
Nota: los comentarios no se pueden anidar, por ej., este fragmento de código produciría un error
de compilación.
/*
if (x < 10) printf (“todo bien”); /* muestra estado */
else printf (“error”);
*/

main ( ) (3)
{ (4)
int a, b, c; (5)
a = 10; (6)
b = 15;
c = a + b; (7)
}
(3) define la función main( ), que es la función principal del programa, está seguida por un
par de paréntesis vacíos, lo que significa que no hay transferencia de argumentos. En otras
funciones entre los paréntesis se coloca la lista de argumentos que transfieren valores entre la
función que llama y la función llamada.-
(4) las proposiciones de main() o de cualquier otra función van entre llaves { }
(5) en C se deben declarar todas las variables antes de su uso, al principio de la función y antes
de cualquier proposición ejecutable. Una declaración está formada por un nombre de tipo y una
lista de variables.-

main ( ) (3)
{ (4)
int a, b, c; (5)
a = 10; (6)
b = 15;
c = a + b; (7)
}
(6) proposición de asignación, inicializa las variables. Cada proposición individual termina con “;”
(7) se asigna a la variable c el resultado de una operación aritmética.-
(8) main llama a la función de biblioteca printf con el argumento:

(“la suma es c = %d\n”, c)
\n representa el carácter nueva línea y hace avanzar la impresión al margen izquierdo de la
siguiente línea, printf no proporciona una nueva línea automáticamente (\n representa un solo
carácter). Una secuencia de caracteres entre comillas dobles se llama cadena de caracteres o
constante de cadena.-
Algunas consideraciones al escribir un programa
 Utilizar comentarios
 Escoger nombres de variables con significado
 Utilizar líneas en blanco para separar las distintas secciones de la función
 Espacios en blanco entre los operadores
 Utilizar sangría
 Mantener una línea con el posicionamiento de las llaves
 Tener en cuenta que x y X son dos caracteres distintos, que la mayor parte del
programa se escribe en minúscula de imprenta y se usa la mayúscula de imprenta
para escribir nombres de constantes
El lenguaje C averigua dónde termina una sentencia y comienza la siguiente por

medio de los puntos y coma introducidos, de todas maneras el programa quedará
mucho más legible si se lo escribe teniendo en cuenta las pautas antes
mencionadas, o sea:
Variables, Constantes, Operadores y Expresiones
DIRECTIVAS DEL PRE-PROCESADOR
#include
La directiva del preprocesador #include hace que el compilador incluya otro archivo fuente en el que
tiene la directiva #include. El nombre del archivo fuente que se incluirá se debe encerrar entre comillas
dobles “ … ” o entre los signos menor que y mayor que < … >.
Por ejemplo:
#include <stdio.h>
#define
La directiva #define se usa para definir constantes simbólicas o realizar sustitución de macros.
Su formato es el siguiente:
#define <nombre de macro> <nombre de reemplazo>
Por ejemplo:
#define CANT_ALUMNOS 100
#define FALSO 0
#define VERDADERO !FALSO
El preprocesador también permite configurar el lenguaje. Por ejemplo, se pueden cambiar los
delimitadores de bloque de código { ... } por otros delimitadores inventados por el programador
como inicio ... fin haciendo:

#define inicio {
#define fin }
#define
La directiva #define tiene otra poderosa característica: el nombre de macro puede tener
argumentos.
Cada vez que el compilador encuentra el nombre de macro, los argumentos reales encontrados
en el programa reemplazan los argumentos asociados con el nombre de la macro.
Por ejemplo:
#define MIN(a, b) (a < b) ? a : b
main( )
{
int x=10, y=20;
printf("EL mínimo es %d\n", MIN(x, y));
}
printf("El mínimo es %d\n", (x < y) ? x : y);

#define
Como se puede observar donde se coloque MIN, el texto será reemplazado por la definición
apropiada. Por lo tanto, si en el código se hubiera puesto algo como:
x = MIN(q+r, s+t);
después del preprocesamiento, el código podría verse de la siguiente forma:
x = (q+r < s+t) ? q+r : s+t;
Nota: El uso de la sustitución de macros en lugar de funciones reales tiene un beneficio

importante: incrementa la velocidad del código porque no se gasta tiempo en llamar a una función.
#undef
Se usa #undef para quitar una definición de nombre de macro que se haya definido previamente.
El formato general es:
#undef <nombre de macro>
Por ejemplo:
#define LONG 100

#define ANCHO 100
char array[LONG][ANCHO];
#undef LONG
#undef ANCHO
/* en este momento LONG y ANCHO están indefinidas*/

NOMBRES DE IDENTIFICADORES
Se conocen como identificadores los nombres usados para referenciar las variables, las
funciones, las etiquetas y otros objetos definidos por el usuario.
Las reglas a tener en cuenta para los nombres de los identificadores son:
• Puede estar formado por letras mayúsculas, letras minúsculas, dígitos y el carácter
de subrayado ‘_’, este último es útil para mejorar la legibilidad de nombres de identificadores
largos.
• El primer carácter no puede ser un dígito, y tampoco conviene que sea el carácter de
subrayado ‘_’, puesto que las rutinas de biblioteca con frecuencia usan tales nombres. Por lo
tanto conviene que el primer carácter sea una letra.
• Su longitud puede variar entre 1 y 32 caracteres. En general son significativos los primeros
31 caracteres, esto difiere según el compilador, aunque en general para nombres de funciones
y variables externas, el estándar garantiza distinguir un máximo de 6 u 8 caracteres.
• No debe coincidir con ninguna palabra clave.
• Se acostumbra usar minúsculas para nombres de variables y mayúsculas para nombres

de constantes simbólicas.
NOMBRES DE IDENTIFICADORES
Se conocen como identificadores los nombres usados para referenciar las variables, las
funciones, las etiquetas y otros objetos definidos por el usuario.
Los siguientes son ejemplos de nombres de identificadores:

TIPOS DE DATOS
En C las variables se corresponden con una posición de memoria y poseen: un nombre que
las identifica y permite así, referirse al contenido de una dirección particular de memoria y un
tipo que las describe, para interpretar el valor contenido en esa dirección.
Existen cuatro tipos de datos básicos en C:
El C proporciona además un tipo de dato de propósito especial cuyo significado es “sin valor”
y cuya palabra clave es void. Desde el punto de vista sintáctico este tipo se comporta como un
tipo fundamental, no obstante, se lo puede utilizar sólo como parte de un tipo derivado. No existen
variables de tipo void. Sirve para especificar que una función no devuelve ningún valor, o bien,
para declarar explícitamente una función sin parámetros.
Modificadores de Tipos
Los tipos de datos básicos pueden estar precedidos por modificadores que alteran el significado
del tipo base para que se ajuste más precisamente a cada necesidad. Los modificadores de tipo
que existen en C son:
short ............................ reduce a la mitad la longitud de almacenamiento
long .............................. duplica la longitud de almacenamiento
unsigned ...................... número sin signo (siempre positivo)

signed .......................... número con signo (positivo o negativo)
Para elegir el tipo de dato adecuado es necesario conocer muy bien la arquitectura de la máquina; en
general los conceptos fundamentales a tener en cuenta respecto al tamaño son:
tamaño char < tamaño short int < = tamaño int <= tamaño long int
tamaño float < tamaño double < tamaño long double
El siguiente cuadro muestra todas las combinaciones que se ajustan al estándar ANSI junto con sus
rangos y longitudes, suponiendo palabras de 16 bits:
DECLARACIÓN DE VARIABLES
En C todas las variables deben declararse antes de su uso, generalmente al principio de la
función y antes de cualquier proposición ejecutable.
tipo lista_de_variables
dónde, tipo debe ser un tipo de datos válido de C y la lista_de_variables puede consistir en
uno omás nombres de variables separados por comas.
Ejemplos:
int i, j, k;
char a, b, c;
double prom1;
Nota: Existen tres sitios básicos donde se pueden declarar variables: dentro de las
funciones, en la definición de parámetros de funciones y fuera de todas las funciones. Estas
variables son respectivamente, las variables locales, los parámetros formales y las variables
globales.
INICIALIZACIÓN DE VARIABLES
Inicializar significa especificar un valor de comienzo. Para aquellas que no se inicialicen
se debe asumir que contienen valores desconocidos, “basura”, porque si bien hay algunos
compiladores que inicializan automáticamente a cero, no conviene tomarlo como algo seguro
(globales a 0, locales con basura). La inicialización de cualquier variable se realiza mediante la
asignación de un valor constante que puede realizarse en la sentencia de declaración o en una
sentencia por separado.
El formato general de la inicialización es:
tipo nombre_de_variable = constante;
o bien:
tipo nombre_de_variable;
nombre_de_variable = constante;
Ejemplos:
int cant = 97;

char c = ‘a’;
int x = 0, y = 0; o bien: int x, y; o bien: int x, y;
x = 0; x = y = 0;
y = 0;
VARIABLES LOCALES Y GLOBALES
Según el lugar dónde se declaran las variables se clasifican en distintos tipos, a saber:
Variables Locales, también llamadas privadas o automáticas:
• Se declaran dentro de una función o de un bloque de código.
• Sólo pueden ser referenciadas por sentencias que estén dentro de esa función o de ese
bloque de código, ya que fuera de los mismos no se las conoce.
• Sólo existen mientras se está ejecutando la función o el bloque de código en el que están
declaradas. Se crea cuando se llama a dicha función o se entra a dicho bloque y se
destruye cuando se sale de ellos, por lo tanto no conservan los valores entre llamadas.
• Su nombre puede ser usado por otras funciones.

EJEMPLO  Variables Locales

A. La variable entera x se define dos veces, una vez en func1( ) y otra en func2( ), pero una
no tiene relación con la otra, ya que cada x sólo es conocida en la propia función en la que
fue declarada.
func1( )
{
int x;
x = 10;
.
.
}
func2( )
{
int x;
x = 35;
·
·
}
EJEMPLO  Variables Locales

B. La variable s se define dentro de un bloque de código, fuera de él la variable s es
desconocida
{
int t;
if (t > 0) {
char s; /* esta existe únicamente en este bloque */
}
/* aquí no se conoce a la variable s */
}
VARIABLES LOCALES Y GLOBALES
Según el lugar dónde se declaran las variables se clasifican en distintos tipos, a saber:
Variables Globales:
 Se declaran fuera de todas las funciones.
 Son conocidas a lo largo de todo el programa y por lo tanto se pueden usar en cualquier
parte del código.
 Mantienen su valor durante toda la ejecución del programa.
 Si una variable local y una variable global tienen el mismo nombre, toda referencia a ese
nombre de variable dentro de la función dónde se ha declarado la variable local se refiere a
ésta y no tiene efecto sobre la variable global.
EJEMPLO  Variables Globales
#include <stdio.h>
void f1(void );
void f2(void );
int var; /* var es global */
main( ) {
var = 10;
f1( ); }
void f1( ) {
int h;
h = var;
f2( );
printf (“var es %d\n”, var); /* imprimirá 10 */ }
void f2( ) {
int var; /* var es local */
var = 34;
x = var * 2;
printf (“x = %d\n”, x); /* imprimirá 68 */ }
ALGUNAS CONSIDERACIONES SOBRE EL USO DE VARIABLES GLOBALES
Las variables globales son muy útiles cuando muchas funciones del programa usan los mismos
datos, sin embargo, se debe evitar el uso innecesario de variables globales, entre otras, por algunas
de las siguientes razones:
 las variables globales usan memoria todo el tiempo que el programa está en ejecución, no
sólo cuando se necesitan (importante si la memoria es un recurso escaso).
 usar una variable global dónde podría ir una local hace a la función menos general, ya que
depende de algo que debe estar definido fuera de ella.
 usar muchas variables globales puede acarrear problemas de programación (especialmente

en programas grandes) cuando se modifica el valor en algún lugar del programa.
ESPECIFICADORES DE CLASE DE ALMACENAMIENTO
Indican al compilador cómo debe almacenar la variable que le sigue, precede al resto de la
declaración de la variable, y su forma general es:
especificador_de_almacenamiento tipo nombre_de_variable
Existen 4 tipos, a saber:
 auto: sirve para declarar variables locales, por lo general no se usa ya que se
asume por omisión.
 extern: la forma de hacer conocer a todos los archivos (caso compilación por separado)
las variables globales requeridas por el programa es declarando la totalidad de las
mismas en un archivo, y usar declaraciones extern en los otros. Este especificador
indica al compilador que los nombres y tipos de variables que siguen ya han sido
declarados en otra parte y por lo tanto no crea un nuevo almacenamiento para ellas.
EJEMPLO  extern
 static dentro de su propia función o archivo las variables static son permanentes. Difieren de
las variables globales en que no son conocidas fuera de su función o archivo, aunque mantienen
sus valores entre llamadas. Tienen efectos diferentes siendo locales que globales.
* Variables estáticas locales: el compilador crea un almacenamiento permanente para ellas.

• sólo es conocida en el bloque en que está declarada.
• es una variable local que mantiene su valor entre llamadas.
* Variables estáticas globales: sólo es conocida en el archivo en el que se declara, o sea, que
las rutinas de otros archivos no la reconocerán ni alterarán su contenido directamente.
 register: sólo se aplica a variables de tipo int y char y sólo a variables locales y parámetros
formales. Se mantiene el valor de la variable así declarada de forma que se permita un acceso más
rápido a la misma. Por lo general se guarda en CPU en lugar de hacerlo en memoria, por lo tanto
no se requiere acceso a memoria para determinar o modificar su valor.
CONSTANTES
C permite declarar constantes. Declarar una constante es parecido a declarar una variable,
excepto que el valor no puede ser cambiado.
La palabra clave const se usa para declarar una constante, como se muestra a continuación:
const int a = 1;
Notas:
 Se puede usar const antes o después del tipo.
 Es usual inicializar una constante con un valor, ya que no puede ser cambiada de alguna otra
forma.
La directiva del preprocesador #define es un método más flexible para definir constantes en un
programa, a las constantes así definidas se las denomina constantes simbólicas.
La directiva #define indica al preprocesador que debe sustituir, en el código fuente del programa,
todas las ocurrencias del <nombre_de_la_constante> por la <secuencia_de_caracteres>, antes de la
compilación. #define <constante> <secuencia_de_caracteres>
Frecuentemente se ve la declaración const en los parámetros de una función.

CONSTANTES
Constantes Numéricas
Pueden ser enteras (contienen un número entero) o de coma flotante (contienen un número
en base 10 que contiene un punto decimal o un exponente o ambos).
Ejemplos de Constantes:
Enteras -> 5280 32767 0 -743
Enteras de Coma Flotante -> 0.2 1. 2e-8 12.3e-5
Constantes No Numéricas
- de carácter: es un carácter delimitado entre comillas simples. El valor de una constante de carácter
es el número correspondiente al código del procesador (generalmente el ASCII).
Hay algunos caracteres no imprimibles que se representan como constantes de carácter mediante una
secuencia de escape que aparece como 2 caracteres pero en realidad son sólo uno (‘\n’, ‘\0’, etc.).
- cadena de caracteres: es una secuencia de ninguno, uno o más caracteres encerrada entre comillas
dobles. El compilador ubica un carácter nulo (‘\0’) al final de cada cadena para que los programas
puedan encontrar el final. Técnicamente una cadena de caracteres es un vector cuyos elementos son
caracteres.
NOTA: no es lo mismo ‘x’ que “x”; en el primer caso se trata de un único carácter, x, cuyo valor
es el que le corresponde en el conjunto de caracteres del procesador, y en el segundo caso se trata de
una cadena que tiene 2 caracteres, una x y un \0.
CÓDIGOS DE BARRA INVERTIDA
Son constantes de carácter que se utilizan

para representar caracteres que son
imposibles de introducir desde el teclado.
Se utilizan igual que las demás constantes
de carácter, o sea, pueden asignarse a una
variable o bien utilizarlas dentro de una
cadena de caracteres; (c = ‘\t’, “error\n”).
El siguiente cuadro muestra la lista de

códigos de barra invertida:
OPERADORES
OPERADOR DE ASIGNACIÓN ( = )
Provoca el almacenamiento de un valor en una variable. El formato general resulta:
variable operador valor
dónde valor puede ser una constante, otra variable (ya inicializada), o una expresión.
Como en otros lenguajes la operación de asignación es una sentencia, pero a diferencia de
muchos de ellos se trata, en C, de un operador muy potente.
Variaciones en la sentencia de asignación:

 En la inicialización puede asignársele el mismo valor a distintas variables, no así en la
declaración, la forma sería:
variable1 = variable2 = variable3 = valor

OPERADORES
El C define muchos más operadores que otros lenguajes. Combinados con distintos
operandos pueden generar expresiones que siguen las reglas del álgebra, pudiendo los
paréntesis alterar el orden de evaluación que le correspondería por la prioridad propia de
cada operador.
ARITMÉTICOS
Suma ................ +
Resta ................ –
Multiplicación .. *
División ............ /
Módulo ............. % (resto de la división entera-no puede aplicarse a operandos float o double)
Incremento…… ++
Decremento….. --
OPERADORES
Incremento y decremento
C contiene dos operadores muy útiles que no existen generalmente en otros lenguajes.
Son el incremento y el decremento, ++ y --.
++ ............. aumenta en 1 el valor del operando
-- ............ disminuye en 1 el valor del operando
El formato de la expresión que resulta de aplicar el operador incremento o decremento es:
operador variable
variable operador
dónde operador actúa distinto según su ubicación respecto a la variable:
 operador variable (prefijo)

1º se modifica en 1 el valor de la variable
2º la variable usa su nuevo valor
 variable operador (sufijo)
1º la variable usa su valor
2º se modifica en 1 el valor de la variable
OPERADORES
Incremento y decremento
C contiene dos operadores muy útiles que no existen generalmente en otros lenguajes.
Son el incremento y el decremento, ++ y --.
++ ............. aumenta en 1 el valor del operando
-- ............ disminuye en 1 el valor del operando
Ejemplos:
++n  equivale a  n=n+1
z = b++  equivale a  z=b y luego b=b+1
x = --r  equivale a  r=r–1 y luego x=r

OPERADORES
RELACIONALES
Mayor ................ >
Menor ................ <
Mayor o igual ..... >=
Menor o igual ..... <=
Igual ................... = =
Distinto .............. !=
Con éstos se pueden generar expresiones relacionales cuyos operandos pueden ser constantes,
variables u otro tipo de expresiones.
 Cuando en una expresión se combinan distintos tipos de operadores, la prioridad en la
evaluación es:
1º > < >= <=
2º = = !=
 Cuando en una expresión se combinan operadores de igual prioridad, la evaluación es de
izquierda a derecha. Los paréntesis alteran este orden de evaluación.
 El resultado de una operación relacional es un número entero: 1 para verdadero y 0 para falso.
OPERADORES
LÓGICOS
Conjunción (y)................. &&
Opción (o) ....................... ||
Negación (no) ................. !
Con éstos se pueden generar expresiones lógicas cuyos operandos pueden ser constantes,
variables u otro tipo de expresiones.
 Cuando en una expresión se combinan distintos tipos de operadores, la prioridad en la

evaluación es:
1º !
2º &&
3º ||
 Cuando en una expresión se combinan operadores de igual prioridad, la evaluación es de
izquierda a derecha. Los paréntesis alteran este orden de evaluación.
 El resultado de una operación lógica es un número entero: 1 para verdadero y 0 para falso .
OPERADORES
LA COMA COMO OPERADOR ( , )
Como operador la coma encadena varias expresiones, su función es la de indicarle al compilador

la sucesión de cosas que debe hacer (hacer esto y esto y esto).
Cuando se usa en la parte derecha de una sentencia de asignación, el valor asignado es el valor de
la última expresión de la lista separada por comas.
Ejemplo:
x = (y = 3, y + 1); ===> x = 4
y = 10;
x = (y = y – 5, 25 / y); ===> x = 5
los ( ) son necesario por la precedencia: = > ,
OPERADORES
OPERADOR CONDICIONAL ( ?: )
C contiene un operador muy potente y conveniente que puede usarse para sustituir ciertas
sentencias de la forma if ... else. El operador ternario ?: toma la forma general:
Exp1 ? Exp2 : Exp3;
El operador ?: actúa de la siguiente manera: evalúa Exp1, si es cierta evalúa Exp2 y toma
ese valor para la expresión. Si Exp1 es falsa evalúa Exp3 tomando su valor para la expresión.
Ejemplo:
y = x > 9 ? 100 : 200
en este caso si x es mayor que 9, a y se le asigna el valor 100, de lo contrario a y se le

asigna el valor 200.
EXPRESIONES Y SENTENCIAS
Expresión
Representa una unidad de datos simple, tal como un número o un carácter.
La expresión puede consistir en una entidad simple, como una constante, una variable, un
elemento de un arreglo o una referencia a una función. También puede consistir en alguna
combinación de tales identidades interconectadas por uno o más operadores.
Por ejemplo:
a+b x=y c=a+b x==y
Sentencia
Consiste en una expresión seguida de un punto y coma (;) y hace que la computadora lleve a
cabo alguna acción. La ejecución de la sentencia de expresión hace que se evalúe la
expresión. Algunos ejemplos de sentencias son:
a = 3; ++ i; c = a + b; suma += 10;
CONVERSIÓN DE TIPOS DE DATOS
Conversión Automática o Implícita

Hay que diferenciar entre el tipo de dato del resultado de una expresión (regla nº 1) y el tipo de
dato con que ese resultado se almacena en la variable (regla nº 2).
Regla Nº 1: en una expresión aritmética dónde se vinculan por lo menos 2 operandos, si estos
son de distinto tipo, el compilador C, previo a la resolución de la operación igualará los tipos de
datos convirtiéndolos automáticamente según una escala de dominio de tipos que podríamos
expresar como: char ---> int ---> float ---> double
Regla Nº 2: en una asignación, independientemente de los tipos de datos que intervienen se

almacenará el resultado de la expresión convirtiéndose automáticamente al tipo de la variable de
asignación.
Expresando las asignaciones por su tipo podríamos resumir:
int = char .......... . se almacena el código ASCII del carácter.
int = float ........... se almacena como entero truncando los decimales.
float = double ..... se almacena en simple precisión redondeando los decimales.
float = int ........... se almacena el valor entero con parte decimal 0.
float = char ......... se almacena el código ASCII del carácter con su parte decimal 0.
char = float ......... se almacena el carácter correspondiente truncando los decimales.
CONVERSIÓN DE TIPOS DE DATOS
Conversión Forzada o Explícita

Si algún operando de una expresión debe ser usado momentáneamente con otro tipo, distinto al
con el que fue declarado o más allá del que adquirió automáticamente de acuerdo con las reglas
anteriores, es posible provocar esa conversión. El operando será afectado por el nuevo tipo de
dato de la siguiente forma:
(nuevo tipo de dato) operando
TABLA GENERAL DE PRECEDENCIAS

Mayor ( ) [ ] ->
! - ++ -- (tipo) * & sizeof
*/%
+-
< <= > >=
= = !=
&&
||
?:
= += -= *= /= %=
Menor ,
FUNCIONES DE ENTRADA Y SALIDA
<stdio.h>
FUNCIONES DE E/S CON FORMATO
FUNCIÓN printf( )
Es una función de salida por pantalla con formato, escribe datos en la misma con un formato
determinado. Esta función puede operar sobre cualquiera de los tipos de datos existentes,
incluyendo caracteres, cadenas y números. El formato de llamada a esta función es:
printf ( “cadena de control”, arg1, arg2, arg3,.......);
La cadena de control es un conjunto de caracteres entrecomillados que contiene dos tipos

de elementos:
 caracteres ordinarios que desean imprimirse y que se mostrarán por pantalla tal cual.
 especificadores de conversión, cada uno de los cuales causa la conversión e impresión
de cada uno de los argumentos de la lista que aparecen a continuación de la cadena de
control (arg1, arg2, arg3, etc.).
<stdio.h>
FUNCIÓN printf( )
printf ( “cadena de control”, arg1, arg2, arg3,.......);
La lista de argumentos (arg1, arg2, etc.) está formada por constantes, expresiones o variables
cuyos valores se desean imprimir.
Habrá un especificador de conversión por cada uno de los argumentos de la lista, si no hay
suficientes o no son del tipo correcto se producen resultados confusos. La sintaxis es la
siguiente:
 comienza con el carácter %
 termina con un carácter de conversión, que es una letra que indica con que forma
se imprimirán los argumentos de la lista. Si el carácter después del % no es una
especificación de conversión válida, el comportamiento no está definido.
<stdio.h>

Los especificadores de conversión válidos son:
<stdio.h>
FUNCIÓN scanf( )
Esta función se comporta como la inversa de printf( ), puede leer todos los tipos de datos
que suministra el compilador y convierte los números automáticamente al formato interno
apropiado.
El formato de llamada a esta función es:
scanf(“cadena de control”, lista de argumentos);
La lista de argumentos (arg1, arg2, etc.) está formada por punteros a variables que indican
dónde deberá almacenarse la entrada correspondientemente convertida. Las reglas a seguir
son:
 Si desea leer un valor perteneciente a cualquiera de los tipos básicos, coloque
el nombre de la variable precedido por un &.
 Si lo que desea es leer una variable de tipo string (tira de caracteres), no anteponga el &.
<stdio.h>
FUNCIÓN scanf( )
scanf(“cadena de control”, lista de argumentos);
La cadena de control es un conjunto de caracteres entrecomillados que consta de 3 tipos de

elementos:
• Blancos o tabuladores, los cuales son ignorados.
• Especificadores de conversión, que indican a scanf( ) que tipo de dato se va a
leer a continuación.
• Caracteres ordinarios (no %), que se espera coincidan con el siguiente carácter
que no sea espacio en blanco del flujo de entrada.
<stdio.h>

Los especificadores de conversión válidos son:
<stdio.h>
FUNCIONES DE E/S SIN FORMATO

Las siguientes funciones están previstas de manera estándar en el ANSI C, biblioteca <stdio.h>:
•gets(arg)  lee una cadena de caracteres que se ingresa por teclado, asigna todos los caracteres
ingresados hasta que se pulse la tecla [enter]. Su único argumento es un arreglo
que contendrá a la cadena ingresada.
•puts(arg)  muestra una cadena en pantalla, tiene un argumento que puede ser una constante
de cadena, un arreglo o un puntero a un arreglo de char.
•getchar()  permite leer un carácter, no tiene argumentos.

Similares: getche() y getch(). No requieren de <enter>.
•putchar(arg)  muestra un carácter, tiene un argumento que puede ser una constante, variable
o función que devuelva un caracter.
Sentencias de Control
La mayoría de las sentencias de control de programa se basan en una prueba condicional que
determina la acción a seguir, o sea, especifican el orden en que se realiza el procesamiento.
Una prueba condicional produce un valor cierto o falso; en C cualquier valor distinto de cero
es cierto, incluyendo los números negativos. “El 0 (cero) es el único valor falso en C”.
PROPOSICIONES Y BLOQUES
 El ; es un terminador de sentencias o proposiciones, o sea, expresiones como x = 0 ó i++ ó

printf(...) cuando van seguidas de ; se convierten en proposiciones.
 Las llaves { } se emplean para agrupar declaraciones y proposiciones dentro de una proposición
compuesta o bloque, de modo que son sintácticamente equivalentes a una proposición sencilla. No
se coloca “;” después de la llave derecha que termina un bloque.
 En C una sentencia puede consistir en una única sentencia, un bloque de sentencias o nada (en
el caso de sentencias vacías).
Sentencias de Control Condicionales
El lenguaje C soporta dos tipos de sentencias condicionales: if (decisión simple) y
switch (decisión múltiple). Además, el operador condicional ?: es una alternativa para if
en ciertas situaciones.
SENTENCIA if
Se utiliza para expresar decisiones. La forma general de la sentencia if es:
if (num > 10)
if (expresión) sentencia_1; num = num * 2;
else sentencia_2; else
printf (“num = %d\n”, num);
dónde sentencia_1 y sentencia_2 pueden ser una sentencia simple o un bloque y la cláusula
else es opcional.
La forma general del if con bloques de sentencias es:
if (expresión) {
NOTA: En cualquiera de los dos casos la expresión se evalúa, si
secuencia de sentencias_1 es verdadera (cualquier valor != 0) sentencia_1 se ejecuta, si es
} falsa (= 0) y existe una parte else sentencia_2 se ejecuta. Recordar
else { que sólo se ejecuta el código asociado al if o al else, nunca ambos.
secuencia de sentencias_2
}
LA ESCALA if – else – if
Una construcción común en programación es la escala if-else-if. Su forma general es:
if (expresión_1)
sentencia_1;
else if (expresión_2)
sentencia_2;
else if (expresión_3)
sentencia_3;
·
·
else
sentencia_n;
Esta secuencia de proposiciones if es la forma más general de escribir una decisión múltiple. Las
expresiones se evalúan en orden de arriba abajo; tan pronto como se encuentra una expresión
cierta la sentencia asociada con ella se ejecuta y el resto de la escala se pasa por alto. Si ninguna
de las condiciones es verdadera se ejecuta el else final, o sea, el último else maneja el caso
“ninguno de los anteriores”; es decir, actúa como condición implícita, si todas las pruebas
condicionales fallan, se ejecuta la última sentencia else.
SENTENCIA switch
Si bien con la escala if-else-if se puede escribir una La forma general de la sentencia switch es:
decisión múltiple, este código puede ser bastante switch (variable) {
difícil de seguir. Por este motivo C incorpora una case constante_1:
sentencia de decisión de ramificación múltiple secuencia de sentencias;
denominada switch. Esta sentencia compara break;
sucesivamente una variable con una lista de case constante_2:
constantes enteras o de caracteres, cuando se secuencia de sentencias;
encuentra una correspondencia traslada el control break;
adecuadamente y se ejecuta una sentencia o bloque case constante_3:
de sentencias. secuencia de sentencias;
break;
Nota: la sentencia default se ejecuta si no se encuentra ·
ninguna correspondencia. La parte default es opcional, y ·
si no aparece, no se lleva a cabo ninguna acción al fallar ·
todas las pruebas. Cuando se encuentra una coincidencia, default:
se ejecuta la secuencia de sentencias asociadas con ese secuencia de sentencias;
case hasta encontrar la sentencia break o, en el caso de break;
default ( o el último case si no hay default), el final del }
switch con lo que sale de la estructura.
SENTENCIA switch switch (letra)
{
Resumiendo, cada caso empieza con un case y acaba donde hay case 'a':
un break. Si no ponemos break aunque haya un case el programa case 'e':
sigue hacia delante hasta encontrar un break o la llave de cierre case 'i':
del switch. Esto puede parecer una desventaja pero a veces es case 'o':
conveniente. Por ejemplo cuando dos case deben tener el mismo case 'u':
código, si no tuviéramos esta posibilidad tendríamos que escribir numvocal++;
dos veces el mismo código. break;
case ' ':
numesp++;
Puntos importantes a tener en cuenta sobre la sentencia switch: break;
 Con switch sólo se puede comprobar la igualdad, no se default:
pueden evaluar expresiones relacionales o lógicas, mientras numotras++;
que con if puede usarse cualquier operador relacional. break;
}
 Dentro de un switch no puede haber dos constantes case que
tengan los mismos valores. Por supuesto una sentencia switch
contenida en otra sentencia switch (switch anidados) puede
tener constantes case que sean iguales.
Sentencias de Iteración
Las sentencias de iteración o bucles son estructuras que permiten ejecutar partes del código
de forma repetida mientras se cumpla una condición. Esta condición puede ser simple o
compuesta de otras condiciones unidas por operadores lógicos.
LA SENTENCIA for La forma general de la sentencia for es:
Este bucle permite agrupar las tres acciones en un for (inicialización; condición; incremento)
sólo lugar: {
sentencia1;
 La inicialización se realiza una única vez al sentencia2;
principio del bucle, normalmente es una }
sentencia de asignación que se utiliza para
inicializar la variable de control del bucle.-
 La condición es una expresión relacional que determina cuando finaliza el bucle, se evalúa
antes de cada ejecución potencial del bucle, cuando la expresión es falsa, o sea, = 0, el bucle
finaliza. Esto permite que el for se ejecute de 0 a n veces, ya que si la condición es falsa
de entrada no se ejecuta nunca.-
 El incremento define como cambia la variable de control cada vez que se repite el bucle, se
ejecuta al final de cada iteración.-
LA SENTENCIA for
El flujo del bucle for transcurre de la siguiente forma:
Observaciones:
 Estas tres secciones principales deben estar separadas por ; (punto y coma). Cualquiera de la tres secciones
pueden omitirse, pero deben permanecer los ;. Se utiliza el operador ‘coma’ para permitir que en el bucle se
inicialicen y/o se incrementen dos o más variables de control.
for (a=1, b=100; a!=b; a++, b- -){
……….. }
 Se utilizan los operadores condicionales para permitir que en el bucle se evalúen dos o mas condiciones de
finalización
for (x = 0; x < 10 && z == 0; ++x){
………… }
El C permite generar bucles for sin cuerpo, generalmente se utilizan para generar retardos
for (t = 0; t <= valor; ++t);
 El C permite generar bucles infinitos, esta iteración infinita será interrumpida por una sentencia break.
for ( ; ; ) {
……… }
LA SENTENCIA while
while ( expresión) {
sentencia;
}
donde sentencia puede ser una sentencia única o un bloque de sentencias que se ejecutarán
repetidamente mientras el valor de expresión no sea 0. Esta sentencia debe incluir algo que altere
el valor de expresión (MUY IMPORTANTE PARA NO HACER UN BUCLE INFINITO).
Cuando el flujo del programa llega a esta instrucción, primero se revisa si la expresión es
verdadera para ejecutar la(s) sentencia(s), y después el ciclo while se repetirá mientras el valor de
expresión no sea cero.
Al igual que el for este bucle puede ejecutarse de 0 a n veces, si la expresión es falsa de entrada
el bucle no se ejecuta nunca.
LA SENTENCIA while
En el siguiente ejemplo se muestra una rutina de entrada desde el teclado, la cual se cicla
mientras no se pulse A:
main()
{
char carac;
carac = '\0';
while( carac != 'A') carac = getchar();
}
Nota: Antes de entrar al ciclo se inicializa la variable carac a nulo. Después pasa a la sentencia while
donde se comprueba si carac no es igual a 'A', como sea verdad entonces se ejecuta la sentencia del
bucle (carac = getchar();. La función getchar() lee el siguiente carácter del flujo estándar (teclado) y
lo devuelve, que en nuestro ejemplo es el carácter que haya sido tecleado. Una vez que se ha pulsado
una tecla, se asigna a carac y se comprueba la condición nuevamente. Después de pulsar A, la
condición llega a ser falsa porque carac es igual a A, con lo que el ciclo termina.
LA SENTENCIA while
De lo anterior, se tiene que tanto el ciclo for, como el ciclo while comprueban la
condición en lo alto del ciclo, por lo que el código dentro del ciclo no se ejecuta
siempre.
A continuación mostramos otro ejemplo que genera la siguiente salida en pantalla:
main()
{
int x=3;
while( x>0 )
{
printf("x = %d\n", x);
x--;
}
}
LA SENTENCIA do while
Al contrario de los ciclos for y while que comprueban la condición en lo alto del bucle, el
bucle do ... while la examina en la parte baja del mismo. Esta característica provoca que
un ciclo do ... while siempre se ejecute al menos una vez. La forma general del ciclo es:
do {
sentencia1;
sentencia2;
} while(expresión );
En el siguiente programa se usa un ciclo do ... while para leer números desde el teclado
hasta que uno de ellos es menor que o igual a 100:
main()
{
int num;
do
{
scanf("%d", &num);
} while (num>100 );
}
LA SENTENCIA do while
Otro uso común de la estructura do ... while es una rutina de selección en un menú, ya que
siempre se requiere que se ejecute al menos una vez.
do {
system("cls");
printf("\n1-Ingresar analisis\n2-Cargar resultado\n3-Emitir informe\n4-Salir\nOpcion: ");
scanf ("%c", &opc);
switch (opc) {
case '1':
system("cls");
cant_analisis = cargaAnalisis(p_analisis);
printf ("\n\nLa cantidad de analisis cargados son: %i\n\n", *cant_analisis);
break;
case '2':
system ("cls");
printf("Ingrese Id Paciente: ");
scanf("%s", idPaciente);
p_respuesta = cargaRes(p_analisis, idPaciente, idAnalisis, cant_analisis);
printf("\n\n %s \n\n",p_respuesta);
system("pause");
break;
case '3':
system ("cls");
printf("Ingrese Id Paciente: ");
scanf("%s", idPaciente);
p_listado = emision(p_analisis, idPaciente, cant_analisis, &cant_filas);
break;
}} while (opc!='4');
USO DE break, continue, exit y goto
 break: Como se comento uno de los usos de la sentencia break es terminar un case en la
sentencia switch. Otro uso es forzar la terminación inmediata de un ciclo, saltando la prueba
condicional del ciclo.
Cuando se encuentra la sentencia break en un bucle, la computadora termina inmediatamente
el ciclo y el control del programa pasa a la siguiente sentencia del ciclo.
Por ejemplo:
main()
{
int t;
for(t=0; t<100; t++)
{
printf("%d ", t);
if (t==10) break;
}
}
Este programa muestra en pantalla los números del 0 al 10, cuando alcanza el valor 10 se
cumple la condición de la sentencia if, se ejecuta la sentencia break y sale del ciclo.
 continue: La sentencia continue funciona de manera similar a la sentencia break. Sin

embargo, en vez de forzar la salida, continue fuerza la siguiente iteración, por lo que salta el
código que falta para llegar a probar la condición. Por ejemplo, el siguiente programa
visualizará sólo los números pares:
main()
{
int x;
for( x=0; x<100; x++)
{
if ((x%2)!=0)
continue;
printf("%d ",x);
}
}
Finalmente se considera el siguiente ejemplo donde se leen valores enteros y se procesan
de acuerdo a las siguientes condiciones:
a. Si el valor que se ha leído es negativo, se imprime mensaje de error y se abandona el ciclo.
b. Si el valor es mayor que 100, se ignora y se continúa leyendo
c. Si el valor es cero, se desea terminar el ciclo.
main()
{
int valor;
while( scanf("%d", &valor) == 1 && valor != 0)
{
if ( valor<0 )
{
printf ("Valor no valido\n");
break;
/* Salir del ciclo */
}
if ( valor >100)
{
printf ("Valor no valido\n");
continue;
/* Pasar al principio del ciclo nuevamente */
}
printf ("Se garantiza que el valor leido esta entre 1 y 100");
}
}
 exit: Permite salir anticipadamente de un programa. El prototipo de la función exit es: void
exit (int estado); y se encuentra en el archivo de cabecera <stdlib.h>. El valor de estado se
devuelve al sistema operativo.
Se utiliza frecuentemente exit() cuando no se satisface una condición obligatoria en la

ejecución de un programa. Por ejemplo, imagine un juego de computadora que necesita una
tarjeta de gráficos en color. La función main() de este juego puede ser algo parecida a ésta:
#include<stdlib.h>
main(void)
{
if(!tarjeta_color()) exit(l);
jugar( );
}
donde tarjeta_color() es una función definida por el usuario que devuelve cierto si encuentra
la tarjeta de gráficos en color. Si no se encuentra en el sistema, tarjeta_color() devuelve falso, o
sea 0, el programa finaliza.
 goto: La sentencia goto (ir a) nos permite hacer un salto a la parte del programa que deseemos.
En el programa debemos poner etiquetas, estas etiquetas no se ejecutan, es como poner un nombre
a una parte del programa. Estas etiquetas son las que nos sirven para indicar a la sentencia goto
dónde tiene que saltar. El goto sólo se puede usar dentro de funciones, y no se puede saltar desde
una función a otra.
#include <stdio.h>
main()
{
printf( "Línea 1\n" );
goto linea3; /*El goto busca la etiqueta linea3 */
linea3: /* Esta es la etiqueta */
}
Este programa muestra:

Línea 1
Línea 3
y no se ejecuta el printf de Línea 2 porque nos lo hemos saltado con el goto
Arreglos
Definición
Un arreglo es un conjunto de variables del mismo tipo que tienen el mismo nombre y se
diferencian en el índice.
Un arreglo consta de posiciones de memoria contiguas. La dirección más baja corresponde al
primer elemento y la más alta al último. Un arreglo puede tener una o varias dimensiones.
Para acceder a un elemento en particular de un arreglo se usa un índice.
tipo_de_datos nombre_arreglo [ tamaño ]

El tipo_de_dato es uno de los tipos de datos conocidos (int, char, float, ...) .
El nombre_ arreglo es el nombre que damos al arreglo, este nombre debe seguir las mismas
reglas que siguen los nombres de variables.
tamaño es el número de elementos que tiene el arreglo.
Declaración
int listanum[10];
Referencia
listanum[2] = 15; /* Asigna 15 al 3er elemento del arreglo listanum*/
num = listanum[2]; /* Asigna el contenido del 3er elemento a la variable num */
NOTA: No hay que confundirse. En la declaración de un arreglo el número entre corchetes

es el número de elementos, en cambio cuando ya usamos el arreglo el número entre
corchetes es el índice.
Arreglos
También podemos declarar un arreglo bidimensional, para ello usaremos el siguiente formato:
tipo_de_dato nombre_del_arreglo [ filas ] [ columnas ];
Declaración
int tabladenums[50][50];
Referencia
tabladenums[2][3] = 15; /* Asigna 15 al elemento de la 3ª fila y la 4ª columna*/
num = tabladenums[25][16];
De la misma manera C permite arreglos multidimensionales, el formato general es:

tipo_de_dato nombre_del_arreglo [ tam1 ][ tam2 ] ... [ tamN];
NOTA: EN TODOS LOS CASOS EL NOMBRE DEL ARREGLO ES UN PUNTERO

AL PRIMER ELEMENTO DEL ARREGLO.
Arreglos
Inicialización de arreglos unidimensionales
int hojas = 34; //declarar e inicializar una variable
int temp [10] = { 15, 18, 20, 23, 22, 24, 22, 25, 26, 25 }; // declarar e inicializar un arreglo
Inicialización de arreglos multidimensionales

int num[3][4]={0,1,2,3,4,5,6,7,8,9,10,11};
int temp [3][5] = {
{ 15, 17, 20, 25, 10 },
{ 18, 20, 21, 23, 18 },
{ 12, 17, 23, 29, 16 } }; // forma alternativa, no olvidar el ; final
Ejemplo (asigna al primer elemento de un arreglo bidimensional 0, al sig. 1, y así sucesivamente.)

main() {
int t, i, num[3][4];
for(t=0; t<3; ++t) {
for(i=0; i<4; ++i) {
num[t][i]=(t*4)+i;
}
}
for(t=0; t<3; ++t) {
for(i=0; i<4; ++i) {
printf("num[%d][%d]=%d \n", t, i, num[t][i]);
}
}
}
Cadenas
C no maneja tipo de datos string. Una cadena es un arreglo de caracteres.
char cadena[11]; // declaración
char nombre_arr[tam] = "cadena"; //declaración e inicialización
char cadena[5]="hola"; // inicialización. 1 posición más para ‘\0’ (carácter nulo de fin de cadena)
char cadena[5]={'h','o','l','a','\0'}; //inicialización alternativa
Para asignar la entrada estándar a una cadena se puede usar la función scanf con la opción %s,
de igual forma para mostrarlo en la salida estándar, utilizando printf.
(O utilizar gets y puts).
Ejemplo
main() {
char nombre[15], apellido [30];
printf("Introduce tu nombre: ");
scanf("%s",nombre); // gets(nombre);
printf("Introduce tu apellido: ");
scanf("%s",apellido); // gets(apellido);
printf("Usted es %s %s\n", nombre, apellido); }
Como C no maneja cadenas de caracteres, lo siguiente no es válido:
char nombre[40], apellidos[40], completo[80];

nombre="José María"; /* ilegal */
apellidos="Morelos y Pavón"; /* ilegal */
completo="Gral."+nombre+apellidos ; /* ilegal */
Funciones para el manejo de caracteres <ctype.h>
Funciones para el manejo de cadenas <string.h>
Estructuras
Definición
En C una estructura es una colección de variables que se referencian bajo el mismo nombre.
Una estructura proporciona un medio conveniente para mantener junta información que se relaciona.
Una definición de estructura forma una plantilla que se puede usar para crear variables de estructura.
Las variables que forman la estructura son llamados campos, elementos, o miembros de la estructura.
struct nombre_de_la_estructura {
campos_de_estructura;
};
Declaración
struct datos_contacto {
char nombre[30];
char calle[40];
char ciudad[20];
char estado;
int codigo;
};
Para declarar una variable, se hará como sigue:

struct datos_contacto contacto;
dónde contacto sería el nombre de la variable de tipo estructura datos_contacto.
Estructuras
Ejemplos de declaración e inicialización
struct datos_contacto {
char nombre[30];
char calle[40];
char ciudad[20];
char estado;
int codigo;
} contacto1, contacto2, contacto3 ;
struct datos_contacto contacto1 = {"Vicente Fernández",“San Juan

1168",“Rosario",’A’,12345};
Referencias
contacto1.codigo = 22222 ;
contacto1.estado = ‘B’ ;
strcpy(contacto1.nombre,“Juan Perez”) ;
Estructuras
Arreglos de Estructuras
Dada la siguiente estructura:
struct identificacion {
char nombre[30];
char calle[40];
char ciudad[20];
char estado;
int codigo;
};
Se puede definir un arreglo de estructura de esta forma:
struct identificacion contacto[1000];
contacto tiene 1000 elementos del tipo identificacion.
Lo anterior podría ser accedido de la siguiente forma:

contacto[50].codigo = 22222 ;
contacto[50].estado = ‘A’ ;
strcpy(contacto[50].nombre,“Juan Perez”) ;
Estructuras
Estructuras anidadas
Es posible crear estructuras que tengan como miembros otras estructuras, de manera de ordenar mejor
la información.
struct estruc_existencias {
int dvd;
int blu-ray;
int ultra-hd; };
struct estruc_proveedor {
char nombre[40];
char telefono[10];
char direccion[100]; };
struct estruc_inventario {
char titulo[30];
char autor[40];
struct estruc_existencias existencias;
struct estruc_proveedor proveedor;
} inventario;
Ahora para acceder a la cantidad de dvd de cierto título usaríamos lo siguiente:

inventario.existencias.dvd
y para acceder al nombre del proveedor:
inventario.proveedor.nombre
Y como antes hariamos inventario.titulo para acceder al titulo de una película.
Punteros
Definición
Un puntero es una variable que contiene una dirección de memoria. Normalmente, esa dirección
es la posición de otra variable de memoria. Si una variable contiene la dirección de otra variable,
entonces se dice que la primera variable apunta a la segunda.
Declaración
tipo *nombre;
Operadores de punteros
Existen dos operadores especiales de punteros: & y *.
El operador de dirección (&) devuelve la dirección de memoria de su operando.
El operador de indirección (*) devuelve el contenido de la dirección apuntada por el
operando.
Inicialización
int x; // define la variable entera x
int *p1,*p2; // define los punteros a entero p1 y p2
p1=&x; // asigno al puntero p1 la dirección de la variable x
p2=p1; // asigno al puntero p2 el contenido del puntero p1
Punteros
Analizando un ejemplo
main() {
int x = 1, y = 2;
int *ap;
ap = &x;
y = *ap;
x = ap;
*ap = 3;
}
Aritmética de punteros
Existen sólo dos operaciones aritméticas que se puedan usar con punteros: la suma y la resta
entre un puntero y un entero.
main() {
float *flp, *flq, a=0;
flp= &a;
*flp = *flp + 10;
++*flp; // con *++flp muevo el puntero
(*flp)++; // con *flp++ muevo el puntero
flq = flp;
}
Punteros
Punteros y Arreglos
Existe una relación estrecha entre los punteros y los arreglos. En C, un nombre de un arreglo es
un índice a la dirección de comienzo del arreglo. En esencia, el nombre de un arreglo es un
puntero al arreglo.
int a[10], x;
int *ap;
ap = &a[0]; /* ap apunta a la dirección de a[0] */
x = *ap; /* A x se le asigna el contenido de ap (a[0] en este caso) */
*(ap + 1) = 100; /* Se asigna al segundo elemento de 'a' el valor 100 usando ap*/
Como se puede observar en el ejemplo la sentencia a[1] es idéntica a *(ap+1).

Por ejemplo se puede escribir solamente ap = a; en vez de ap = &a[0];
Como &a[i] es equivalente con a+i resulta que *(a + i) es equivalente a a[i].
Diferencias
• Un puntero es una variable. Se puede hacer ap = a y ap++.
• Un arreglo NO ES una variable. Hacer a = ap y a++ ES ILEGAL.
Es correcto inicializar un puntero con la dirección de un array, en cambio no se puede

cambiar la dirección de un array definido en forma estática, pues el array es un puntero
constante, esto es, se puede modificar su contenido pero no la dirección que le fue
asignada en su definición.
Punteros
Punteros y Estructuras
Los punteros a estructuras se definen fácilmente y en una forma directa. Considerar lo siguiente:
struct coord {
float x;
float y;
float z; };
main() {
struct coord punto;
struct coord *ap_punto;
punto.x = 1;
punto.y = 10;
punto.z = 2;
ap_punto = &punto; // Se asigna la dirección de comienzo de punto al puntero
ap_punto->x = 3; /* Con el operador -> se accede a los miembros */
ap_punto->y++; /* de la estructura apuntados por ap_punto */
ap_punto->z+=2;
}
Funciones creadas por el programador
Definición
Una función es un conjunto de declaraciones, definiciones, expresiones y sentencias que
realizan una tarea específica y bien definida. Todo programa en C consta de una o más funciones.
Una de estas funciones se debe llamar main. La ejecución del programa siempre comenzará
por la las instrucciones contenidas en main.
Características
• Se puede acceder a una misma función desde varios puntos del programa. Una vez completada la
ejecución de una función, se devuelve el control al punto desde el que se accedió a ella.
• A la función se le puede pasar información mediante unos identificadores denominados argumentos o
parámetros.
• Las funciones terminan y regresan automáticamente al procedimiento que las llamó.
• En C una función puede devolver datos mediante argumentos y puede devolver también un valor.
• Las funciones pueden ser llamadas desde la función main o desde otras funciones.
• Nunca se debe llamar a la función main desde otro lugar del programa.
Ventajas
• Reuso. Evitar la repetición innecesaria de código.
• Independencia: separando el código en funciones modulares se facilita el diseño y la comprensión de
los programas.
• Al realizar funciones independientes de la función principal e independientes entre sí permite
que las funciones puedan tener sus propias variables “locales", es decir, estas variables no pueden
ser accedidas desde fuera de la función. Esto significa que el programador no necesita preocuparse
por el uso accidental de los mismos nombres de variables en otros puntos del programa.
Estructura de las funciones
#include <stdio.h>
float calculaprom (int num1, int num2); /*prototipo*/
main() {
int a=7, b=10;
float resultado;
resultado = calculaprom (a, b); /*llamada*/
printf("Promedio=%f\n",resultado);
}
float calculaprom (int num1, int num2) { /*declaración*/

float promedio;
promedio = (num1 + num2) / 2.0;
return(promedio);
}
Prototipo
Este es el primer elemento relacionado con una función. Está formado por una línea antes del comienzo
de main(). El formato general de la línea del prototipo es:
tipo_de_retorno nombre_función (lista_de_parámetros);
long int factorial (int);

void factorial (int);
Llamada de la función
La llamada a una función se realiza de forma diferente según que la función devuelva o no un valor al
punto de llamada.
Si la función no devuelve ningún valor (void) se accede a ella especificando su nombre, seguido de
una lista de argumentos cerrados entre paréntesis y separados por comas.
Si la función devuelve un valor se debe acceder a ella desde una expresión.
En ambos casos si la función no requiere argumentos se deben especificar los paréntesis vacíos.
Los argumentos actuales pueden ser constantes, variables o expresiones más complejas. No obstante
cada argumento actual debe ser del mismo tipo de datos que el argumento formal correspondiente.
Ejemplos
Ejemplos de llamada a la función factorial:
•Para el caso de la función factorial que devuelve un valor:
fact=factorial(n);
a = a + factorial(n);
printf("el factorial de %d es %ld\n",n,factorial(n));
if (factorial(n)>50)
switch(factorial(n)) {…
•Para el caso de la función factorial que no devuelve nada:
factorial(n);
Ejemplos
/*vemos que sucede si en la llamada no guardamos el valor de la variable retornada */
#include <stdio.h>
int suma(int,int); /* prototipo */
// realiza una suma
main() {
int a=10,b=25,t;
t=suma(a,b); // guardamos el valor
printf("%d=%d",suma(a,b),t);
suma(a,b); // el valor se pierde
}
int suma(int a,int b) {

return (a+b);
}
Declaración de la función
Se denomina declaración de la función a la función propiamente dicha. Es de la forma:
tipo_de_retorno nombre_función (tipo y nombre argumentos) {
declaración de variables locales;
código de la función;
return(x);
}
Notar que la primera línea no finaliza con punto y coma.
Tener en cuenta que los argumentos o parámetros formales de la función y sus variables locales se
destruirán al finalizar la ejecución de la misma.
Los argumentos en la declaración de la función se denominan argumentos o parámetros formales,

permiten la transferencia de información desde el punto del programa en donde se llama a la función a
ésta.
Los argumentos correspondientes en la llamada a la función se denominan argumentos actuales o
reales.
Los identificadores utilizados como argumentos o parámetros formales son locales en el sentido de
que no son reconocidos fuera de la función.
Ejemplos de declaración o definición de funciones
Declaración de una función que devuelve un valor entero largo:
long int factorial (int n) {
long int f=1;
int i;
for (i=2;i<=n;++i) f*=i;
return (f);
}
Declaración de una función que no devuelve ningún valor:

void factorial (int n) {
long int f=1;
int i;
for (i=2;i<=n;++i) f*=i;
printf("el factorial de %d es %ld\n",n,f);
}
Paso de parámetros a una función
Por valor: se copia el valor del argumento actual o real en el argumento o parámetro formal de la
función. Es decir que trabajamos con una copia, no con el original, por lo tanto cualquier cambio que se
realice dentro de la función en el argumento enviado, NO afectará al valor original de las variables
utilizadas en la llamada.
Por referencia: en este caso lo que hacemos es enviar a la función la dirección de memoria donde se
encuentra la variable o dato. Es decir que trabajamos directamente con el original, por lo tanto cualquier
modificación SI afectará a las variables utilizadas en la llamada. En resumen, esto permite que datos de
la parte del programa en la que se llama a la función sean accedidos por la función, alterados dentro de
ella y luego devueltos al programa de forma alterada. En los casos de pasajes por referencia en la
llamada se debe anteponer al nombre de la variable el operador & (ampersand – la dirección de) y los
parámetros deben ser de un tipo puntero compatible.
Para tener en cuenta:

•Las estructuras se pueden pasar por valor o por referencia. Si se pasa una estructura por valor, las
modificaciones de sus campos serán locales mientras que si se pasan por referencia las modificaciones
serán permanentes.
•El paso de arrays como parámetros de funciones siempre se realiza por referencia. No es posible
enviar por valor los arrays, ya que recordemos que el nombre de un arreglo por si solo es un puntero al
primer elemento del array. Esto significa que la declaración del parámetro formal debe ser de un tipo
puntero compatible, ya sea declararlo como un array (tipo nombre[long]) o como un puntero (tipo
*nombre). Si fuera necesario salvar esta característica de funcionamiento, se podría transferir el arreglo
dentro de una estructura (como un campo de ella).
Paso por valor
#include <stdio.h>
void intercambio(int,int); /* prototipo */
/* Intercambio de valores */
main() {
int a=1,b=2;
printf("a=%d y b=%d",a,b); /* valores de a y b antes de la llamada */
intercambio(a,b); /* llamada */
printf("a=%d y b=%d",a,b); /* valores de a y b después de la llamada */
}
void intercambio (int x,int y) { // declaración o definición

int aux;
aux=x;
x=y;
y=aux;
printf("a=%d y b=%d",x,y); /* valores de a y b en la función */
}
Paso por referencia
#include <stdio.h>
void intercambio(int *,int *); /* prototipo */
/* Intercambio de valores */
main() {
int a=1,b=2;
printf("a=%d y b=%d",a,b); /* valores de a y b antes de la llamada */
intercambio(&a,&b); /* llamada */
printf("a=%d y b=%d",a,b); /* valores de a y b despues de la llamada */
}
void intercambio (int *x, int *y) { // declaración o definición

int aux;
aux=*x;
*x=*y;
*y=aux;
printf("a=%d y b=%d",*x,*y); /* valores de a y b en la función */
}
Tiempo de vida de los datos
En C, cada función es un bloque de código. El código de una función es privado a esa función y solo se
puede acceder a él mediante una llamada a esa función.
Las variables que están definidas dentro de una función se llaman variables locales. Una variable local
comienza a existir cuando se entra en la función y se destruye al salir de ella.
La única excepción a esta regla se da cuando la variable se declara con el especificador de clase de
almacenamiento static. Esto hace que el compilador trate a la variable como si fuese una variable global
en cuanto a almacenamiento se refiere, pero siga limitando su ámbito al interior de la función.
Ejemplo:
# include <stdio.h>
void prueba_estatica(void);
main() {
int cont;
for(cont = 1; cont <= 3; cont++) { La salida del programa ejemplo será:
printf("iteracion numero %d:", cont); iteracion numero 1: local = 1 y estatica = 1
prueba_estatica(); iteracion numero 2: local = 1 y estatica = 2
} iteracion numero 3: local = 1 y estatica = 3
}
void prueba_estatica(void) {
int local = 1;
static int estatica = 1;
printf(“local = %d y estatica = %d\n", local, estatica);
local++;
estatica++; }

Apunte Lenguaje C Resumido1

Cargado por

Copyright:

Formatos disponibles

Apunte Lenguaje C Resumido1

Cargado por

Información del documento

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Apunte Lenguaje C Resumido1

Cargado por

Copyright:

Formatos disponibles

Lenguaje C

[Sintaxis y Semántica del lenguaje]

Ing. Alvaro Hergenreder Universidad Tecnológica Nacional – FRRO

Material extraído del apunte de “Lenguaje de Programación C”

 C se clasifica como un lenguaje de nivel medio porque combina elementos de

 El código C es muy portable

 C es un lenguaje estructurado. El principal componente estructural de C es la

 Tiene la ventaja de usar compilador en lugar de intérprete, es más rápido.

 En C las mayúsculas y las minúsculas son diferentes.

 Las 32 palabras claves del standard ANSI son:

 Todos los programas en C consisten en una o más funciones (estándares o

#include <stdio.h> (1)

#include <stdio.h> (1)

#include <stdio.h> (1)

(7) se asigna a la variable c el resultado de una operación aritmética.-

(8) main llama a la función de biblioteca printf con el argumento:

 Escoger nombres de variables con significado

 Utilizar líneas en blanco para separar las distintas secciones de la función

 Espacios en blanco entre los operadores

 Mantener una línea con el posicionamiento de las llaves

El lenguaje C averigua dónde termina una sentencia y comienza la siguiente por

#define <nombre de macro> <nombre de reemplazo>

como inicio ... fin haciendo:

#define MIN(a, b) (a < b) ? a : b

printf("El mínimo es %d\n", (x < y) ? x : y);

después del preprocesamiento, el código podría verse de la siguiente forma:

x = (q+r < s+t) ? q+r : s+t;

Nota: El uso de la sustitución de macros en lugar de funciones reales tiene un beneficio

El formato general es:

#undef <nombre de macro>

#define LONG 100

/* en este momento LONG y ANCHO están indefinidas*/

• Se acostumbra usar minúsculas para nombres de variables y mayúsculas para nombres

Los siguientes son ejemplos de nombres de identificadores:

Existen cuatro tipos de datos básicos en C:

unsigned ...................... número sin signo (siempre positivo)

El formato general de la inicialización es:

tipo nombre_de_variable = constante;

int cant = 97;

Variables Locales, también llamadas privadas o automáticas:

• Se declaran dentro de una función o de un bloque de código.

• Su nombre puede ser usado por otras funciones.

EJEMPLO  Variables Locales

EJEMPLO  Variables Locales

 Se declaran fuera de todas las funciones.

 Mantienen su valor durante toda la ejecución del programa.

 usar muchas variables globales puede acarrear problemas de programación (especialmente

especificador_de_almacenamiento tipo nombre_de_variable

Existen 4 tipos, a saber:

* Variables estáticas locales: el compilador crea un almacenamiento permanente para ellas.

Frecuentemente se ve la declaración const en los parámetros de una función.

CÓDIGOS DE BARRA INVERTIDA

Son constantes de carácter que se utilizan

El siguiente cuadro muestra la lista de

variable operador valor

Variaciones en la sentencia de asignación:

variable1 = variable2 = variable3 = valor

El formato de la expresión que resulta de aplicar el operador incremento o decremento es:

dónde operador actúa distinto según su ubicación respecto a la variable:

 operador variable (prefijo)

float calculaprom (int num1, int num2) { /declaración/

void intercambio (int x, int y) { // declaración o definición