Evolución del Lenguaje C

A mediados de los años 60s, Martin Richards diseñó el lenguaje BCPL con la finalidad de usarlo para escribir software de sistemas operativos y compiladores.
En 1969, Ken Thompson escribió el Lenguaje B, en Bell Laboratories, con el objetivo de recodificar UNIX (escrito hasta ese momento en lenguaje ensamblador) usando un lenguaje de alto nivel más portable y flexible.

Durante los siguientes años, Dennis Ritchie modificó el lenguaje B, llegando a crear el lenguaje C y reescribiendo el sistema UNIX en dicho lenguaje; añadió características nuevas, como son el diseño de tipos y las estructuras de datos.

En 1978, Dennis Ritchie y Brian Kernighan publicaron la primera edición del libro El lenguaje de programación C. Este libro fue durante años la especificación informal del lenguaje. El lenguaje descrito en la primera edición de este libro, fue conocido como "el C de Kernighan y Ritchie" o simplemente "K&R C". En este libro se introdujeron nuevas características al lenguaje: los tipo de datos struct, long int y unsigned int; los operadores =+ y =- fueron sustituidos por += y -=.
A mediados de los años 80, Bjarne Stroustrup (también de los laboratorios Bell), crea el lenguaje C++, un lenguaje basado en C, con numerosas características adicionales, siendo la principal que está orientado a objetos. Si bien se han creado muchos lenguajes basados en C, C++ es el que ha permanecido más asociado a C.

En los años siguientes a la publicación del C de Kernighan y Ritchie, se añadieron al lenguaje muchas características no oficiales, que estaban presentes en algunos compiladores y no en otros. Fue por ello que en 1989 ANSI (American National Standards Institute) publicó el primer estándar oficial de C, que es conocido como ANSI C.

En este estándar se tomaron muchas de las funcionalidades no oficiales y se agregaron funcionalidades nuevas como los prototipos de función, y un preprocesador mejorado. También se cambió la sintaxis de la declaración de parámetros de funciones, para que incluyeran el tipo junto con el nombre.

Al año siguiente, en 1990 se publicó la estandarización ISO del lenguaje. Este estándar es básicamente el estándar ANSI, con unas pocas modificaciones de formato. A este estándar se lo conoce, entonces, como C89, o C90, y se trata del mismo lenguaje.
Basándose en el estándar ANSI que estaba en preparación, en 1988 Kernighan y Ritchie publicaron la segunda edición de su libro, que es aún hoy utilizada como una de las referencias principales del lenguaje.
Durante los siguientes años, el lenguaje C permaneció sin demasiados cambios. Sin embargo, como había sucedido antes, los distintos compiladores fueron incorporando características adicionales, que otros compiladores no tenían, siendo C++ la principal influencia.
Fue por ello que a finales de los noventa se decidió revisar el estándar de C, lo que llevó a la publicación del estándar C99. Este estándar incluye varias nuevas características como son: las funciones inline; la posibilidad de declarar variables en cualquier parte del código; los comentarios de una sola línea utilizando //; los tipos de datos long long int, bool y complex, entre otras.
Aún hoy el proceso de evolución del lenguaje sigue avanzando, y desde 2007 se está trabajando en el armado de un nuevo estándar.

Historia del Lenguaje C

En 1978, Ritchie y Brian Kernighan publicaron la primera edición de El lenguaje de programación C, también conocido como La biblia de C. Este libro fue durante años la especificación informal del lenguaje. El lenguaje descrito en este libro recibe habitualmente el nombre de "el C de Kernighan y Ritchie" o simplemente "K&R C" (La segunda edición del libro cubre el estándar ANSI C, descrito más abajo).

Kernighan y Ritchie introdujeron las siguientes características al lenguaje:

1. El tipo de datos struct.
2. El tipo de datos long int.
3. El tipo de datos unsigned int.

