INTRODUCCIÓN AL LENGUAJE C (BÁSICO). (ACTUALIZADO EL 14/12/04)

[Griph]

ÍNDICE:

INTRODUCCIÓN AL LENGUAJE C.


1) Los Programas en Lenguaje C.

A) Primera aplicación: “Hola Mundo”.
B) La función “main” (principal).
C) Las sentencias y el punto y coma.
D) Archivos de encabezado (headers).
E) Caracteres de Control.
F) Cadenas de caracteres.
G) Compilación de fuentes (Proceso de Compilación).

2) La Función "printf".

A) Cadenas de Texto.
B) Enteros.
C) Números Reales.
D) Caracteres.

3) Tipos de Datos.

A) Rangos de Valores.
B) El Tipo Carácter.

4) Definición de variables.

5) Asignaciones y Expresiones.

A) Operadores Aritméticos.
B) Operadores Combinados.
C) El Operador de Incremento y Decremento.
D) Prioridad de los operadores.
E) Funciones.
F) Conversión de Tipos.

6) La Función scanf.

7) Los Comentarios.

8) Definición de Constantes.

9) Sentencias Compuestas.

A) Las sentencias if~then~else.
B) Condiciones.
C) Operadores Lógicos
D) La Sentencia if~then
E) Instrucción Condicional Anidada



Para más información acerca de bibliografía sobre el lenguaje C:
]http://foro.elhacker.net/index.php/topic,78431.0.html

[Griph]

INTRODUCCIÓN  AL LENGUAJE C (BÁSICO):

La mayoría de los lenguajes de programación de alto nivel que se construyen, tienen como objetivo adaptarse a la forma de pensar de las personas y desligar de la mejor manera posible aspectos referentes a la arquitectura del computador. Pero, una gran cantidad de aplicaciones (programas o software) requieren de un contacto directo sobre sus componentes, como los sistemas operativos y los programas de hardware – drivers - que controlan las impresoras, módems, etc. (es decir requieren de una programación a un nivel medio o bajo). Por otro lado, existen muchas aplicaciones que simplemente necesitan ejecutarse en menor tiempo y, sin embargo,  el lenguaje que usan no les permite tener un buen desempeño.

Cuando era necesario un programa con tales características, se recurría principalmente al lenguaje ensamblador. Este permite trabajar directamente con las instrucciones y el hardware de la máquina, obteniendo así un rendimiento óptimo (es el lenguaje de bajo nivel). No obstante, cuando se trabaja con el lenguaje ensamblador surgen varios inconvenientes: es diferente para cada computador y es necesario de un conocimiento muy profundo del hardware utilizado; además aunque en la mayoría de los casos se logra una mejora significativa, es necesario un programador con experiencia (si se quiere hacer algo serio y lo más óptimo o eficaz posible, como en todo lenguaje).

Por estas razones, durante mucho tiempo se mantuvo la necesidad de un lenguaje sencillo y fácil de implantar en cualquier ordenador, usando/combinando las estructuras y ventajas de los lenguajes de alto nivel con las ventajas del lenguaje de máquina.

El primer lenguaje del cual se confirmaron estas características fue BCPL, creado por Martin Richards en la Universidad de Cambridge. Muchas de las ideas de ese lenguaje fueron utilizadas por Ken Thompson, quien en 1970 creó el lenguaje B; para el primer sistema operativo UNIX. Posteriormente Dennis Ritchie (que trabajaba con Thompson en Bell Laboratories) convierte el lenguaje B en C, el cual hereda muchas características originales del BCPL.

En el año 1978 Brian Kernighan junto con Dennis Ritchie escriben y publican el libro “The C programming Languaje”, donde se encuentra la definición para el lenguaje C. Este libro además de difundir el lenguaje sirvió durante mucho tiempo (mejor dicho muchos años) como manual de referencia. Debido a su gran aceptación y popularidad, en 1983 el “Instituto Nacional Americano de estándares” (ANSI), estableció un comité para proporcionar una definición moderna y comprensible del lenguaje. De este comité surgió la definición estándar ANSI o “ANSI C” que se usa hoy en día y consta de 32 palabras reservadas.

Inicialmente el lenguaje se relacionó muy directamente con el sistema operativo (SO) UNIX, ya que de las 13.000 líneas de código que lo componen, sólo unas 800 está escritas en lenguaje ensamblador, y el resto, un 93%, están escritas en C. Gracias a que el lenguaje no está ligado a ninguna computadora en particular, UNIX es un sistema operativo que se encuentra disponible para CASI todos los computadores.

Dado que el lenguaje C está cercano al bajo nivel, el código producido es muy rápido (hablando de velocidad, no del desarrollo de las aplicaciones) y compacto. Gracias a todas sus propiedades, C es considerado como un lenguaje de propósito general. Por esto no sólo el SO UNIX y sus aplicaciones se escriben en él, sino que una gran cantidad de aplicaciones de gran importancia  como los sistemas operativos. (Se destaca por el desarrollo de este tipo de aplicaciones, aunque es de propósito general).

En la actualidad se encuentran compiladores de C para casi todos los computadores. Su utilización ha permitido a una gran cantidad de casas de software, desarrollar aplicaciones que se pueden trasladar con facilidad entre máquinas tan diferente como las Apple de Macintosh y los IBM-PC.

[Griph]

1) Los Programas en Lenguaje C:


A) La Primera Aplicación: “Hola Mundo”:

A continuación el programa que imprime en pantalla el mensaje “Hola Mundo”:

Código:

#include <stdio.h>

main()
{
printf(“Hola Mundo\n”);
}

C es un lenguaje estructurado; pero no obstante no es tan estricto, lo cual lo hace más agradable y flexible. Sin embargo hay que ser cuidadoso, esa flexibilidad puede jugar en contra.

Al observar este programa:

Código:

#include <stdio.h>

main()
{
printf(“Hola Mundo”);
}

podemos ver la definición de la función main:

Código:

main()

En este caso, no se usaron argumentos. Pero siempre hay que colocar los paréntesis.

B) La función “main” (principal):

