• Moderno. Los programas desarrollados utilizan las técnicas de programación estructurada y poseen un diseño modular.
  

• Eficiente. Su diseño aprovecha las posibilidades y los recursos de los ordenadores actuales.
  

• Portátil. Los programas escritos en C para un ordenador concreto son, por lo general, fácilmente transportables a otro ordenador de distinta arquitectura con muy pocas modificaciones, siempre que en el desarrollo de éstos se utilice el conjunto estándar de bibliotecas del lenguaje.
  

• Potente y flexible. Se emplea para resolver problemas físicos y de ingeniería. A diferencia de los demás lenguajes de alto nivel, posee control sobre aspectos asociados a los lenguajes ensambladores.

• Compilado. Es necesario disponer de un editor de texto y un compilador en modo de línea de órdenes, o de un entorno integrado de desarrollo (IDE). El compilador permite, a partir del programa en código fuente, obtener la traducción a código objeto en formato ejecutable. En el sistema operativo Windows, los ficheros ejecutables poseen la extensión .EXE.

Ejemplo 1.2. Escribir un programa que asigne a una variable de tipo entero el número cien y muestre en pantalla dicho valor los siguientes formatos: base diez, base ocho (octal) y base dieciseis (hexadecimal).

#include <stdio.h>

int main() {

  unsigned x = 100;

  printf("\nBase diez: %d, Formato octal: %o, Formato hexadecimal: %x.\n", x, x, x);

  system("pause");
  return 0;
}

Modificadores del tipo entero básico: unsigned, long y short. La especificación del lenguaje garantiza el cumplimiento de la siguiente desigualdad: short [int] <= int <= long [int]. Como regla general, los compiladores asignan al tipo short un tamaño de dieciséis bits y al tipo long un tamaño de treinta y dos bits. El tipo int podrá tener el tamaño del tipo long o el del tipo short.

Ejemplo 1.3. Desarrollar un programa que muestre en pantalla el rango de representación de un entero corto con signo y de un entero corto sin signo.

#include <stdio.h>

int main() {

  short x = 0x7fff;
  unsigned short y = 0xffff;

  printf("\nRango de un entero corto con signo: [%hd, %hd].", x + 1, x);
  printf("\nRango de un entero corto sin signo: [%hu, %hu].\n\n", y + 1, y);

  system("pause");
  return 0;
}

El tipo void (vacío) se emplea para escribir funciones que carecen de valor de retorno (ver guión correspondiente).

Ejemplo 1.8. Escribir un programa que imprima por pantalla el tamaño en bytes del tipo long double. Para ello deberá usarse el operador sizeof(), el cual se explicará más adelante.

#include <stdio.h>

int main() {

  long double x = 1.0;

  printf("\nEl tipo \"long double\" tiene %d bytes.\n", sizeof(x));

  system("pause");
  return 0;
}

Operador de asignación (=). Almacena el valor de la expresión situada a la derecha del operador en la variable que se halla a la izquierda del mismo. El tipo de la expresión cuyo valor se va a asignar debe ser compatible con el de la variable objeto de la asignación.

Operadores aritméticos (+, -, *, / y %). El operador de división (/) funciona de manera diferente según el tipo de los operandos: Si ambos son enteros se realizará una división entera. En este caso, el operador módulo (%) permite obtener el resto de la división entera. Por el contrario, si uno de ellos o ambos son reales, tendrá lugar una división real.

Operadores de incremento (++) y decremento (--). El primero aumenta en una unidad el valor de la variable sobre la que actúa, mientras que el segundo disminuye en una unidad dicho valor. La utilización de ambos operadores da lugar a un código objeto más compacto y eficiente que el uso de la asignación ordinaria para incrementar o decrementar una variable en una unidad.

Ejemplo 1.9. Desarrollar un programa que, mediante los incrementos sucesivos de una variable, muestre en pantalla los cinco primeros números naturales.

#include <stdio.h>

int main() {

  unsigned n = 0;

  printf("\nCinco primeros naturales: ");

  n++; /* 1 */
  printf("%u, ", n);
  n++; /* 2 */
  printf("%u, ", n);
  n++; /* 3 */
  printf("%u, ", n);
  n++; /* 4 */
  printf("%u, ", n);
  n++; /* 5 */
  printf("%u.\n", n);

  system("pause");
  return 0;

}