Los operadores =+ y =- fueron sustituidos por += y -= para eliminar la ambigüedad sintáctica de expresiones como i=-10, que se podría interpretar bien como i =- 10 o bien como i = -10.
El C de Kernighan y Ritchie es el subconjunto más básico del lenguaje que un compilador debe de soportar. Durante muchos años, incluso tras la introducción del ANSI C, fue considerado "el mínimo común denominador" en el que los programadores debían programar cuando deseaban que sus programas fueran transportables, pues no todos los compiladores soportaban completamente ANSI, y el código razonablemente bien escrito en K&R C es también código ANSI C válido.
En las primeras versiones del lenguaje, la definición de funciones se hacía mediante un 'prototipo de función' (function prototype), el cual indicaba al compilador el tipo de retorno de la función. Aunque este método tiene una gran desventaja respecto al nuevo, debido a que no comprueba el número ni el tipo en la lista de argumentos; en otras palabras, es mucho más fácil cometer errores al hacer una llamada a una función con argumentos incorrectos.


Ejemplo del "viejo estilo":

int power(); /* Podria haberse omitido (*) */

power()
int a, b;
{
int n;
for (n = 1; b > 0; --b)
n *= a;
return n;
}

Ejemplo de la nueva definición:

int power(int a, int b)
{
int n;
for (n = 1; b > 0; --b)
n *= a;
return n;
}



(*) Por defecto, el tipo de retorno en C es int, por lo que la declaración entera int power(); podría haberse omitido.
En los años siguientes a la publicación del C de Kernighan y Ritchie, se añadieron al lenguaje muchas características no oficiales, que estaba soportadas por los compiladores de AT&T, entre otros. Algunas de estas características eran:

1. Funciones void y el tipo de datos void *.
2. Funciones que retornaban tipos de datos struct o union (en lugar de punteros).
3. Asignación de tipos de datos struct.
4. Calificador const, que hace que un objeto sea de sólo lectura.
5. Una biblioteca estándar, que incorporaba la mayoría de las funcionalidades implementadas por varios desarrolladores de compiladores.
6. Enumeraciones.

• ANSI C e ISO C

A finales de la década de 1970, C empezó a sustituir a BASIC como lenguaje de programación de microcomputadores predominante. Durante la década de 1980 se empezó a usar en los IBM PC, lo que incrementó su popularidad significativamente. Al mismo tiempo, Bjarne Stroustrup empezó a trabajar con algunos compañeros de Bell Labs para añadir funcionalidades de programación orientada a objetos a C. El lenguaje que crearon, llamado C++, es hoy en día el lenguaje de programación de aplicaciones más común en el sistema operativo Microsoft Windows; mientras que C sigue siendo más popular en el entorno Unix. Otro lenguaje que se desarrolló en esa época, Objective C, también añadió características de programación orientada a objetos a C. Aunque hoy en día no es tan popular como C++, se usa para desarrollar aplicaciones Cocoa para Mac OS X.

En 1983, el Instituto Nacional Estadounidense de Estándares organizó un comité, X3j11, para establecer una especificación estándar de C. Tras un proceso largo y arduo, se completó el estándar en 1989 y se ratificó como el "Lenguaje de Programación C" ANSI X3.159-1989. Esta versión del lenguaje se conoce a menudo como ANSI C, o a veces como C89 (para distinguirla de C99).
En 1990, el estándar ANSI (con algunas modificaciones menores) fue adoptado por la Organización Internacional para la Estandarización (ISO) en el estándar ISO/IEC 9899:1990. Esta versión se conoce a veces como C90. No obstante, "C89" y "C90" se refieren en esencia al mismo lenguaje.
Uno de los objetivos del proceso de estandarización del ANSI C fue producir una extensión al C de Kernighan y Ritchie, incorporando muchas funcionalidades no oficiales. Sin embargo, el comité de estandarización incluyó también muchas funcionalidades nuevas, como prototipos de función, y un preprocesador mejorado. También se cambió la sintaxis de la declaración de parámetros para hacerla semejante a la empleada habitualmente en C++:

main(argc, argv)
int argc;
char **argv;
{
...
}

pasó a ser:int main(int argc, char *argv[])
{
...
}



ANSI C está soportado hoy en día por casi la totalidad de los compiladores. La mayoría del código C que se escribe actualmente está basado en ANSI C. Cualquier programa escrito sólo en C estándar sin código que dependa de un hardware determinado funciona correctamente en cualquier plataforma que disponga de una implementación de C compatible. Sin embargo, muchos programas han sido escritos de forma que sólo pueden compilarse en una cierta plataforma, o con un compilador concreto, esto puede ser debido a diversos motivos:
La utilización de bibliotecas no estándar, como interfaces gráficas de usuario.
El uso de compiladores que no cumplen las especificaciones del estándar.
El uso de tipos de datos suponiendo que tendrán el mismo tamaño u orden de los bits en todas las plataformas.
La macro __STDC__ puede usarse para dividir el código en secciones ANSI y K&R para el compilador.