La función main es una función privilegiada dentro del lenguaje. Se puede decir que ejecutar un programa en C es ejecutar la función main, dado que lo primero que hace cualquier programa es invocar esta función. Si en el momento en el que se compila el código fuente falta la definición de esta función el compilador dará/mostrará un mensaje de error, indicando la falta de la definición de la misma.

Para definir un bloque de instrucciones se usan los símbolos abrir y cerrar llaves { }.

C) Las sentencias y el punto y coma:

El cuerpo de la función main, conforma el cuerpo del programa y consiste en una secuencia de sentencias. Estas pueden ocupar más e incluir cualquier cantidad de espacios y tabulaciones; además, el punto y coma sigue una regla simple: siempre se utiliza al final de cada instrucción. En el primer programa se encuentra la siguiente sentencia:

Código:

printf (“Hola Mundo\n”);

D) Archivos de encabezado (headers):

A diferencia de, por ejemplo el lenguaje Pascal, no existe ninguna palabra reservada para la entrada y salida (de datos) como read y write. No obstante, C proporciona un conjunto de librerías donde se definen las funciones (como printf) para realizar estas operaciones. Las declaraciones se encuentran en el archivo stdio.h en un directorio que conoce el compilador (simplemente, algo lógico). Este fichero/archivo se copia dentro del código fuente, por medio de la directiva:

Código:

#include <stdio.h>

esto es para que se pueda utilizar la función printf y demás funciones de entrada y salida dentro del programa, Ej.: scanf. Entonces los archivos que se incluyen por medio de la directiva #include al comienzo de los programas se denominan archivos de encabezados o headers, en inglés.

E) Caracteres de Control:

La función printf se utiliza para imprimir en la pantalla y no coloca automáticamente el cursor en la siguiente línea. Pero se puede colocar en la siguiente línea escribiendo el carácter de “nueva línea” mediante la secuencia “\n”. El lenguaje C proporciona una cantidad de símbolos especiales para los caracteres de control, todos los cuales comienzan con el carácter de división invertido “\” o barra invertida. A estas secuencias de símbolos se las llama secuencias de escape y se pueden usar dentro de cualquier texto. Cada secuencia de escape, aunque puede tener dos o tres símbolos, representa un solo carácter.

Las secuencias de escape son las siguientes:
__________________________________________________
|Secuencia de escape:  |  Carácter que representa:|

\a   ================--->  Carácter de alarma (campana).
\b   ================--->  Retroceso.
\f    ===============--->  Avance de línea.
\n   ================--->  Nueva Línea.
\r    ===============--->  Regreso de carro.
\t    ===============--->  Tabulador Horizontal.
\v   ================--->  Tabulador Vertical.
\\    ===============--->  Diagonal invertida ( \ ).
\?   ================--->  Interrogación.
\’    ===============--->  Apóstrofe.
\’’   ===============--->  Comillas.

Cuando se necesitan caracteres difíciles de escribir se puede utilizar la barra invertida ( \ ). Seguida de un número: en octal de 3 dígitos o un número en hexadecimal de 2 dígitos, el cual debe comenzar con un “x”.

Ejemplo:

Octal: \013. Es la Tabulación Vertical. Y \007 es el carácter de alarma.
Hexadecimal:  \x0b. Es la Tabulación Vertical. Y \x07 es el carácter de alarma.

El siguiente programa da el mismo resultado que el programa “Hola Mundo”:

Código:

#include <stdio.h>

main()
{
printf(“Este es”);
printf(“mi segundo”);
printf(“programa en C.”);
printf(“\n”);
}

Dará como resultado:

Código:

Este es mi segundo programa en C.

F) Cadenas de caracteres.

Podemos notar que los textos se delimitan entre comillas dobles ( “ ). Los textos reciben el nombre de cadenas de caracteres o constantes de cadena.

G) Compilación de fuentes (Proceso de Compilación):

El lenguaje C es un lenguaje compilado (es decir que se traduce a un archivo de lenguaje de máquina – 01110101... -, como cualquier lenguaje compilado), y el proceso de compilación en algunas máquinas puede requerir de múltiples etapas para que se pueda obtener un programa que se pueda ejecutar. Hoy en día esto ya no es tan así, dado que existen compiladores como Dev-C++, Visual C++, Borland, etc. que generan un ejecutable con tan sólo apretar una tecla. Por ejemplo en Dev-C++, la tecla F9. Esto siempre y cuando el programa no tenga algún que otro “bug”, en este caso el compilador dará aviso del mismo; y tendremos que depurarlo (limpiarlo), aunque hay veces en que el compilador no te avisa de ciertas irregularidades de la aplicación (el programa).

Lo primero que se hace es utilizar un editor de texto o procesador de palabras para escribir el código fuente (Ej.: el Block de Notas, aunque hay otros que tienen la capacidad de marcar la sintaxis del lenguaje. Yo he usado - cuando no tenía un IDE - el EmEditor y el UltraEdit que son bastante buenos, pero hay muchos como éstos). Luego se debe guardar en un archivo cuyo nombre termina en “.c”. Después se utiliza el compilador junto con el nombre del archivo que contiene el programa para que lo convierta en el código de máquina.

Una vez que se ha compilado el programa, el traductor crea un archivo que contiene las instrucciones de máquina (10100110...), el cual se llama programa objeto. No obstante, dependiendo del sistema operativo utilizado, el programa objeto puede necesitar de algunos pasos adicionales para ejecutarlos.

El compilador de C, a diferencia de - por ejemplo - el QBasic, no se incluye con el sistema operativo DOS o Windows y debe adquirirse en algún comercio donde vendan programas para ordenadores. Cabe destacar que no ocurre lo mismo en sistemas UNIX o GNU/Linux (respecto de este ultimo véase "gcc", compilador para sistemas GNU/Linux).
Respecto de Qbasic: Lo mencioné como un lenguaje del cual se incluía un compilador, en los sistemas operativos, porque en una época fue así. Luego de unos años este fue un poco olvidado, y, en consecuente, llegó algo nuevo llamado Visual Basic.

