Principales funciones del Lenguaje C

*Funciones de entrada y salida*

A diferencia de otros lenguajes, C no dispone de sentencias de entrada/salida . En su
 lugar se utilizan funciones contenidas en la librería estándar y que forman parte 
integrante del lenguaje.

Las funciones de entrada/salida (Input/Output) son un conjunto de funciones, 
incluidas con el compilador, que permiten a un programa recibir y enviar datos
 al exterior. Para su utilización es necesario incluir, al comienzo del programa, 
el archivo stdio.h en el que están definidos sus prototipos:

#include <stdio.h>

donde stdio proviene de standard-input-output .

Función printf()
double tiempo;
float masa;
printf("Resultado nº: %d. En el instante %lf la masa vale %f\n",i, tiempo, masa)

Carácter	Tipo de argumento	Carácter	Tipo de argumento
d, i	int decimal	o	octal unsigned
u	int unsigned	x, X	hex. unsigned
c	char	s	cadena de char
f	float notación decimal	e, g	float not. científ. o breve
p	puntero (void *)

Un número entero positivo, que indica la anchura mínima del campo en caracteres.
Un signo (-), que indica alineamiento por la izda (el defecto es por la dcha).
Un punto (.), que separa la anchura de la precisión .
Un número entero positivo, la precisión , que es el nº máximo de caracteres a 

imprimir en un string , el nº de decimales de un float o double , o las cifras mínimas 

de un int o long .
Un cualificador : una (h) para short o una (l) para long y double.
"Con cien cañones por banda,","viento en popa a toda vela,",
"no cruza el mar sino vuela,",
"un velero bergantín.");
Función scanf()

carácter	caracteres leídos	argumento
c	cualquier carácter	char *
d, i	entero decimal con signo	int *
u	entero decimal sin signo	unsigned int
o	entero octal	unsigned int
x, X	entero hexadecimal	unsigned int
e, E, f, g, G	número de punto flotante	float
s	cadena de caracteres sin ' '	char
h, l	para short, long y double
L	modificador para long double

double distancia;
char nombre[20];
scanf("%d%lf%s", &n, &distancia, nombre);
Macros getchar() y putchar()
escribe el carácter a . Esta sentencia equivale a printf("a");
char name[100];
while((c = getchar()) != '\n') // se leen caracteres hasta el '\n'
         name[i++] = c; // se almacena el carácter en Name[]
name[i]='\0'; // se añade el carácter fin de cadena 

La función printf() imprime en la unidad de salida (el monitor, por defecto), el texto, 
y las constantes y variables que se indiquen. La forma general de esta función
 se puede estudiar viendo su prototipo :

int printf("cadena_de_control", tipo arg1, tipo arg2, ...)

Explicación: La función printf() imprime el texto contenido en cadena_de_control 
junto con el valor de los otros argumentos, de acuerdo con los formatos incluidos 
en cadena_de_control . Los puntos suspensivos (...) indican que puede 
haber un número variable de argumentos. Cada formato comienza con el carácter 
(%) y termina con un carácter de conversión .

Considérese el ejemplo siguiente,

int i; 

en el que se imprimen 3 variables ( i , tiempo y masa ) con los formatos
 ( %d , %lf y %f ), correspondientes a los tipos (int, double y float ),
 respectivamente. La cadena de control se imprime con el valor de cada 
variable intercalado en el lugar del formato correspondiente

Tabla 8.1. Caracteres de conversión para la función printf() .

Lo importante es considerar que debe haber correspondencia uno a uno (el 1º con
 el 1º, el 2º con el 2º, etc.) entre los formatos que aparecen en la cadena_de_
control y los otros argumentos (constantes, variables o expresiones). Entre 
el carácter % y el carácter de conversión puede haber, por el siguiente orden, uno
 o varios de los elementos que a continuación se indican:

Los caracteres de conversión más usuales se muestran en la Tabla 8.1.

A continuación se incluyen algunos ejemplos de uso de la función printf() .
 El primer ejemplo contiene sólo texto, por lo que basta con considerar la cadena_
de_control .

printf("Con cien cañones por banda,\nviento en popa a toda vela,\n"); 

El resultado serán dos líneas con las dos primeras estrofas de la 
famosa poesía. No es posible partir cadena_de_control en varias líneas con 
caracteres intro , por lo que en este ejemplo podría haber problemas para 
añadir más estrofas. Una forma alternativa, muy sencilla, clara y ordenada, de escribir la poesía sería la siguiente:

printf("%s\n%s\n%s\n%s\n",

En este caso se están escribiendo 4 cadenas constantes de caracteres que se
 introducen como argumentos, con formato %s y con los correspondientes 
saltos de línea. Un ejemplo que contiene una constante y una variable como argumentos 
es el siguiente:

printf("En el año %s ganó %ld ptas.\n", "1993", beneficios); 

donde el texto 1993 se imprime como cadena de caracteres (%s), mientras 
que beneficios se imprime con formato de variable long (%ld). Es importante hacer 
corresponder bien los formatos con el tipo de los argumentos, pues si no los resultados
 pueden ser muy diferentes de lo esperado.

La función printf() tiene un valor de retorno de tipo int , que representa el número de 
caracteres escritos en esa llamada.

La función scanf() es análoga en muchos aspectos a printf() , y se utiliza para leer datos 
de la entrada estándar (que por defecto es el teclado). La forma general de esta función 
es la siguiente:

int scanf("%x1%x2...", &arg1, &arg2, ...);

donde x1, x2, ... son los caracteres de conversión , mostrados en la Tabla 8.2, que 
representan los formatos con los que se espera encontrar los datos. La función scanf() 
devuelve como valor de retorno el número de conversiones de formato realizadas 
con éxito. La cadena de control de scanf() puede contener caracteres además de formatos.
 Dichos caracteres se utilizan para tratar de detectar la presencia de caracteres idénticos
 en la entrada por teclado. Si lo que se desea es leer variables numéricas, esta posibilidad
 tiene escaso interés. A veces hay que comenzar la cadena de control con un espacio en
 blanco para que la conversión de formatos se realice correctamente.

En la función scanf() los argumentos que siguen a la cadena_de_control deben ser 
pasados por referencia , ya que la función los lee y tiene que trasmitirlos al programa que la 
ha llamado. Para ello, dichos argumentos deben estar constituidos por las direcciones de
 las variables en las que hay que depositar los datos, y no por las propias variables. Una
 excepción son las cadenas de caracteres , cuyo nombre es ya de por sí una dirección 
(un puntero), y por tanto no debe ir precedido por el operador (&) en la llamada.

Tabla 8.2. Caracteres de conversión para la función scanf() .

Por ejemplo, para leer los valores de dos variables int y double y de una cadena de 

caracteres, se utilizarían la sentencia:

int n; 

en la que se establece una correspondencia entre n y %d , entre distancia y %lf , y 
entre nombre y %s . Obsérvese que nombre no va precedido por el operador (&). La lectura
 de cadenas de caracteres se detiene en cuanto se encuentra un espacio en blanco,
 por lo que para leer una línea completa con varias palabras hay que utilizar otras técnicas
 diferentes.

En los formatos de la cadena de control de scanf() pueden introducirse corchetes [...], que se utilizan como sigue. La sentencia,

scanf("%[AB \n\t]", s); // se leen solo los caracteres indicados 

lee caracteres hasta que encuentra uno diferente de ( 'A','B',' ','\n','\t' ) . En otras palabras
, se leen sólo los caracteres que aparecen en el corchete. Cuando se encuentra un
 carácter distinto de éstos se detiene la lectura y se devuelve el control al programa que
 llamó a scanf() . Si los corchetes contienen un carácter (^), se leen todos los caracteres 
distintos de los caracteres que se encuentran dentro de los corchetes a continuación del (^). 
Por ejemplo, la sentencia,

scanf(" %[^\n]", s);

lee todos los caracteres que encuentra hasta que llega al carácter nueva línea '\n'. Esta 
sentencia puede utilizarse por tanto para leer líneas completas, con blancos 
incluidos. Recuérdese que con el formato %s la lectura se detiene al llegar al 
primer delimitador (carácter blanco, tabulador o nueva línea).

Las macros 6 getchar() y putchar() permiten respectivamente leer e imprimir un sólo 
carácter cada vez, en la entrada o en la salida estándar. La macro getchar() recoge un
 carácter introducido por teclado y lo deja disponible como valor de retorno. La macro 
putchar() escribe en la pantalla el carácter que se le pasa como argumento. Por ejemplo:

putchar('a'); 

mientras que

c = getchar();

equivale a

scanf("%c", &c);

Como se ha dicho anteriormente, getchar() y putchar() son macros y no funciones , aunque 
para casi todos los efectos se comportan como si fueran funciones. El concepto de macro 
se verá con más detalle en la siguiente sección. Estas macros están definidas en el 
fichero stdio.h , y su código es sustituido en el programa por el preprocesador antes de la 
compilación.

Por ejemplo, se puede leer una línea de texto completa utilizando getchar() :

int i=0, c; 

*Los operadores aritméticos*

En informática y lenguajes de programación, se entiende por expresión aritmética a 
aquella donde los operadores que intervienen en ella son numéricos, el resultado es un 
número y los operadores son aritméticos. Los operadores aritméticos más comúnmente 
utilizados son:

El signo más (+) se emplea para sumar dos valores, el signo menos (-) para restar un valor 
de otro, el asterisco (*) para multiplicar dos valores, la división (/) para dividir un valor por otro,
 y el signo % para obtener el resto de una división entera. Estos símbolos se conocen como
 operadores binarios, pues operan sobre dos valores o variables.

La lista siguiente son ejemplos de expresiones aritméticas:

resultado = x - y;

total = capital+ interés;

cuadrado = x * x;

celcius = (fahrenheit - 32) / 1.8

Hay que comprender que el signo igual (=) en las expresiones anteriores se le conoce como
 "operador de asignación". Asigna el valor de la derecha de dicho signo igual a la variable de
 la
 izquierda.

En la última expresión, se utilizan paréntesis () para realizar primero cierta operación. 
Esto sucede porque en C, los operadores siguen unas reglas de preferencia. *, / y % tienen
 preferencia sobre + y -. Para soslayar esta preferencia, se deben utilizar paréntesis. Las 
expresiones con operadores de la misma preferencia se suelen evaluar de izquierda a 
derecha. Otro punto a tener en cuenta es que en una expresión que entraña una división, 
hay que tener cuidado de evitar la división por cero, que da como resultado infinito o un valor
 anómalo. En el capítulo 5 sobre declaraciones de control, veremos cómo hacer una revisión previa a la división para 
prevenir estos resultados.

*Operadores logicos*

Muy utilizados en Informática, Lógica proposicional y Álgebra booleana, entre otras 
disciplinas. Los operadores lógicos nos proporcionan un resultado a partir de que se 
cumpla o no una cierta condición, producen un resultado booleano, y sus operandos
 son también valores lógicos o asimilables a ellos (los valores numéricos son asimilados
 a cierto o falso según su valor sea cero o distinto de cero). Esto genera una serie de 
valores que, en los casos más sencillos, pueden ser parametrizados con los valores
 numéricos 0 y 1. La combinación de dos o más operadores lógicos conforma una función
 lógica.

Los operadores lógicos son tres; dos de ellos son binarios, el último (negación) es unario.
 Tienen una doble posibilidad de representación en el estándar C++ actual: la representación
 tradicional que se indica a continuación, y la natural introducida recientemente que se 
detalla más adelante.

• Y lógico && AND

• O lógico || OR

• Negación lógica  ! NOT

Las expresiones conectadas con los operadores && y || se evalúan de izquierda a derecha, 
y la evaluación se detiene tan pronto como el resultado verdadero o falso es conocido 
(muchos programas tienen una lógica que se basa en este propiedad).

*Operadores relacionales*

Los operadores relacionales son símbolos que se usan para comparar dos valores. 
Si el resultado de la comparación es correcto la expresión considerada es verdadera, 
en caso contrario es falsa.

El carácter ~ se obtiene manteniendo pulsada la tecla Alt y pulsando en el teclado numérico
 las teclas 126. Corresponde al carácter ASCII decimal 126.

Se debe tener especial cuidado en no confundir el operador asignación con el 
operador relacional igual a. Las asignaciones se realizan con el símbolo =, las 
comparaciones con ==.

Si dos escalares a y b se comparan el resultado puede ser verdadero (1) o falso (0) de 
acuerdo con la tabla anterior.

Si a y b son vectores de la misma dimensión, se compara cada elemento a(i) con b(i) el
 resultado es que el elemento (i) del vector resultado u(i) puede contener un 1 ó 0.

Si se comparan dos matrices (de la mismas dimensiones) la comparación se hace elemento 

a elemento y el resultado es otra matriz de la misma dimensión con unos y ceros de 

acuerdo con el resultado de la comparación.