# if __STDC__
extern int getopt(int,char * const *,const char *);
# else
extern int getopt();
# endif



Algunos programadores recomiendan usar "#if __STDC__", como en el ejemplo, en lugar de "#ifdef __STDC__" porque algunos compiladores le asignan el valor cero a __STDC__ para indicar que no son compatibles con ANSI.

• C99

Tras el proceso de estandarización de ANSI, la especificación del lenguaje C permaneció relativamente estable durante algún tiempo, mientras que C++ siguió evolucionando. Sin embargo, el estándar continuó bajo revisión a finales de la década de 1990, lo que llevó a la publicación del estándar ISO 9899:1999 en 1999. Este estándar se denomina habitualmente "C99". Se adoptó como estándar ANSI en marzo de 2000.
Las nuevas características de C99 incluyen:
· Funciones inline.
· Las variables pueden declararse en cualquier sitio (como en C++), en lugar de poder declararse sólo tras otra declaración o al comienzo de una declaración compuesta.
· Muchos tipos de datos, incluyendo long long int (para reducir el engorro de la transición de 32 bits a 64 bits), un tipo de datos booleano, y un tipo complex que representa números complejos.
· Arrays de longitud variable.
· Soporte para comentarios de una línea que empiecen con //, como en BCPL o en C++, característica para la que muchos compiladores habían dado soporte por su cuenta.
· muchas funciones nuevas, como snprintf()
· algunos headers nuevos, como stdint.h.
Una consideración importante es que hasta la publicación de este estándar, C había sido mayormente un subconjunto estricto del C++. Era muy sencillo "actualizar" un programa de C hacia C++ y mantener ese código compilable en ambos lenguajes. Sin embargo, el nuevo estándar agrega algunas características que C++ no admite, como por ejemplo los inicializadores estáticos de estructuras. También define al tipo "bool" de una manera que no es exactamente la del C++.
El compilador GCC, entre muchos otros, soportan hoy en día la mayoría de las nuevas características de C99. Sin embargo, este nuevo estándar ha tenido poca acogida entre algunos desarrolladores de compiladores, como Microsoft y Borland, que se han centrado en C++. Brandon Bray, de Microsoft, dijo a este respecto:
"En general, hemos visto poca demanda de muchas características de C99. Algunas características tienen más demanda que otras, y consideraremos incluirlas en versiones futuras siempre que sean compatibles con C++.

• C11

C11 (antes conocido como C1X) es un nombre informal para ISO/IEC 9899:2011,3 el último estándar publicado para C. El borrador final, N1570,4 fue publicado en abril de 2011. El nuevo estándar superó su última revisión el 10 de octubre de 2011 y fue oficialmente ratificado por la ISO y publicado el 8 de diciembre de 2011.

• C++

Al principio de los 80s, donde Bjarne Stroustrup, diseñó una extensión del lenguaje C, llamándolo C con Clases. El término clase provenía de Simula 67, y servía para entender más el comportamiento del mundo real y llevarlo a los códigos, ocultando los detalles de su implementación.
En 1984, C con Clases fue rediseñado en un compilador y se lo denominó C ++. Como lo indica la nota Data Abstraction in C, en el Técnical Journal de AT&T Bell Laboratories. (vol. 63, núm 8, Octubre 1984). En 1985 estuvo disponible la primera versión del lenguaje C ++ y se realizó el libro de Bjarne Struostrup: The C ++ Programming Languaje, publicado por Addison-Wesley en 1986.
El nombre de C ++, fue porque éste último era una variante del C original. En el lenguaje C, el operador ++ significa, incrementar la variable, se eligió en nombre C ++, debido a que éste agregaba al C original el término de Programación Orientada a Objetos (POO), basadas en Simula 67.
Al ser C ++ una variación de C, los programas codificados en C pueden correr tranquilamente en C ++. En 1990, el lenguaje ha sido descrito por Stroustrup y Ellis en el Annotated C ++ Reference Manual editado por Addison -Wesley, existiendo una versión en español del mismo, con el título de C ++. Manual de Referencia con anotaciones publicado por Addison-Wesley/Días de Santos en 1994.
La versión actual estandarizada por ANSI, la versión 3.0 es la que soportan la mayoría de los fabricantes mundiales, como ser, , AT&T, WatCom, Microsoft, etc, es sus respectivas actualizaciones.
Hoy en día, Borland ofrece el compilador de C++ en la versión 5.5 de forma gratuita.