En fin, en este momento ,a la hora de compilar un código fuente, no hacen falta pasos adicionales para el programa objeto. Dado que los compiladores de hoy en día lo hacen casi todo por el programador, respecto de la compilación.

[Griph]

2) La Función "printf".

En el primer programa se utilizó la función printf para imprimir en pantalla el famoso "Hola Mundo". Entonces decimos que la función printf tiene el objetivo de imprimir información en pantalla. Dado que printf en C es una función, se deben encerrar sus argumentos entre paréntesis y separados por comas (" , ").

Un ejemplo de la utilización de la función printf:

Código:

//Lamamos un archivo [i]header[/i] o de encabezado.
#include <stdio.h>

main()
{

//Declaramos una variable.
int a = 2;

//Finalmente los ejemplos de la función printf:
printf("Que tal gente, cómo andan. ");
printf("En el mensaje anterior el cursor queda en la misma línea, ahora no.[b]\n[/b]");
printf("Y ahora mostramos el valor de la variable 'a': [b]%i[/b].", [b]a[/b]);
}

Entonces, el resultado de esta Aplicación es:

Código:

Que tal gente, cómo andan. En el mensaje anterior el cursor queda en la misma línea, ahora no.
Y ahora mostramos el valor de la variable 'a': 2.

A) Cadenas de Caracteres Textos:

Como printf es una función de propósito general para dar formato de salida y no una instrucción del lenguaje, el primer argumento siempre debe ser una cadena de caracteres que indica cómo y en dónde se imprime cada uno de los argumentos restantes.

Por ejemplo:

Código:

printf("%s%s%s%s\n", "Uso", "de", "múltiples", "argumentos");

Esto produce como resultado en la pantalla:

Código:

Uso de múltiples argumentos

Cada %s en la cadena que se coloca como primer argumento es sustituida por cada uno de los argumentos restantes, respectivamente. Por ejemplo, sino se incluye uno de los %s, como en:

Código:

printf("%s%s%s\n", "Uso", "de", "múltiples", "argumentos");

Se obtiene el siguiente resultado:

Código:

Uso de múltiples

Podemos notar que no se imprime el último de los argumentos, ya que no se especificó en la cadena la existencia del mismo. Se debe tener cuidado en no especificar un argumento inexistente, ya que produce resultados inesperados. La secuencia %s significa que el argumento es una cadena de caracteres.

Se puede utilizar un tabulador para separar los diferentes argumentos utilizado el carácter de escape "\t". Por ejemplo:

Código:

printf("Uso del\t tabulador.");

Imprime en pantalla:

Código:

Uso del tabulador.

B) Enteros:

Para imprimir en números enteros se utiliza la secuencia %d, de modo que la proposición:

Código:

printf("Este es un número entero: [b]%d[/b]", [b]5[/b]);

Imprime en pantalla:

Código:

Este es un número entero: 5

Cada construcción % debe coincidir con cada argumento, así el primer % debe coincidir con el primer argumento, el segundo % con el segundo argumento, etc., etc., y deben corresponder tanto en el número como en el tipo de los argumentos; de lo contrario se obtienen resultados incorrectos. Dado que printf no forma parte del lenguaje; es una biblioteca que pueden acceder los programas escritos en C. No obstante su comportamiento está bien definido en el estándar ANSI y su utilización es la misma en cualquier compilador o biblioteca (librería) que cumpla con éste.

C) Número Reales:

Cuando se visualizan en C números con decimales, la función printf utiliza la secuencia %f. Por ejemplo:

Código:

printf("[b]%f[/b]\n", [b]15.0[/b]);

Produce el siguiente resultado:

Código:

15.000000

D) Caracteres

Los caracteres individuales, cuando no forman parte de una cadena, se representan dentro del lenguaje  encerrándolos entre comillas simples. Por ejemplo, el carácter A se escribe como 'A'. De la misma forma, los caracteres de control se pueden escribir en forma individual como '\t' para el tabulador, '\n' para una nueva línea, '\b' para el carácter de retroceso, etc.

Para visualizar un carácter se utiliza la secuencia %c, de esta manera se pueden imprimir las diferentes letras:

Código:

printf("Esta es una letra %c\n", 'a');

e imprimir los caracteres de control:

Código:

printf("Esta es una tabulación |%c|\n", '\t');

[Griph]

3) Tipos de Datos:

En el lenguaje C todos los datos que se definen deben pertenecer a una categoría o tipo específico. A continuación se presentan los tipos básicos que se posee el lenguaje:

1_ char: se utiliza para almacenar un carácter.
2_ int: números enteros.
3_ long: números enteros largos.
4_ float: números reales o de punto flotante de precisión simple.
5_ double: números reales o de punto flotante de precisión doble.

A) Rangos de Valores.

Como no es posible representar en el computador todos los valores enteros y reales que existen, cada compilador en particular define un número máximo y mínimo que pueden ser utilizados con estos números. Hay que tener un poco de cuidado de no sobrepasar estos valores ya que producen resultados "inesperados" en los cálculos. El lenguaje C proporciona al menos dos tipos de enteros (normal y largo) y dos tipos de números reales (de precisión simple y doble). Los números reales se pueden escribir en forma natural como 123.46, 0.0234, 234E-3, .01234, etc., etc.

A continuación se presentan los rangos de valores que se utilizan frecuentemente en los compiladores:
___________________________________
Tipo de datos:   Rangos de Valores:
int ================> Entre -32. 768 y 32.767
long ===============> Entre -2.147.483.648 y 2.147.483.647
float ==============> Alrededor de ±1.7E+38 con una precisión de 7 dígitos en la mantisa (o sea la parte decimal de un logaritmo).
double  ============> Alrededor de ±1.5E308 con una precisión de 15 dígitos en la mantisa.

B) El Tipo Carácter:

El tipo de datos char se usa para representar un carácter. Los caracteres están representados por el número que le corresponde según la tabla ASCII, es decir un valor entre 0 y 255. Por lo tanto es lo mismo hablar del carácter 'A' que del número 65. Sin embargo no hace falta conocer de memoria los números asociados con las letras; C permite utilizar los caracteres encerrados entre apóstrofes para representarlos. Por ejemplo 'A', 'a', '0', etc.