Ejercicio: Modificar el programa del ejemplo 1.9 para que imprima por pantalla en orden descendente los cinco primeros números naturales.

Operadores de actualización de variables (+=, -=, *=, /= y %=). Realizan la operación aritmética correspondiente entre el valor de la variable de la izquierda y el de la expresión de la derecha. El resultado obtenido se asigna a la variable. El empleo de estos operadores permite al compilador generar un código objeto más compacto y eficiente que el uso de la asignación ordinaria. Asimismo, es posible simplificar determinadas expresiones y hacerlas más legibles.

Ejemplo 1.10. El siguiente programa permite comprobar que determinadas expresiones complejas pueden simplificarse si se utilizan los operadores de actualización de variables y que, además, las expresiones modificadas resultan ser equivalentes a las originales en cuanto a los resultados obtenidos.

#include <stdio.h>

int main() {

  int t = 4, x = 5, y = -6;

  t = t * (10 * x + 5 * y + 5);
  printf("\nExpresión original: t -> %d.", t);

  t = 4; /* restaurar valor inicial */
  t *= 10 * x + 5 * y + 5;
  printf("\nExpresión modificada: t -> %d.\n\n", t);

  system("pause");
  return 0;
}

Operadores relacionales (<, <=, >, >=, == y !=). Se emplean para comparar los valores de dos expresiones. Éstas comparaciones dan como resultado un valor lógico o booleano (cierto o falso), y suelen actuar como condiciones simples en las sentencias de selección e iteración para controlar la ejecución de las mismas (ver guión correspondiente).

En C toda expresión siempre tiene un valor.

Ejemplo 1.11. Escribir un programa que muestre en pantalla los valores de una expresión relacional cierta y de otra falsa.

#include <stdio.h>

int main() {

  int cierto, falso;

  cierto = (10 > 2); /* expresión cierta */
  falso = (10 == 2); /* expresión falsa */

  printf("\nCierto: %d, falso: %d.\n", cierto, falso);

  system("pause");
  return 0;
}

Operadores lógicos (&& (AND), || (OR) y ! (NOT)). Permiten combinar dos o más expresiones de relación. De este modo, es posible escribir una condición compuesta a partir de varias condiciones simples. Los operadores lógicos actúan sobre los resultados individuales de las expresiones relacionales (condiciones simples) para dar lugar a un resultado lógico global.

Ejemplo 1.12. Desarrollar un programa que ilustre el funcionamiento de los operadores lógicos (&&, || y !). Para ello, solicitará al usuario que escriba dos valores lógicos (uno o cero) y posteriormente imprimirá por pantalla los resultados de aplicar estos operadores a los valores anteriores.

#include <stdio.h>

int main() {

  int a, b;

  printf("\nIntroducir dos valores de verdad (uno o cero): ");
  scanf("%d %d", &a, &b);

  printf("\n%d && %d -> %d.", a, b, a && b);
  printf("\n%d || %d -> %d.", a, b, a || b);
  printf("\n!%d -> %d.", a, !a);
  printf("\n!%d -> %d.\n\n", b, !b);

  system("pause");
  return 0;
}

El operador sizeof() devuelve el tamaño en bytes de la expresión o del tipo de dato que se le pase como argumento.

Ejemplo 1.13. Escribir un programa que muestre en pantalla los tamaños de los tipos de los datos elementales. No es necesario considerar el modificador unsigned, puesto que no afecta al tamaño de los tipos modificados.

#include <stdio.h>

int main() {

  printf("\nchar -> %d.", sizeof(char));
  printf("\nshort -> %d.", sizeof(short));
  printf("\nint -> %d.", sizeof(int));
  printf("\nlong -> %d.", sizeof(long));
  printf("\nfloat -> %d.", sizeof(float));
  printf("\ndouble -> %d.", sizeof(double));
  printf("\nlong double -> %d.\n\n", sizeof(long double));

  system("pause");
  return 0;
}

Ejercicio: Modificar el programa del ejemplo 1.13 para que imprima por pantalla los tamaños de distintas expresiones cuyos tipos coincidirán con los que aparecen en la versión original del código.

Ejercicios de afianzamiento.