Sentencias de Control

En C, cualquier expresión finalizada en un punto y coma ; forma una sentencia.
De todos los tipos, las estructuras (o sentencias ) de control son las que controlan la ejecución de las instrucciones de un programa.
La programacion estructurada se basa en la utilización de un reducido número de estructuras
que permiten hacer que un programa sea suficientemente legible, reduciendo considerablemente
el número de errores, y facilitando enormemente la detección y solución de estos.
La característica fundamental de la programación estructurada consiste en que todas las
estructuras tienen un único punto de entrada y un único punto de salida. Esto permite descomponer
fácilmente un problema en subproblemas, reduciendo la complejidad y facilitando la programación.


En C diferenciamos tres tipos de sentencias de control:

1. Sentencias Condicionales
2. Sentencias de Repetición
3. Sentencias de Salto

• Sentencias Condicionales

Hay tres sentencias condicionales en C: if, else y switch


Sentencia if
La sentencia if nos permite elegir si se ejecuta o no un bloque de instrucciones. La "expresión" del if es una expresión que debe ser evaluada: falsa si es cero y verdadera si vale distinto de cero.

Ejemplo:
#include <stdio.h>
int main ()
{
int x;
printf(“Dame un numero”);
scanf(“%d”,&x);
if (x>0) {
printf(“El numero %d es positivo”,x);
}
return 0;
}


Sentencia else
Una sentencia if cuando incluye un else, permite ejecutar un bloque de código si se cumple la condición y otro bloque diferente de código si la condición no se cumple.

Ejemplo:
#include <stdio.h>
void main ()
{
int x;
printf(“Dame un numero: ”);
scanf(“%d”,&x);
if (x>=0) {
printf(“El numero %d es positivo”, x);
} else {
printf(“El numero %d es negativo”, x);
}
}