Como los caracteres están enumerados según la tabla ASCII, se garantiza que están ordenados de la "A" a la "Z". En consecuente 'A' es menor que 'B', 'B' es menor que 'C', etc. De la misma forma están ordenados los caracteres en minúscula y los dígitos del '0' al '9'.

Para entender un poco mejor la representación que usa el lenguaje C para los caracteres, se puede probar el siguiente programa que imprime con el formato de carácter y número diferentes letras y dígitos:

Código:

#include <stdio.h>

main()
{
printf("Carácter\tNúmero\n");
printf("'%c'\t\t%d\n", 'A', 'A');
printf("'%c'\t\t%d\n", 'B', 'B');
printf("'%c'\t\t%d\n", 'Z', 'Z');
printf("'%c'\t\t%d\n", 'a', 'a');
printf("'%c'\t\t%d\n", 'b', 'b');
printf("'%c'\t\t%d\n", 'z', 'z');
printf("'%c'\t\t%d\n", '0', '0');
printf("'%c'\t\t%d\n", '1', '1');
printf("'%c'\t\t%d\n", '2', '2');
printf("'%c'\t\t%d\n", '3', '3');
}

En C no existe el tipo de datos booleanos; no obstante, el valor de verdad falso se representa con 0 y el valor verdadero se representa con cualquier valor diferente de cero. Además, C no hace chequeo fuerte de tipos, por lo que es responsabilidad del programador el uso correcto de los mismos.

Por la forma tan flexible de representar y utilizar los datos en C, como la representación de la información numérica o simbólica indistintamente, y por no presentar restricciones como el chequeo fuerte de tipos, se dice que C es un lenguaje de nivel medio o bajo.

[Griph]

4) Definición de Variables:

Bien, al igual que en el lenguaje Pascal, los identificadores que no forman parte del lenguaje deben ser declarados antes de utilizarse. Como es habitual, todo identificador no puede comenzar por un dígito, tampoco se permiten espacios, letras acentuadas o cualquier otro tipo de símbolos en los nombres. Se puede utilizar el carácter subrayado y no debe coincidir con ninguna palabra reservada o nombre de función definida anteriormente.

Las variables se definen en el comienzo de cualquier bloque o sentencia compuesta del programa, y sólo se pueden utilizar dentro del bloque y subloques que la contienen (aunque hay variables globales y locales...).

Variable Local:

Código:

#include <stdio.h>

main()
{
int x=5;
printf(“El valor de la variable ‘x’ es: %i”, x);
}

Variable Global:

Código:

#include <stdio.h>

main()
{
int y=6;
printf(“El valor de la variable ‘y’ es: %i”, y);
}

Para aclarar un poco esto de la definición de variables se puede analizar el programa que calcula el área de un triángulo de base 6 y altura 10:

Código:

#include <stdio.h>

main()
{
float area;
area=(5*6)/2.0;
printf(“El área del triángulo es: %f”, area);
}

Las variables se definen colocando el tipo de datos seguido del nombre de la variable. En la quinta línea de este programa se declara la variable area del tipo float. Esta declaración significa que en el bloque del programa se utiliza la variable area, la cual puede almacenar un número real (con decimales) de precisión simple.

La declaración de las variables de los demás tipos se hace de manera similar, utilizando la palabra correspondiente al tipo de datos, en lugar de la palabra float en la declaración.

Otro ejemplo puede ser el programa para el cálculo del área de un  triángulo (esto es para introducir un pequeño dato, de forma un poco didáctica):

Código:

#include <stdio.h>

main()
{
double area;
int b;
int h;

b=5;
h=6;
area=(b*h)/2.0;
printf(“El área del triángulo es: %f”, area);
}

Cuando se declaran variables del mismo tipo, se puede simplificar la declaración separándolas con coma ‘ , ’:

Código:

#include <stdio.h>

main()
{
double area;
int b=5,h=6;

area=(b*h)/2.0;
printf("El área del triángulo es: %f", area);
}

[Griph]

5) Asignaciones y Expresiones:

En el lenguaje C se utiliza el símbolo “=” para hacer realizar las asignaciones.

Ejemplos:

Código:

a = 1;
b = 23;
area = (a*b)/2.0;

Las variables almacenan el valor que se expresa en el lado derecho de la asignación. Cuando se utiliza el mismo nombre de variable en el lado derecho, primero se evalúa la expresión con el valor esta variable, y posteriormente se realiza la asignación. Por ejemplo:

Código:

x = 5;
x = x + 1;

Primero se calcula la expresión con el valor actual de la x, es decir la expresión x + 1 es igual a 5+1 =6. Posteriormente se realiza la asignación, x =6. Por lo tanto no hay ningún problema en utilizar la misma variable que se encuentra al lado izquierdo de la asignación en la expresión del lado derecho.

Además, está permitido la utilización de las asignaciones en la declaración de las variables para darles un valor de inicialización. Por ejemplo, en el programa del area del triángulo, se hizo esto respecto de las variables h y b en la declaración:

Código:

#include <stdio.h>

main()
{
double area;
int b=5,h=6; //En esta línea vemos la inicialización en la declaración de las variables.

area=(b*h)/2.0;
printf("El área del triángulo es: %f", area);
}

Como se ha mencionado anteriormente, no hay chequeo fuerte de tipos, y además hay una gran libertad en la forma en que se pueden realizar las asignaciones. Por lo tanto, aunque no tiene sentido, es válido multiplicar caracteres con números de punto flotante (números reales), y asignar el resultado a un número entero. Por ejemplo, el siguiente programa en C es correcto (en lenguajes como Pascal tiraría un montón de errores):

Código:

#include <stdio.h>

main()
{
int x;

x = ‘A’*5.12;
printf(“El valor de ‘x’ es: %d”, x);
}