Sentencia else colgante
Ejemplo:
#include<stdlib.h>
int main()
{
float nota;
printf ("Dame una nota: ")
scanf ("%f", &nota)
if (nota>9){
printf("Sobresaliente");}
else if(nota >=7){
printf("Notable);}
else if(nota >=5){
printf("Aprobado");}
else{
printf ("Suspenso);}
return 0;
}


Sentencia switch
Permite seleccionar entre multiples alternativas posibles. La expresión del switch es una variable int o char, que puede tomar los valores, entre otros, dados por "opción 1", "opcion 2", etc.

Ejemplo:
#include <stdio.h>
void main()
{
int nota;
printf(“Calificación: ”);
scanf(“%d”, &nota);
switch (nota) {
case 0:
case 1:
case 2:
case 3:
case 4:
printf(“Suspenso”);
break;
case 5:
case 6:
printf(“Aprobado”);
break;
case 7:
case 8:
printf(“Notable”);
break;
case 9:
printf(“Sobresaliente”);
break;
case 10:
printf(“Matrícula”);
break;
default:
printf(“Error”);
}
}

• Sentencias de Repetición

Las instrucciones de repetición también llamados bucles, se ejecutan hasta que se cumpla alguna condición predeterminada en el bucle en el caso del “for” o también en los casos del “while” y “do-while”. Podemos destacar los antes mencionados bucles que son los bucles for,while y do-while.



Bucles for:
Tienen una gran potencia y flexibilidad, y tienen un esquema muy sencillo y definido. Este esquema es así:
for(inicialización del bucle; condición; incremento).
Ahora vamos a proceder a definir cada una de las partes del esquema básico, inicialización (exp1): es una asignación que se utiliza para comenzar la variable del bucle, esto es de la variable de la que parte el bucle. Condición (exp2): es una expresión relacional que hace que el bucle concluya cuando no se cumpla. Por último el incremento (exp3): es la parte que determina como cambia la variable hasta que el bucle concluye. Es importante señalar que cada parte ha de ser separado por ; .Para que deje de ejecutarse el bucle como antes hemos mencionado depende de la condición, que deberá de ser falsa para que el bucle se detenga.
Debemos tener en cuenta que a diferencia de otros bucles este no llegará a ejecutarse si la condición es falsa, ya que la condición se comprueba antes de entrar en el bucle.

Un sencillo ejemplo:
#include <stdio.h>
int main( )
{
int x;
for(x=1; x<=100; x++)
printf (“%d”,x);
return 0;
}
Una de las utilidades del bucle for es en el bucle infinito, que pese a que puede hacerse con todos los bucles es el for con el que se usa. Estos bucles infinitos son usados para que el bucle no concluya nunca hasta que en el cuerpo se encuentre un break. Por otro lado la construcción de este bucle for es muy sencilla, for ( ; ; ).



Bucles while:
Tiene cierta semejanza con el bucle for, así es en el uso de una inicialización, una condición y un incremento. Otra de sus similitudes es el momento en el que analizan la condición que en ambos es antes de ejecutar el bucle. Sin embargo, en su esquema básico aunque parezcan diferentes, son el mismo:

while (condición)
{
cuerpo;
incremento;
}

Algunas de las veces podremos saber antes de empezar el bucle cuantas veces se va a ejecutar.



Ejemplo:
char esperar_caracter (void)
{
char c;
c=’\0’;
while (c!=’A’)
c=getchar ( );
return c;
}


Bucles do-while:
Este es el único bucle que al menos se va a ejecutar una vez puesto que este bucle examina la condición una vez se ha ejecutado el bucle, esto es, al final del mismo. El esquema básico de este bucle sería algo así:
do
{
cuerpo;
}
while (condición);

Este bucle es muy útil por ejemplo en menús dado que el menú debe de ejecutarse al menos una vez.

Ejemplo:
#include <stdio.h>
int main()
{
int digito=0;
do {
printf("%d ",digito++);
}
while (digito<=9);
}

• Sentencias de Salto

Hay cuatro sentencias de salto en C: break, return, goto y continue.
Suelen estar condicionadas (que solo las ejecute el programa en un determinado caso).
Se desaconseja la utilización de este tipo de sentencia de control, sobre todo el goto, ya que su uso implica un aumento de la probabilidad de cometer errores, dificulta la legibilidad del código y es mucho mas difícil corregir errores y cambiar secuencias de código.


Sentencia break
La instrucción de salto break se usa para interrumpir (romper) la ejecución normal de un bucle, es decir, la instrucción break finaliza la ejecución de un bucle y, por tanto, el control del programa se transfiere (salta) a la primera instrucción después del bucle.


Ejemplo:
#include <stdio.h>
int main()
{
int n, a;
a = 0;
do
{
printf( "Introduzca un numero entero: " );
scanf( "%d", &n );
if ( n == 0 )
{
printf( "ERROR: El cero no tiene opuesto.\n" );
break;
/* En el caso de que n sea un cero,
el bucle se interrumpe. */
}
printf( "El opuesto es: %d\n", -n );
a += n;
} while ( n >= -10 && n <= 10 );

printf( "Suma: %d", a );
return 0;
}



Sentencia return
La instrucción de salto return es utilizada en lenguaje C para devolver el control de ejecución desde la función que contiene el return a la rutina que la invocó y para indicar el valor de retorno de una función.

Ejemplo:
#include <iostream>
int z;
void funcion();
int main()
{
for(z=0;z<=5;z++)
{
printf("%i\n",z);
funcion();
system("pause");
}
return 0; Indica al ordenador que el programa ha fnalizado sin errores.
}

void funcion()
{
printf("Hola\n");
if(z==3){printf("Z vale 3\n"); return;} El return termina la función y entonces printf("Z no vale 3\n"); no se ejecutará
printf("Z no vale 3\n");
}


Sentencia goto
La instrucción de salto goto se puede usar en un programa, para transferir incondicionalmente el control del mismo a la primera instrucción después de una etiqueta, o dicho de otra forma, al ejecutar una instrucción goto, el control del programa se transfiere (salta) a la primera instrucción después de una etiqueta.

Ejemplo:
#include <stdio.h>
int main()
{
int n, a;
a = 0;
do
{
printf( "Introduzca un numero entero: " );
scanf( "%d", &n );
if ( n == 0 )
{
printf( "ERROR: El cero no tiene opuesto.\n" );
goto etiqueta_1;
/* En el caso de que n sea un cero,
el control de programa salta a la
primera instrucción después de
etiqueta_1. */
}
printf( "El opuesto es: %d\n", -n );
a += n;
} while ( n >= -10 && n <= 10 );

etiqueta_1:
printf( "Suma: %d", a );
return 0;
}



Sentencia continue
La instrucción de salto continue siempre se usa para interrumpir (romper) la ejecución normal de un bucle. Sin embargo, el control del programa no se transfiere a la primera instrucción después del bucle, como sí hace la instrucción break, es decir, el bucle no finaliza, sino que, finaliza la iteración en curso, transfiriéndose el control del programa a la condición de incremento de contadores y después a la condición de salida del bucle, para decidir si se debe realizar una nueva iteración o no.


Ejemplo:
#include <stdio.h>
int main()
{
int n, a;
a = 0;
do
{
printf( "Introduzca un numero entero: " );
scanf( "%d", &n );
if ( n == 0 )
{
printf( "ERROR: El cero no tiene opuesto.\n" );
continue;
/* En el caso de que n sea un cero,
la iteración en curso del bucle
se interrumpe aquí. */
}
printf( "El opuesto es: %d\n", -n );
a += n;
} while ( n >= -10 && n <= 10 );

printf( "Suma: %d", a );
return 0;
}

Elementos del lenguaje C

Los elementos del lenguaje C mas importantes son: Datos, constantes, variables, acumuladores, banderas, contadores, comentarios e identificadores.

• Datos

Las computadoras pueden trabajar con varios tipos de datos, los algoritmos y programas operan sobre estos. Existen dos clases de datos: datos simples y datos compuestos.

Los distintos tipos de datos se representan como un conjunto o secuencia de dígitos binarios (bits). Los lenguajes de programación de alto nivel nos permiten basarnos en abstracciones para no manejar los detalles de representación interna.

Los tipos de datos simples son:

  -Datos numéricos

Este tipo de datos se divide en enteros y reales.

Los enteros son aquellos números que no tienen componente fraccionario o decimal y dentro de la computadora son un subconjunto finito de los números enteros. Estos números pueden ser negativos o positivos y el rango es de –32,768 a 32,767.

El tipo de datos "real" son aquellos números que tienen una parte fraccionaria y pueden ser positivos y negativos dentro de la computadora forman un subconjunto de los números reales. Para representar números muy pequeños o muy grandes se emplea la notación de punto flotante, que es una generalización de la notación científica. En esta notación se considera al número real como mantisa y al exponente la potencia de 10 a la que se eleva este número.

 -Datos lógicos

Este tipo de dato es aquel que solo puede tomar uno de 2 valores: verdadero (true) o falso (false). En lenguaje C no existe el tipo lógico pero se puede implementar con un número entero conociendo que 0 es falso y cualquier número diferente de cero verdadero.

 -Caracteres

El dato tipo carácter puede tomar un valor de un conjunto finito y ordenado de caracteres o símbolos que la computadora reconoce (código ASCII). Este tipo de dato ocupa un byte y almacena un solo carácter.

Existe también el dato tipo cadena (compuesto) que es una sucesión de caracteres que se encuentran delimitados por comillas, la longitud de una cadena es el número de caracteres comprendidos entre los delimitadores.

• Constantes y variables

Una variable es un dato cuyo valor puede cambiar durante el desarrollo del algoritmo o ejecución del programa. Hay diferentes tipos de variables: enteras, reales, caracteres y cadenas. Una variable que es de cierto tipo solo puede tomar valores que correspondan a ese tipo. Si se intenta asignar un valor de tipo diferente se producirá un error.

Una variable se identifica por dos atributos: el nombre de la variable (identificador) y el tipo de la variable. El identificador se puede formar con caracteres alfanuméricos y el carácter de subrayado ( _ ) empezando siempre por una letra. No se admiten como identificadores palabras reservadas del lenguaje de programación que se esté utilizando. Los nombres de variables que se elijan para el algoritmo o programa deben ser significativos y tener relación con el objeto que representa. En lenguaje C la sintaxis para definir una variable es:

tipo_de_dato identificador;

Las constantes son expresiones con un significado invariable. La representación más simple de un concepto de este lenguaje son las constantes.

Al contrario que las variables, las constantes mantienen su valor a lo largo de todo el programa.
Para indicar al compilador que se trata de una constante, usaremos la directiva #define
#define <identificador> <valor>

Observa que no se indica el punto y coma de final de sentencia ni tampoco el tipo de dato.
La directiva #define no sólo nos permite sustituir un nombre por un valor numérico, sino también por una cadena de caracteres.
El valor de una constante no puede ser modificado de ninguna manera.

/* Uso de las constantes */
#include <stdio.h>
#define pi 3.1416
#define escribe printf
main() /* Calcula el perimetro */
{
int r;
escribe("Introduce el radio: ");
scanf("%d",&r);
escribe("El perimetro es: %f",2*pi*r);
}

• Acumulador

Un acumulador o totalizador es una variable cuya función es almacenar cantidades resultantes de operaciones sucesivas. Realiza la misma función que un contador con la diferencia de que el incremento o decremento es variable en lugar de constante.

int acumulador = 0;

acumulador = acumulador + valor;

acumulador += valor;

• Banderas

Una bandera, también denominada interruptor o conmutador es una variable que puede tomar uno de dos valores (verdadero o falso) a lo largo de la ejecución del programa y permite comunicar información de una parte a otra del mismo.

int primo;

primo = 0;

primo = 1;

• Contador

Los procesos repetitivos requieren contar los sucesos y acciones internas, una forma de hacerlo es mediante un contador. Un contador es una variable cuyo valor se incrementa o decrementa en una cantidad constante en cada repetición. La forma en que se construye un contador es la siguiente:

int contador = 1; //variable con valor inicial de 1

contador = contador+1;

contador += 1;

contador ++;

• Operadores 

Los operadores son palabras o símbolos que hacen que un programa actúe sobre las variables.
En C existen diversos tipos de operadores. Aritméticos, relacionales, de asignación, lógico.

• Sentencias 

Una sentencia es una expresión en C donde se esperan unas consecuencias, normalmente son las instrucciones, cada sentencia finaliza con un punto y coma.

Introducción al lenguaje C

Luego de la aparición de B y BCPL, en los Laboratorios Bell, Ken Thompson modeló muchas características sacadas de su lenguaje B, según las equivalentes en BCPL, con B creó las primeras versiones del sistema operativo UNIX, durante los 70's, en una computadora DEC PDP-7.

Creado entre 1970 y 1972 por Brian Kernighan y Dennis Ritchie para escribir el código del sistema operativo UNIX.

Desde su nacimiento se fue implantando como el lenguaje de programación de sistemas favorito para muchos programadores, sobre todo por ser un lenguaje que conjugaba la abstracción de los lenguajes de alto nivel con la eficiencia del lenguaje máquina. Los programadores de sistemas que trabajaban sobre MS-DOS y Macintosh también utilizaban C, con lo cual la práctica totalidad de aplicaciones de sistema para micro-ordenadores y para sistemas UNIX está escrita en este lenguaje.

A mediados de los ochenta el C se convierte en un estándar internacional ISO. Este estándar incluye tanto la definición del lenguaje como una enorme biblioteca de funciones para entrada/salida, tratamiento de textos, matemáticas, etc.

A mediados de los ochenta se crea el C++, extensión de C orientada a objetos. El C++ se convierte en estándar ISO en 1998. En el momento actual, el lenguaje C no va a modificarse más. Será el C++ el que incorporará nuevos cambios. 

El lenguaje C tiene ciertas características, la cuales se muestran a continuación:

• Orientado a la programación de sistemas
• Es altamente transportable
• Es muy flexible
• Genera código muy eficiente
• Es muy expresivo (se pueden realizar muchas funciones escribiendo pocas líneas de código)
• Es muy poco modular
• Hace pocas comprobaciones
• Da poca disciplina al programador
• Es difícil leer código escrito por otras personas