No obstante no se debe abusar de la flexibilidad. Por otro lado hay que tener en cuenta que no en todos los compiladores podremos hacer uso de tanta flexibilidad, tal vez algunos nos permitan ejecutar los programas desarrollados sin ningún error, tal vez otros nos den algún que otro warning pero de todas formas podamos ejecutar la aplicación (lo que ocurre con el Dev-C++ si ejecutamos el programita anterior).

A) Operadores Aritméticos:

Las expresiones pueden contener números, variables y funciones relacionadas con los operadores del lenguaje.

Las siguientes son las operaciones que se pueden realizar con las expresiones aritméticas:
_______________________________________________________________________
Operador:     Operación:          Ejemplo:         Resultado:
+   ==============> Suma   =================> 2+500   =====> 502
-   ==============> Resta   ================> 23-6   ======> 17
*   ==============> Multiplicación   =======> 5*5   =======> 25
/   ==============> División   =============> 5.0/3   =====> 1.666...
/   ==============> División Entera   ======> 5/3   =======> 1
%   ==============> Módulo o Resto   =======> 22 % 5   ====> 2

El módulo tiene el mismo significado que en lenguajes como BASIC, en fin lo que hace es recoger el resto de la división (como su otro nombre lo dice/indica). Por otro lado no existe un operador a parte para la división entera. La regla para realizar una división entera es la siguiente: si los operandos, tanto el numerador y el denominador  son de tipo entero el resultado es la división entera. Si alguno de los operandos es un número de punto flotante, el resultado es la división real. Por ejemplo: 5/3 es 1, pero 5.0/3 es 1.666667. Podemos notar que en la segunda expresión el número 5.0 es un número de punto flotante porque se específica su parte decimal (así sea cero).

Ejemplos de Expresiones Enteras:

0
10+3
7*9-8
1-(2*3)+9
7/5
15%7

Ejemplos de Expresiones Reales:

0.0
1.0
11+3.0
7/4.0
15*3+1.0
(5*6)/2.0

B) Operadores Combinados:

En el lenguaje C se encuentran un conjunto de asignaciones un poco convencionales, pero son bastante útiles. Estas asignaciones mezclan una operación con una asignación.

Por ejemplo:

Código:

a += 5;

entonces esto significa que se debe sumar 5 a la variable ‘a’. Esta asignación es equivalente (igual) a la siguiente:

Código:

a = a +5;

Se puede utilizar cualquier operación matemática en el lugar del signo de adición (+).

Algunos ejemplos de estas asignaciones, y su forma equivalente:
________________________________
Asignación:   Forma equivalente:
a *= 10;   ======> a = a*10;
a /= 5+4;   =====> a = a/(5+4);
a -= 8+5;   =====> a = a –(8+5);
a %= 2*3;   =====> a = a%(2*3);
a += 4;   =======> a = a+4;

C) El Operador de Incremento y Decremento:

Además existen los operadores de incremento y decremento, que se pueden entender como una asignación:

Código:

a++;

significa que se debe sumar 1 a la variable a; es igual a la asignación:

Código:

a = a + 1;

de la misma forma:

Código:

a--;

significa que se debe restar 1 a la variable a; es equivalente a:

Código:

a = a –1;

Estos operadores se pueden usar de forma prefija o postfija:

Código:

--a;
++a;

Cuando se utilizan como una sola sentencia no hay ninguna diferencia entre las dos notaciones, sin embargo este operador se puede utilizar en las variables de expresiones, donde la notación prefija y postfija tienen significados diferentes.

La notación postfija significa que primero se debe evaluar la expresión y posteriormente realizar la operación de incremento (decremento). Por ejemplo la siguiente asignación:

Código:

a = c++;

Es equivalente a las dos asignaciones:

Código:

a = c;
c = c+1;

En cambio, la asignación prefija significa que primero se debe realizar la operación de incremento (decremento) y posteriormente evaluar la expresión. En este caso, la siguiente asignación:

Código:

a = ++c;

Es equivalente a las dos asignaciones:

Código:

c = c +1;
a = c;

D) Prioridad de los operadores:

Cuando se utilizan los paréntesis las operaciones se realizan de acuerdo al orden de prioridad de la siguiente tabla (las que tienen mayor prioridad están arriba en la tabla y se realizan primero):
__________________________________________________________________________________
Operador:                   Operación:                                  Prioridad:
()  =====================> Paréntesis. =================================> 1
+, -, ++, --   ==========> Más/ menos unario/ incremento/ decremento. ==> 2
*, /, %   ===============> Multiplicación/ División/ Módulo.   =========> 3
+, -   ==================> Suma/ Resta.   ==============================> 4
=, +=, -=, *=, /=, %=  ==> Operadores de asignación   ==================> 5
+, -   ==================> Suma/ Resta   ===============================> 6


El mas y menos unario se colocan al comienzo de las expresiones como en –7, +5, -(6*2), etc.

Como se puede observar en la tabla, C considera las asignaciones como un operador, esto en principio puede parecer un poco raro, pero resulta conveniente en el momento de hacer incializaciones. El resultado de un operador de asignación es el valor asignado. De esta forma el valor de la expresión a = 10 es 10 y de a += 7 es a +7. Ejemplo:

Código:

#include <stdio.h>

main()
{
int a, b, c;
a = b = c = 0;
printf(“a = %d\n”, a);
printf(“b = %d\n”, b);
printf(“c = %d\n”, c);
}

En esta forma, las variables a, b y c quedan inicializadas en 0.

E) Funciones:

Las funciones se utilizan para proporcionar las operaciones que no se encuentran en el lenguaje, como el valor absoluto, la raíz cuadrada y las funciones trigonométricas. Estas se deben declarar antes de utilizarlas, incluyendo el archivo de encabezados stdilb.h para las funciones con números enteros y math.h para las funciones con números de punto flotante. La mayoría de éstas utilizan números con punto flotante de precisión doble, y por esto, cuando no hay restricciones de memoria, se definen todos los números de este tipo como double.

Algunas de las funciones matemáticas más comunes son las siguientes:
_____________________________________________________________________________________
Nombre:       Argumento:             Descripción:                 Tipo de Resultado:[/u]
abs(x)   ====> int   ===========> Valor absoluto de “x”.   =======> int
fabs(x)   ===> double   ========> Valor absoluto de “x”.   =======> double
pow(x,y) ====> double, double ==> “x” elevado a la “y”.   ========> double
sqrt(x)   ===> double   ========> Raíz cuadrada de “x”.   ========> double
cos(x)   ====> double   ========> Coseno de “x”.   ===============> double
exp(x)   ====> double   ========> Exponencial de “x”   ===========> double
log(x)   ====> double   ========> Logaritmo natural de “x”.   ====> double
log10(x)  ===> double   ========> Logaritmo en base 10 de “x”. ===> double
sin(x)   ====> double   ========> Seno de “x”.   =================> double
tan(x)   ====> double   ========> Tangente de “x”.   =============> double

F) Conversión entre tipos:

La conversión de los parámetros de las funciones se realiza en forma automática. Por ejemplo si se coloca un argumento double en la función en abs este se convierte en un entero antes de ejecutar la función. De la misma forma si se coloca un argumento int en la función exp, este se convierte a un double antes de llamar a la función. Justamente por esto el programador no tiene que preocuparse tanto por el tema de las conversiones. (Aunque, como siempre, cabe aclarar que no hay que abusar de la flexibilidad).



Este inciso continua...



En otro momento libre lo continuaré o completaré un pocos más, pido disculpas por el momento.

Saludos...

[Griph]

6) La Función scanf:

La función scanf se utiliza par pedir al usuario la información que se necesite.

La función scanf es parecida a la función printf: utiliza un primer argumento de tipo texto que indica el tipo y número de variables que debe leer. El formato del texto es muy parecido al de printf, se utiliza %d o %i para leer un entero, %c para leer un carácter, %f para leer un número de punto flotante (de precisión simple) con signo, punto decimal y exponente, %lf para leer un número de punto flotante de precisión doble.

Esta función no utiliza ningún texto guía para el usuario; de manera que se debe utilizar la función printf para ayudar al usuario a que entre los valores correctamente.

Ejemplo:

Código:

printf(" Entre el valor de 'x' ");
scanf("%d", &x);

Todos los parámetros de las funciones se pasan por valor, es decir se coloca el contenido de la variable. Para que la función scanf pueda modificar el valor que se encuentra dentro de una variable es necesario colocar en el parámetro al dirección donde se encuetra en la memoria. Esto se hace anteponiendo el símbolo " & " al nombre de la variable. Por esta razón, en la función scanf anterior, se usa " &x " en el parámetro.

Con frecuencia se olvida colocar el símbolo &; no obstante se debe ser muy cuidadoso, ya que los valores que coloca el usuario no son capturados y demás, entonces se obtienen resultados inesperados (lo más probable es que en el momento de compilar el código fuente, el compilador te tire un error).

Cuando el usuario entra un tipo de datos inválidos, la función scanf intenta interpretarlo y coloca en la variable el valor sea conveniente. Por ejemplo, si el usuario introdujo un carácter en lugar de un número, la variable numérica después de la ejecución de la función contiene el valor 0. El carácter se aplaza para la siguiente llamada a una función de entrada de datos.

Cuando se utilzan múltiples argumentos dentro de una misma función scanf, como en el siguiente ejemplo:

Código:

printf(" Ingrse el valor de 'x' e 'y' ");
scanf("%d %d",&x,&y);

El usuario debe separar los valores con espacio o tabulación. Si introduce solamente un valor, el programa se queda esperando hata que se coloque el valor que falta. Si por el contrario se introducen más de los datos solicitados, estos son almacenados y se utilizan como valores de entrada para la siguiente función de entrada de datos.

Para familizarizarse con al forma en que se leen los datos, se puede hacer un programa que lea tres números enteros. Se puede ensayar con diferentes alternativas para ver que resultados se producen. Por ejemplo, introducir números separados por espacios y tabuladores; números reales y textos. Después de cada prueba, se puede volver a ejecutar el programa (por si le hemos hecho alguna modificación, etc...).

[Griph]

7) Los Comentarios:

(me puse a ver el índice de este texto y me di cuanta que no había puesto nada referente a los comentarios, en fin la mayoría de la gente ya lo sabe; pero bueno para que el presente texto quede un poco más completo aquí va algo de info sobre comentarios o anotaciones).

Los comentarios tienen un formato libre y se pueden colocar en cualquier parte del programa, mientras se encuentre después de cualquier palabra o símbolo dentro de las sentencias (aunque lo mejor es ponerlos directamente en una nueva línea, de esta forma el código queda con un grado de legibilidad mayor). También pueden extenderse en más de una línea. Los comentarios se encierran entre los símbolos '/*' y '*/'.

Aquí va un ejemplo:

Código:

/* En este comentario, haremos referencia a la declaración del fichero "header" stdio.d */
#include <stdio.h>

// Aquí podemos ver la función principal, o "main" (en inglés)
main()
/* Abrimos un bloque */
{
//Usamos la función "printf", para mostrar la información en la pantalla
printf("Programa de Prueba :) ");
/* Cerramos el bloque */
}

Aunque es conveniente poner comentarios al código, tampoco hay que abusar de ellos. Dado que de esta forma puede que se dificulte más la comprensión del código, cuando tendría que suceder lo contrario.

[Griph]

8) Definición de Constantes:

Para facilitar la lectura de las aplicaciones, se permite la definición de constantes simbólicas. Éstas se utilizan  para darle nombres expresiones  que no cambian durante TODA la ejecución del programa.

Una forma de crear constante es utilizando una línea con #define, que define un nombre simbólico y un texto de reemplazo:

Código:

#define nombre_de_la_constante texto_de_reemplazo_o_el_contenido

#define int a 5

Después de realizar esto cualquier ocurrencia del nombre simbólico, que esté entre comillas, es sustituido con el texto de reemplazo correspondiente. El nombre sigue las reglas de los identificadores, una secuencia de letras y dígitos que comienzan por una letra. El texto de reemplazo puede ser cualquier secuencia de caracteres sin limitarse a números. A continuación se presentan algunos ejemplos:

Código:

#define VALOR_MAXIMO 32000
#define ValorMinimo -32000
#define exp 2.7182818
#define ENTRAR_NUMERO “Entre un número o valor”
#define NL '\n'

No debe confundirse una constante simbólica con un nombre de variable; el compilador simplemente sustituye todas las apariciones de la constante simbólica con el texto de reemplazo correspondiente.

Un ejemplo del uso de constantes:

Código:

#include <stdio.h>

/* Aplicación para calcular el perímetro de una circunferencia. */

// Definición de la constante simbólica PI .
#define PI 3.1416

main()
{
double perimetro;
double radio;

printf(“Entre el valor del radio”);
scanf(“%lf”, &radio);

/* Cálculo del perímetro 2*PI*radio */
perimetro = 2*PI*radio;
printf(“El perímetro de la circunferencia de”);
printf(“radio %f es: %f”, radio, perimetro);
}

Respecto de las constantes ya esta, sólo una cosa: que en el programa anterior, la siguiente asignación no esta permitida porque PI se reemplaza por el texto correspondiente:

Código:

PI = 4.5; //no se puede

es equivalente a escribir:

Código:

3.1416 = 4.5; //es inválido

Lo cual es un error cuando programamos en lenguaje C.

Los siguientes son otros ejemplos de constantes simbólicas:

Código:

#define PI 3.1416
#define PI2 PI*PI
#define TRUE 1
#define FALSE 0
#define VERDADERO TRUE
#define FALSO FALSE
#define SI TRUE
#define NO FALSE
#define ESPACIO “ ”
#define DOLAR “$”
#define TEXTO “texto de reemplazo”;

Los nombres en mayúsculas se utilizan para distinguirlos de las variables, no obstante, se pueden utilizar minúsculas. Las constantes simbólicas se utilizan frecuentemente para definir los nombres de los valores lógicos TRUE y FALSE, VERDADERO Y FALSO, SI y NO, etc. También para darle nombres a algunos símbolos como el dólar (“$”) y el espacio (“ “).

[Griph]

9) Sentencias Compuestas:

Las sentencias compuestas consisten simplemente en una secuencia de instrucciones delimitadas por los símbolos '}' y '}'.
En cualquier programa que se desarrolle siempre hay una sentencia compuesta, de hecho cuando se usan estructuras soportadas
por el lenguaje C sin darnos cuenta terminamos usando sentencias compuestas.

Una sentencia compuesta se puede utilizar en cualquier parte en la que se pueda usar una sentencia simple. Su estructura
es la siguiente:

Código:

{
declaración de variables;

sentencias del bloque;
}

En fin el cuerpo de cualquier programa es una sentencia compuesta, dado que el cuerpo de sentencias ejecutables tiene esta
forma.

Las sentencias if~then~else

La Sentencia "if" del lenguaje C es muy similar a la de la mayoría de los lenguajes. Por ejemplo, supongamos que queremos saber si un número es mayor que otro, basta con comparar ambos valors llevando a cabo la utilización del operador condicional "<" (menor que) o bien ">" (mayor que), con cualquiera de los dos se puede realizar una aplicación que compare los dos números y nos informe cuál es el mayor. El código de este programa es el siguiente:

Código:

#include <stdio.h>

int main()
{
/* Variables a Utilizar: */
int x;
int y;

printf(" Ingrese el primer número: ");
scanf("%d", &x); /* se ingresa el 1º dato en la variable "x" */
printf(" Ingrese el segundo número: "); /* se ingresa el 2º dato en la variable "y" */
scanf("%d", &y);

/* Comienzo de la estructura "if" */
if( x > y)
printf("%d es mayor que %d", x, y);
else
printf("%d  es mayor que %d", y, x);
; /* Este punto y coma indica que ya no se trabajará más con la instrucción "if" */

return 0;

} // Fin del programa

Bueno está demás decir que el sangrado (también llamado indexado) es opcional, es simplemente que se usa para que el programador (usted y otros) tenga más facilidad a la hora de leer el código.

Respecto de esta la intrucción "if" cabe decir que no hay una palabra que indique si final (por eso el ";" al final del código fuente, la condición a realizar debe estar encerrada entre paréntisis. Algo importante es que sólo se puede colocar una sentencia tanto en la parte que se ejecuta si la condición es verdadera o falsa. Un dato para aquella persona que ande en la búsqueda de información sobre el lenguaje C (tanto porque tiene que rendir un exámen o por otro motivo) es que "else" por si sola no es una instrucción, y simplemente/solamente se utiliza para separar las sentencias de las dos cláusulas (la verdadera y la falsa).

Ahora sí, el tema de que sólo se pueda usar una instrucción tanto en la parte "if"  como en la parte "else" es un problema.
Pero, tiene solución. Hay que usar sentencias compuestas (y ahora se entiende porqué expliqué un poco el tema de las sentencias compuestas anteriormente ). Veamos el siguiente ejemplo:

Código:

#include <stdio.h>

main()
{
int x, y;

printf(" Ingrese el primer número: "); scanf("%d", &x);
printf(" Ingrese el segundo número: "); scanf("%d", &y);

if( x > y) {
printf("Usted ha ingresado el número: %d", x);
printf("%d es mayor que %d", x, y);
}
else {
printf("Usted ha ingresado el número: %d", y);
printf("%d  es mayor que %d", y, x);
}
}

A) Condiciones:

Las condiciones son comparaciones entre dos valores. Los operadores que se utilizan para realizarlas se denominan "operadores de relación". Las expresiones de relación dan como resultado un "valor verdadero" (un valor entero "Distinto de
Cero") o "falso" (cuando el valor es el número "cero").

Veamos una tabla con los diferentes operadores de relación (me parece que se visualiza mejor con una cita que poniendo la "tabla" sola, sin formato alguno):

_______________________________________________________________________
|Operador: |Comparación:     |Comentario:                               |
|op1 > op2 |Mayor q'.        |Es Verdadero si op1 es mayor q' op2.      |
|op1 >= op2|Mayor o igual q'.|Verdadero si op1 es mayor q' op2.         |
|op1 == op2|Igual (q').      |Verdadero si op1 es igual q' op2.         |
|op1 != op2|Diferente.       |Verdadero si op1 es diferente a op2.      |
|op1 <= op2|Menor o igual q'.|Verdadero si op1 es menor o igual q' op2. |
|op1 < op2|Menor q'.         |Verdadero si op1 es menor q' op2.         |
 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

Ejemplifiquemos...

______________________________________________________________________________
| Ejemplo: | Resultado:                            |
| 5>3      |Verdadero.                                 |
| 'Z'>='A' |Verdadero.                            |
| 1=0      |Falso.                            |
| 4!=4     |Falso.                            |
| 14<=14   |Verdadero.                                   |
| 1<1000   |Verdadero.                                                         |
| x<10     |Verdadero si "x es menor que 10",Falso si x es mayor o igual q' 10.|
| x==5     |Verdadero si "x es igual que 5 ", Falso si "x es diferente de 5".  |
| 4==y     |Verdadero si "4 es igual a y", Falos si "4 es diferente de y".     |
| 7<=n     |Verdadero si "7 es menor o igual q' n",Falso si "7 es menor que n".|
 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

De aquí cabe aclarar que respecto del símbolo que se usa para llevar a cabo la operación de relación de igualdad es "==" (dos símbolos consecutivos) y NO "=", dado que éste último es un operador de asignación. De todos modos, dado que en el Lenguaje C "las asignaciones son una operación", la siguiente estructura "if" es válida/correcta (permitida):

Código:

if (x=y) /* En esta estructura llevamos a cabo una Asignación */
printf(" 'x' es igual a 'y' ");
else
printf(" 'x' es diferente de 'y' ");
;

Como se puede observar a "x" sele asigna "y". Entonces, si el valor resultante en "x" es diferente de cero, se imprime:
'x'  es igual a 'y'. Si el valor resultante es cero se imprime en la salida estandar (pantalla): 'x' es diferente de 'y'

La comparación que no produciría ambiguedades sería (aunque cabe decir que también es probable que se quiera hacer una comparación en la cual se averigue si el valor de un número es cero o diferente de cero, este es el caso de la comparación anterior...):

Código:

if (x==y) /* En esta estructura IF realizamos una Comparación */
printf(" 'x' es igual a 'y' ");
else
printf(" 'x' es diferente de 'y' ");
;

Operadores Lógicos:

Los operadores lógicos se usan simplemente para hacer una comparación en un programa. Por ejemplo para saber su una persona nació en el siglo 20, hay que verificar que la fecha de nacimiento se encuentre comprendida entre el año 1901 y 2000. En este caso hayq ue hacer dos comparaciones lógicas como las anteriores, en una sola.

Para estos casos se emplean los operadores lógicos. Los cuales son los siguientes, de forma resumida (como ya demasiados problemillas tuve cuando intentaba hacer algo parecido a una "tabla" porque luego cuando posteaba quedaba un poco bastante deformada, directamente voy con los datos):

Operador Lógico: && . Expresión Lógica: "Y lógico". Significado: la condición es verdadera cuando ambos operandos son verdaderos
Operador Lógico: || . Expresión Lógica: "O lógico". Significado: la condición es verdadera cuando algunos de los dos es verdadero.
Operador Lógico: ! . Expresión Lógica: "No lógico". Significado: la condición es verdadera cuando el operando es falso.

La Sentencia if~then:

La parte else de la instrucción if, al igual que la mayoría de los lenguajes es opcional. Cuando se usa la parte else, se está haciendo una elección, se elige la ejecución entre una sentencia u otra, mientras que, cuando no se utiliza la parte else, se trata simplemente de una opción.

La sentencia if~then tiene la siguiente forma:

Código:

if (condicion)
sentencia
;

Instrucción Condicional Anidada:

[Griph]

Bueno de momento eso es todo, luego seguiré este texto.

Saludos,

Griph

Ante cualquier queja, sugerencia, recomendación, colaboración, etc. mandar un e-mail a: Sr_Binario@hotmail.com

Adiós... (¬_¬)

EOF EOF EOF EOF EOF EOF EOF EOF EOF EOF EOF EOF EOF EOF EOF EOF EOF

[kd]

eeehhh disculpenme una duda...

yo estoy tratando de aprender c, y antes de esto vi un manual en elrincondelc, que se parece bastante a este, me gustaria saber si es el mismo, completamente igual....

o si es que a este le han agregado algo nuevo....


eso...

[Griph]

El curso de elrincondelc.com es el curso que escribió el Gorka Urrutia, y el contenido es el mismo porque el lenguaje C no  va a cambiar por el hecho de que quien escriba un texto sobre el mismo sea una persona diferente. El lenguaje C va ser siempre el mismo.

Esto es simplemente un texto sobre el lenguaje C, no lo consideraría un curso. Lo del Gorka Urrutia es un curso bastante completo que abarca la administración de memoria, estructuras y otros aspectos. Lo cual dentro de un tiempo tal vez lo agregue a este texto.

Espero haber aclarado tu duda, ante cualquier cosa puedes mirar el índice antes postear de forma inepta (tu nick y tu forma de escribir lo dice todo, no es por nada lo que acabo de decir; no me mal interpretes).

Un saludo,

Griph.

[santafesino]

ante cualquier cosa puedes mirar el índice antes postear de forma inepta (tu nick y tu forma de escribir lo dice todo, no es por nada lo que acabo de decir; no me mal interpretes).

jauauauuaa, si no lo toma como una ofensa se pasa de pelotudo ehh!!!

PREGUNTO: ASÍ COMO HAY UN PÒST Q SE REFIERE A LA "INTRODUCCIÓN AL LENGUAJE C (BÁSICO)", HAY ALGUN OTRO O SABE ALGUIEN DONDE PUEDO ENCONTRAR UNO PARA C++ ??????