C ++ Estatutos ciclos

3. Lenguaje de Programación C
3.1. Lenguajes de Programación: Definición y Características.
3.2. Anatomía de un Programa en C.
3.3. Variables y Constantes.
3.4. Tipos de Datos Básicos en C.
3.5. Operadores Básicos en C.
3.6. Sentencias de Entrada y Salida.
3.7. Estructuras de Control.
3.7.1. Iteración.
3.7.2. Selección
3.8. Tipos de Datos Construidos.

Dennis Ritchie de AT&T Bell Laboratories inventó e implementó el primer C en un DEC PDP-11 que usaba el sistema
Operativo UNIX. El Lenguaje C es el resultado de un proceso de desarrollo de un lenguaje llamado BCLP. Dicho lenguaje
fue desarrollado en 1967 por Martin Richards con la idea de escribir software y compiladores en lenguaje ensamblador. A su
vez el BCLP influyo en un lenguaje llamado B que invento Ken Thompson en 1970, este lenguaje surge para crear las
primeras versiones del sistema operativo UNIX y se instalo en una máquina PDP-7, por los laboratorios BELL.

C surge de la necesidad de re-escribir el UNIX en un lenguaje de alto nivel, pero que algunos procedimientos se
manejaran a nivel ensamblador, es entonces cuando se comienza a desarrollar un lenguaje que solucionara dicho problema.

C es un lenguaje de aplicación general que sirve para escribir cualquier tipo de programa, pero su éxito y popularidad
están íntimamente ligados al sistema operativo UNIX. Si se quiere dar mantenimiento a un sistema UNIX, es preciso emplear
C.

C y UNIX se acoplaron tan bien que pronto no sólo los programas de sistemas, sino casi todos los programas
comerciales que se ejecutaban bajo UNIX se escribieron en C. Este lenguaje se volvió tan popular que se escribieron
versiones de él para otros sistemas operativos populares, así que su uso no está limitado a las computadoras que utilizan
UNIX.

El sistema operativo UNIX se inició en una DEC PDP-7, en los Laboratorios Bell durante 1969. En 1973, Ritchie y Thompson re-escribieron el
kernel (núcleo) de UNIX en C, rompiendo así con la tradición de que el software de sistemas está escrito en lenguaje ensamblador.

Hacia 1974 fue introducido en las universidades "con fines educacionales" y al cabo de pocos años estaba ya disponible para uso comercial.

El UNIX es un sistema portable (se ejecutan en una extensa variedad de computadoras), flexible, potente, con entorno programable, multiusuario y
multitarea

Características del lenguaje C.

• C es conocido como un lenguaje de nivel medio.
Nivel medio no tiene propiamente un significado negativo, no significa que C sea menos poderoso, manejable o
menos desarrollado que un lenguaje de alto nivel, tampoco implica que C es similar a un lenguaje ensamblador con
sus problemas asociados. Se considera a C un lenguaje de nivel medio, ya que combina elementos de lenguajes de
alto nivel con la funcionalidad y potencialidad del ensamblador.

Lenguajes de Alto nivel Lenguajes de Nivel Medio Lenguajes de Bajo nivel
Ada C Macro-assembler
Modula-2 Forth Assembler
Pascal
COBOL
FORTRAN
BASIC

• El código C es muy transportable.
Esto quiere decir que se puede adaptar el software escrito para un tipo de computadora a otro tipo.
• Esta basado en funciones.
• Trabaja directo con bits, bytes y direcciones de memoria.
• Es un lenguaje diseñado por programadores para programadores.
Da al programador lo que el programador quiere: pocas restricciones, pocas quejas, código rápido y eficacia.
• No esta orientado a un área en particular.
• Posee 32 palabras claves (27 Kernighan y Ritchie, 5 ANSI)
• C es un compilador, (BASIC es un interprete).
Intérprete: Lee el código fuente de su programa de línea en línea y realiza las instrucciones específicas que están en esa línea.
Compilador: Lee el programa entero y entonces lo convierte en código objeto, que es una traducción del código fuente, de forma que el compilador puede
ejecutarlo directamente.

• Maneja una biblioteca estándar.
Dicha biblioteca esta formada por un conjunto de archivos donde cada archivo esta formado por un grupo de
funciones y/o procedimientos que permiten resolver problemas en forma rápida y eficiente.
• Define seis etapas para ejecutar un programa:
Etapa de Edición.
Etapa de pre-procesamiento.
Etapa de compilación.
Etapa de encadenamiento.
Etapa de carga.
Etapa de ejecución.

ANSI C estándar.
En 1978 Prentice Hall publica el libro “The C Programming” dando a conocer dicho lenguaje. Con la popularidad
creciente de las microcomputadoras, se crearon muchas implementaciones nuevas. En lo que se podría llamar un milagro, la
mayoría de estas implementaciones eran altamente compatibles entre sí a nivel de código fuente. Sin embargo, como no
existía un estándar, siempre había algunas discrepancias. Al principio del verano de 1983 se estableció un comité para
encargarse de esta situación. Este comité comenzó a trabajar en un estándar ANSI que definiría el lenguaje C.

En 1989 fue aprobado el lenguaje estándar de C, llamado ANSI C. El estándar fue dado a conocer en Estados Unidos
por el organismo ANSI y a nivel mundial por la organización ISO.

El estándar ANSI C es un superconjunto del estándar UNIX, los programadores que migren de un compilador basado en
UNIX a uno con estándar ANSI encontrarán todas las características que habían usado.

Palabras clave de C.
Existe una clase especial de identificadores, llamados palabras clave o palabras reservadas, que en C y C++ tienen un
significado predefinido y que no podemos emplear como nombres de variables ni de ninguna otra cosa.

Palabras Clave C
auto do goto short typedef
break double if signed union
case else int sizeof unsigned
char enum long static void
const extern register struct volatile
continue float return switch while
default for

Identificadores: se usan como nombres de variables y otros elementos de un programa en C++. Un identificador debe comenzar con una
letra o bien con el símbolo de subrayado, y los demás caracteres deben ser letras, dígitos o el símbolo de subrayado. Tomar en cuenta que
estos deben ser mnemónicos.

Anatomía de un programa en C.

Un programa en C se compone de una o más funciones. Una de las funciones debe ser obligatoriamente main. Una
función es un grupo de instrucciones o sentencias que realizan una o más acciones. Así mismo, un programa contendrá una
serie de directivas #include que permitirán incluir en el mismo archivos de cabecera que, a su vez constarán de funciones y
datos predefinidos en ellos.

Formato general:
/* Comentarios */

#include archivo /*directivas del preprocesador */
#define /*macros del preprocesador*/

Declaración de variables globales
Declaración de funciones

main()
{
declaración de variables locales
secuencia de sentencias o cuerpo del main
return 0;
}

funcion1()
{
}

/* */
Encierran los comentarios de lo que el programa realiza, se pueden utilizar en cualquier parte del mismo. Es muy importante
ir documentado cada uno de los pasos del programa y sobre todo al inicio indicar que es lo que realiza así como su autor.

Estos símbolos representan comentarios tanto en C como en C++. En C++ también podemos utilizar // para indicar un
comentario pero el mismo terminara al final de la línea. Con /* y */ nos podemos extender por varias líneas.

Directivas:
El pre-procesador de C maneja las siguientes directivas:

#if , #else, #elif, #endif
Permiten compilar porciones del código fuente del programa selectivamente. Tienen la misma función que el if, else, endif
tradicional.

#ifdef, #ifndef
Método de compilación condicional que significa <<si definido>> y <<si no definido>> respectivamente.

#include
Instruye al compilador para incluir otro archivo fuente. El archivo debe encerrase entre paréntesis de ángulo o entre comillas
dobles. Ejemplo:
#include <stdio.h>

#define
Se usa para definir un identificador y una cadena que el compilador sustituirá por el identificador cada vez que se encuentren
en el archivo fuente. Dicha sustitución puede ser por un valor simple o por algo tan elaborado como el cuerpo de una función.

Al identificador se le llama MACRO y al proceso de reemplazamiento se le llama SUSTITUCION DE LA MACRO.

Ejemplo: #define TRUE 1
Esto provocara que el compilador sustituya 1 cada que encuentre TRUE

#undef
Se usa para quitar una definición del nombre de macro que sigue y que se hizo antes.

#line
Se usa para cambiar los contenidos de _ _LINE_ _ y _ _FILE_ _, que son identificadores predefinidos.

#error
Fuerza al compilador a parar la compilación cuando se encuentra.

#pragma

Es una directiva definida por la implementación que permite dar diversas instrucciones, definidas por el creador del
compilador, al compilador.

Declaración de Variables Globales y Funciones:
Representa la parte declarativa del programa. Las variables declaradas en esta parte se podrán utilizar durante todo el
programa, incluyendo dentro de las otras funciones.

main():
Indica el encabezado de la función principal del programa y el cuerpo del mismo deberá estar encerado entre paréntesis de
llave {}.

Declaración de variables locales:
Representa la parte declarativa de las variables que serán utilizadas únicamente en esta función.

Cuerpo del main:
Representan a las instrucciones ejecutables necesarias para la solución a un problema.

Funcion1():
Representa a una o mas funciones creadas por el programador para estructurar el programa.

Notas importantes:
• Toda sentencia o instrucción en un programa debe de terminar con punto y coma.
• Puede haber más de una instrucción por línea siempre y cuando vayan separadas por puntos y coma.
• Los comentarios deberán ser claros y concisos. Se puede utilizar un numero variable de los mismos siempre y cuando el programa
así lo requiera.

Variables y Constantes

Tipos de datos de C.
Los operadores manipulan variables constantes para formar expresiones. Estos cuatro: variables, constantes,
operadores y expresiones son el abecedario del lenguaje C.

• Variables: es una posición de memoria con nombre que se usa para mantener un valor que puede ser modificado
por el programa. Todas las variables en C han de ser declaradas antes de poder ser usadas. La forma general de
declaración es: tipo lista_de_variables;
• Constante: se refieren a valores fijos que no pueden ser alterados por el programa. La forma en que se
representan depende de su tipo.
• Operador: es un símbolo que le dice al compilador que realice manipulaciones matemáticas o lógicas especificas.
Existen cuatro clases de operadores: Aritméticos, Relacionales, Lógicos y a nivel de bits.
• Expresiones: Cualquier combinación valida de los elementos atómicos de C: los datos (variables o constantes) y los
operadores.

En C existen cinco tipos básicos de datos, Carácter (char), Entero (integer), Flotante (float), Doble flotante (double), vacío
(void).

• char: Carácter. Se usa para guardar caracteres de 8 bits.
• int: Entero. Se usa para guardar cantidades enteras. También se usan para controlar los bucles y las sentencias
condicionales.
• float y double: Flotante y doble flotante. Se usan para guardar valores que necesiten componente fraccional. La
diferencia entre ellos es la magnitud del numero.
• void: vacío. Se usa para mejorar la comprobación de tipos. Declarar explícitamente una función como que no
devuelve valor alguno. Declarar una función explícitamente sin parámetros. Para crear puntero genéricos.

La siguiente tabla muestra el tamaño y el rango de valores para los cuales están definidos cada uno de los tipos de datos:

Tipo Ancho Rango
Char 8 bits o 1 byte 0 a 255 o –128 a 127
Int 16 bits o 2 bytes -32768 a 32767
Float 32 bits o 4 bytes 3.4 E – 38 a 3.4 E + 38
Double 64 bits o 8 bytes 1.7 E –308 a 1.7 E +308
Void 0 Sin Valor

Modificadores de Tipo:
Excepto para void, los tipos de datos básicos tienen varios modificadores que los preceden. Se usa un modificador
para alterar el significado de un tipo para que se ajuste a las necesidades de cada momento. Dichos modificadores son:
Signed (con signo), Unsigned (sin signo), Long (largo), Short (corto).

La siguiente tabla muestra todas las combinaciones que se ajustan al estándar ANSI. Es importante recordar que
los datos de la tabla son valores muestra para dar una idea general de las diferencias entre tipos, ya que las máquinas
pueden emplear una longitud de palabra de 16, 32 o 64 bits y esto produciría cambios significativos a dicha tabla.

Tipo Tamaño aproximado Rango mínimo
Char 8 bits ó 1 byte -128 a 127
Unsigned char 8 bits ó 1 byte 0 a 255
Signed char 8 bits ó 1 byte -128 a 127
Int 16 bits ó 2 bytes -32,767 a 32,767
Unsigned int 16 bits ó 2 bytes 0 a 65,535
Signed int 16 bits ó 2 bytes -32,767 a 32,767
Short int 16 bits ó 2 bytes -32,767 a 32,767
Unsigned short int 16 bits ó 2 bytes 0 a 65,535
Signed short int 16 bits ó 2 bytes -32,767 a 32,767
Long int 32 bits ó 4 bytes -2,147,483,647 a 2,147,483,647
Signed long int 32 bits ó 4 bytes -2,147,483,647 a 2,147,483,647
Unsigned long int 32 bits ó 4 bytes 0 a 4,294,967,295
Float 32 bits ó 4 bytes Seis dígitos de precisión
Double 64 bits ó 8 bytes Diez dígitos de precisión
Long double 128 bits ó 16 bytes Diez dígitos de precisión

La diferencia entre los enteros con y sin signo es la forma en que la computadora interpreta el bit más alto (más
significativo) del entero. Si se especifica un entero con signo, entonces el compilador genera código que asume que el bit
más significativo va a ser usado como indicador de signo.

En el caso de los números con signo. Si el identificador de signo es 0 entonces el numero es positivo; si es 1
entonces el numero será negativo.

Los enteros con signo son importantes en muchos algoritmos, pero sólo tienen la mitad de la magnitud absoluta que
el correspondiente sin signo. Por ejemplo:

01111111 11111111 corresponde al 32767
Si el primero fuese 1, estaríamos hablando del mismo numero negativo.

En el caso de que el número fuese unsigned y el mas significativo fuera 1 entonces representaría el numero 65535.

Modificadores const y volatile.
Los números presentan dos problemas en los programas de computadora. El primero es que no poseen valor
mnemónico. Por ejemplo, si encontramos el numero 10 en un programa, nada nos dice acerca de su significado. Si el
programa se usa en un banco, podría tratarse del número de sucursales o del número de ventanillas en la oficina matriz.
Para entender el programa, necesitamos conocer el significado de cada constante. El segundo problema es que si es
necesario cambiar algunos números de un programa, la modificación suele introducir errores. Supongamos que el 10 ocurre
doce veces en el programa del banco, y que en cuatro ocasiones representa el número de sucursales y en las otras ocho
ocasiones representa el número de ventanillas en la oficina matriz. Si el banco abre una nueva sucursal y se hace necesario
actualizar el programa, hay una buena posibilidad de que algunos de los 10 que deberían cambiarse a 11 no se cambien, y
que algunos de los que no deberían cambiarse sí lo hagan. La forma de evitar estos problemas es dar un nombre a cada
número y utilizar el nombre en lugar del número dentro del programa. Por ejemplo, el programa del banco podría tener dos
constantes con los nombres NO_SUCURSALES y NO_VENTANILLAS. Ambos números podrían tener el valor 10, pero en el
momento en que el banco abre una nueva sucursal lo único que hay que hacer para actualizar el programa es modificar la
definición de NO_SUCURSALES.

Sin embargo, este método de nombrar constantes numéricas tiene un problema; podríamos modificar
inadvertidamente el valor de una de estas variables. C++ ofrece un mecanismo para marcar una variable inicializada de
modo que no se pueda modificar. Si el programa trata de modificar una de estas variables, se produce una condición de
error. Este mecanismo es llamado const y tiene las siguientes características.

El modificador de tipo const se utiliza para informar al compilador de que el valor de la siguiente variable no puede
ser cambiado por ninguna sentencia del programa. (Sin embargo debe ser inicializada). Por ejemplo:

const int NO_SUCURSALES = 10

Informa al compilador de que NO_SUCURSALES no puede aparecer en la parte izquierda de una sentencia de
asignación y fija el valor inicial a 10.

Una variable const recibe su valor bien por una inicialización explícita o bien por algún medio dependiente del
hardware.

Las variables de tipo const tienen dos propósitos principales. En primer lugar, permitir al compilador situarlas en
ROM (memoria de sólo lectura). En segundo lugar, permiten asegurarse de que cuando pasan punteros a una función,
ninguna parte del código de la función pueda modificar los objetos a que apuntan.

Nota: Una variable que se declara usando el modificador const se conoce como constante declarada. El lenguaje C no exige escribir las
constantes declaradas exclusivamente con mayúsculas, pero ello es una práctica estándar entre los programadores en C.

volatile:
Se utiliza para decir al compilador que la variable que le sigue puede ser modificada de alguna forma que no sea
bajo el control del programa. Por ejemplo la dirección de una variable global puede ser pasada a la rutina de reloj del sistema
operativo y usada para mantener el tiempo real del sistema o bien una variable puede ser actualizada por el reloj del sistema
cada 10 segundos.

El propósito de declarar una variable como volatile es evitar ciertas optimizaciones del compilador que pudieran
evitar el acceso al valor de la variable según indique una expresión. Esto es muy importante porque la mayoría de los
compiladores de C automáticamente optimizan ciertas expresiones asumiendo que el contenido de una variable no cambia si
no aparece en la parte izquierda de una sentencia de asignación; así, puede que no se vuelva a comprobar la variable cada
vez que se referencia. Además algunos compiladores cambian el orden de evaluación de una expresión durante el proceso
de compilación. El modificador volatile previene que se hagan esos cambios.

Nota: Es posible usar const y volatile juntos. Por ejemplo, si se asume que 0x30 es el valor de un puerto que cambia por
una condición externa exclusivamente, entonces la siguiente declaración es precisamente la que se necesita para prevenir
cualquier posibilidad de efectos secundarios accidentales:

const volatile unsigned char *puerto=0x30;

Conversiones de Tipos de Datos.
La mayoría de los programas procesan información de varios tipos. A veces todas las operaciones son del mismo
tipo. Por ejemplo, la adición de un entero a otro produce un entero. Pero con frecuencia es necesario convertir datos de un
tipo a otro. La conversión de tipos se refiere a la situación en la que variables de un tipo se mezclan con las de otro tipo.
Cuando se da esta mezcla en la sentencia de asignación, la regla de la conversión de tipo es sencilla; C convierte el valor del
lado derecho (lado de la expresión) de la asignación al tipo del lado izquierdo (la variable destino).

Cuando se convierten desde enteros hasta caracteres, los enteros largos a enteros y los enteros a enteros cortos, la
regla básica que se sigue es la cantidad apropiada entre los bits más altos se quitará. Así se perderán 8 bits cuando va
desde un entero hasta un carácter o un entero corto y 16 bits cuando va de un entero largo a un entero.

La siguiente tabla sintetiza estas conversiones de tipo. Se debe recordar un punto importante: la conversiones de
un int a un float, un float a un double, y así sucesivamente, no añadirá precisión o rendimiento. Estas clases de conversiones
sólo cambiarán el formato en que se representa el valor.

Hacia Desde Posible pérdida de Información
char Unsigned char Si el valor > 127, el objetivo será negativo.
char Short int Mayor de 8 bits
char Int Mayor de 8 bits
char Long int Mayor de 24 bits
short int Int Ninguna
short int Long int Mayor de 16 bits
Int Long int Mayor de 16 bits
Int Float Parte fraccional y posiblemente más
float Double Precisión, resultado redondeado
double Long double Ninguna

Para hacer la conversión que la tabla no muestra directamente, simplemente convertir un tipo de un momento hasta
el final. Por ejemplo, para convertir desde un double hasta un int, primero convertimos de double a float y entonces de float a
un int.

Operadores.
C es un lenguaje muy rico en operadores incorporados. C define cuatro clases de operadores: aritméticos,
relacionales, lógicos y a nivel de bits.

Aritméticos: Los operadores de suma, resta, multiplicación y división funcionan de la misma manera en C que en la mayoría
de los lenguajes de computadora. Cuando se aplica la división a un entero, la computadora truncará cualquier resto. El
operador módulo de la división almacena el resto de una división entera. Sin embargo, no se puede usar % sobre los tipos
float o double.

Símbolo Operación Símbolo Operación
- Resta % Módulo división
+ Suma -- Decremento
* Multiplicación ++ Incremento
/ División

Es importante mencionar que el tipo de valor producido y el valor exacto del resultado dependen de los tipos de
números que se están combinando. Si ambos operandos son de tipo int, el resultado de combinarlos con un operador
aritmético es de tipo int. Si uno de los operadores, o ambos, son de tipo double, el resultado es de tipo double.

El tipo del resultado puede ser más importante de lo que podríamos pensar. Por ejemplo, 7.0/2 tiene un operando
de tipo double, por lo tanto el resultado es el número de tipo double 3.5. En cambio, 7/2 tiene dos operandos de tipo int, y por
ello produce el resultado de tipo int 3. Aunque la parte fraccionaria del resultado valga cero, hay una diferencia. Por ejemplo,
6.0/2 tiene un operando de tipo double, por lo tanto, el resultado es el valor de tipo double 3.0, que sólo es una cantidad
aproximada. En cambio, 6/2 tiene dos operandos de tipo int; por lo tanto, produce el resultado 3 que es de tipo int y por lo
mismo es una cantidad exacta. El operador de división es el que más se ve afectado por el tipo de sus argumentos.

Cuando se emplea con uno o dos operandos de tipo double, el operador de división se comporta como se debería
esperar. En cambio, cuando se utiliza con dos operando de tipo int, dicho operador produce la parte entera del cociente. En
otras palabras, la división entera desecha la parte que sigue al punto decimal. Así pues, 10/3 es 3 (no 3.333...), 5/2 es 2 (no
2.5). Observe que el número no se redondea; la parte que sigue al punto decimal se desecha, por más grande que sea.

Podemos emplear el operador % con operandos de tipo int para recuperar la información que se pierde cuando
usamos / para dividir números de tipo int. Cuando se emplean con valores de tipo int, los dos operadores / y % producen los
dos números que se obtienen cuando se ejecuta el algoritmo de división larga que se aprende en la primaria. Por ejemplo, 17
dividido entre 5 da 3 con un residuo de 2. La operación / produce el número de veces que un número “cabe” en otro. La
operación % da el residuo.

Incremento y Decremento:
C contiene dos operadores muy útiles que no existen generalmente en otros lenguajes de computadora. Son el de
incremento, añade 1 a su operando, y el decremento, resta 1 a su operando. En otras palabras:
x = x + 1; es lo mismo que x++;
y
x = x - 1; es lo mismo que x—;

Estos operadores pueden preceder o seguir al operando la diferencia es que cuando lo precede, C lleva a cabo la
operación antes de utilizar su valor. Si el operador sigue al operando, C utiliza su valor antes de realizar la operación. Por
ejemplo:
x = 10; x = 10;
y= ++x; y= x++;
Valor de y: 11 Valor de y: 10

La mayoría de los compiladores de C generan un código objeto muy rápido y eficiente para las operaciones de
incremento y decremento, siendo mejor que el que se obtendría usando la sentencia de asignación correspondiente. Por esta
razón, se debe usar estos operadores siempre que sea posible.

La precedencia de los operadores aritméticos es de mayor a menor como se muestra a continuación:
Mayor: ( )
++ --
* / %
Menor: + -

Los operadores del mismo nivel de precedencia son evaluados por el compilador de izquierda a derecha. Por
supuesto, se pueden utilizar paréntesis para alterar el orden de evaluación. Los paréntesis en C son tratados prácticamente
igual que en otros lenguajes. Los paréntesis fuerzan a que una operación, o un conjunto de las mismas, tenga un nivel de
precedencia mayor.

Relacionales y Lógicos:
En el término operador relacional la palabra relacional se refiere a la relación entre unos valores y otros. En el
término operador lógico la palabra lógico se refiere a las formas en que esas relaciones pueden conectarse entre sí. Los
discutiremos a la vez, ya que a menudo los operadores relacionales y lógicos actúan juntos.

La siguiente tabla muestra los operadores relacionales y lógicos.

Operadores Relacionales Operadores Lógicos
Operador Acción Operador Valor
> Mayor que && Y
>= Mayor o igual que || O
< Menor que ! No
<= Menor o igual que
== Igual
!= Diferente

La clave de los conceptos de operadores relacionales y lógicos es la idea de cierto (true) y falso (false). En C
cualquier valor distinto de 0 es cierto y el valor 0 es falso.

A continuación se muestra la tabla de verdad para los operadores lógicos usando 0 y 1
A B A&&B A||B !A !B
0 0 0 0 1 1
Falso Falso Falso Falso Cierto Cierto
0 1 0 1 1 0
1 1 1 1 0 0
1 0 0 1 0 1

Todos los operadores relacionales como los lógicos tienen un nivel de precedencia menor que los operadores
aritméticos. Esto significa que una expresión como 10>1+12 se evalúa como si se hubiera escrito 10>(1+12). El resultado,
por supuesto es falso.

Es posible combinar varias operaciones en una expresión tal como se muestra:
10>5&&!(10<9)||3<=4

La precedencia relativa entre los operadores relacionales y lógicos es la siguiente:
Mayor: !
> >= < <=
== !=
&&
Menor: ||

A nivel de bit:
Al contrario que muchos otros lenguajes, el C soporta un completo juego de operadores a nivel de bits. Dado que el
lenguaje C se diseño para sustituir al lenguaje ensamblador en muchas tareas de programación, era importante permitir todas
las operaciones que se pueden hacer en ensamblador. Las operaciones a nivel de bits se refieren a la comprobación,
asignación o desplazamiento de los bits reales que componen un byte o una palabra, que corresponden a los tipos estándar
de C: char e int con sus variantes. Las operaciones a nivel de bits no se pueden usar sobre float, double, long double, void u
otros tipos mas complejos. La siguiente tabla lista los operadores que se aplican a las operaciones a nivel de bits. Estas
operaciones se aplican a los bits individuales de los operandos.

Operador Acción
& Y
| O
∧ O exclusiva (XOR)
~ Complemento a uno (NOT)
>> Desplazamiento a la derecha
<< Desplazamiento a la izquierda

Los operadores Y, O y No a nivel de bits se rigen con la misma tabla de verdad que sus equivalentes lógicos,
excepto que trabajan bit a bit. A continuación la tabla de verdad que se aplica a la O ( ^ ) exclusiva.

A B A^B Como lo indica la tabla, el resultado de
0 0 0 una XOR es verdadero sólo si
0 1 1
exactamente uno de los operandos es
1 1 0
cierto, de otro modo, es falso.
1 0 1

Las operaciones sobre bits son frecuentes en aplicaciones de controladores de dispositivos (como programas de
módem, rutinas de archivos de disco y rutinas de impresora) debido a que permiten enmascarar ciertos bits, como el de
paridad.

Las operaciones de desplazamiento de bits pueden ser muy útiles cuando se decodifica la entrada a través de
dispositivos externos. Los operadores de desplazamiento también pueden utilizarse para llevar a cabo operaciones muy
rápidas de multiplicación y división de enteros. Un desplazamiento a la izquierda equivale a una multiplicación por 2 y un
desplazamiento a la derecha a una división por 2.

Más operadores:

Operador Condicional:
Este operador puede usarse para sustituir ciertas sentencias de la forma if-else con la forma general:

if(condición)
Expresión;
else
Expresión;

El operador condicional ? es un operador ternario, ya que necesita tres operandos y tiene la forma general:
Exp1?exp2 : exp3

El valor de una expresión con ? se determina de esta forma: se evalúa Exp1. Si es cierta se evalúa Exp2 y se
convierte en el valor de la expresión completa. Si Exp1 es falsa, se evalúa Exp3 y se convierte en el valor de la expresión
completa. Por ejemplo:
x = 10;
y = x > 9 ? 100 : 200;

En este ejemplo a y se le asigna el valor de 100. Si x hubiera sido menor que 9, habría recibido el valor de 200.
Utilizando la sentencia if-else, al mismo código es:
x = 10;
Nota: La precedencia de ? y : es menor
if(x>9) y = 100;
que la de cualquier otro operador
else y = 200;
visto anteriormente.

Los operadores de puntero & y *

Un puntero es la dirección de memoria de una variable. Una variable puntero es una variable específicamente
declarada para contener un puntero a su tipo específico. El conocer la dirección de una variable puede ser de gran ayuda en
ciertos tipos de rutinas. Sin embargo, en C los punteros tiene tres funciones básicas.
1. Pueden proporcionar una rápida forma de referenciar los elementos de un arreglo.
2. Permiten a las funciones de C modificar los parámetros de llamada.
3. Dan soporte a las listas enlazadas y a otras estructuras de datos dinámicas.

Mas a delante definiremos ampliamente los Punteros, por el momento mencionaremos brevemente los operadores que nos
ayudaran a manipularlos.

El primer operador de punteros es &, un operador monario (que solo requiere un operando) que devuelve la
dirección de memoria del operando.

Por ejemplo:
m=&muestra; coloca en m la dirección de memoria de muestra.

Esta es la dirección de la posición interna en la computadora de la variable. Recordar que no tiene nada que ver con
el valor de muestra.

Piense en esta forma; “m recibe la dirección de muestra”

El segundo operador de punteros es *, que es el complemento de &. Es también un operador monario que devuelve
el valor de la variable ubicada en la dirección que se especifica. Por ejemplo, si m contiene la dirección de memoria de la
variable muestra, entonces:

q= *m; Colocara el valor de muestra en q.

Piense en esta forma; “q recibe el valor que esta en la dirección m”

Por desgracia, el signo de la operación Y y el de “la dirección de” son el mismo, así como el de multiplicación y el
de “en la dirección”. Estos operadores no tienen relación entre sí.

Operador Serie:
La coma como operador encadena varias expresiones. La parte izquierda del operador como siempre se evalúa
como void. Esto significa que la expresión de la parte derecha se convierte en el valor de la expresión total separada por
coma, por ejemplo:
x= (y=3, y+1);

Primero asigna el valor 3 a y y luego asigna el valor 4 a x. Los paréntesis son necesarios debido a que este
operador tiene menor precedencia que el operador de asignación.

De igual forma nos permite combinar dos o mas expresiones en una sola. Por ejemplo:
x++, y++; Equivale a: x++;
y++;

Operadores punto (.) y flecha (->)
Estos operadores referencian elementos individuales de las estructuras y de las uniones. Las estructuras y las
uniones son tipos de datos compuestos que se pueden referenciar bajo un solo nombre.

El operador punto se usa cuando se trabaja realmente con la estructura o la unión. El operador flecha se usa
cuando se usa un puntero a una estructura o una unión.

Los paréntesis y los corchetes como operadores
Los paréntesis son operadores que aumentan la precedencia de las operaciones que contienen.

Los corchetes llevan a cabo el indexamiento de arreglos. Dado un arreglo, la expresión entre corchetes proporciona
un índice para el mismo.

Operador de Asignación:
En C se puede usar el operador de asignación en cualquier expresión válida. Este no es el caso de la mayoría de
los lenguajes de computadora que tratan el operador de asignación como un caso especial de sentencia. La forma general
del operador de asignación es:
Nombre_de_variable = expresión;

Donde la expresión puede ser tan simple como una constante o tan compleja como se requiera.

Nota: el destino, o parte izquierda de la asignación debe ser una variable o un puntero, no una función ni una constante.

A demás de este operador existen otros operadores de asignación relativa. Por ejemplo el operador += Por
ejemplo:
valor+=100; equivale a valor = valor + 100;

Resumen de precedencias:
Las precedencias entre todos los operadores del lenguaje C se muestra en la siguiente tabla.

Prioridad Operadores Asociatividad
Mayor [ ] ( ) . -> Izquierda – Derecha
++ -- ! & * ~ Derecha – Izquierda
* / % Izquierda – Derecha
+ - Izquierda – Derecha
<< >> Izquierda – Derecha
< <= > >= Izquierda – Derecha
== != Izquierda – Derecha
& Izquierda – Derecha
∧ Izquierda – Derecha
| Izquierda – Derecha
&& Izquierda – Derecha
|| Izquierda – Derecha
?: Derecha – Izquierda
= *= /= %= -= >>= Derecha – Izquierda
<<= &= |= ∧=
Menor: Operador , Izquierda – Derecha

Tome en cuenta que:
• Si dos operadores se aplican al mismo operando, el operador con mayor prioridad se aplica al primero.
• Todos los operadores del mismo grupo tienen la misma prioridad y asociatividad.
• La asociatividad izquierda - derecha significa aplicar el operador más a la izquierda primero, y en la asociatividad derecha -
izquierda se aplica primero el operador más a la derecha.

Declaración de Variables y constantes.

En C++ existen cuatro tipos de constantes: Literales, Definidas, Declaradas y Enumeradas.

Constantes literales: o constantes en general, se clasifican en cuatro grupos: enteras, de coma flotante, caracteres y de
cadena.

Constantes Enteras: Pueden estar en distintos formatos:
Formato decimal: 925
Formato octal: 01635 Están precedidas de la cifra 0
Formato hexadecimal: 0X39D Están precedidas de 0X

Se pueden utilizar los sufijos L que significa long o bien U que significa unsigned.
123U 205L 398UL

Constantes de Coma flotante: también llamadas constantes reales.
95.236 0.36 .95 85. 9.35E5 987.e+3

Constantes caracteres: es un carácter del código ASCII encerado entre comillas simples:
‘a’ ‘B’ ‘+’

Constantes cadena: Es una secuencia de caracteres encerrados entre comillas dobles:
“La niña tiene un vestido rojo”

Se puede escribir una cadena en varias líneas, terminando cada línea con “”
“Este es un ejemplo
de una cadena en varias
líneas”

Constantes de carácter de barra invertida.
Al incluir entre comillas simples las constantes carácter es suficiente para la mayoría de los caracteres imprimibles,
pero algunos, como el retorno de carro, son imposibles de introducir desde el teclado. Por esta razón, C incluye las
constantes especiales de carácter con barra invertida. Estos códigos se usan de la misma forma que cualquier otro
carácter.

Código Significado Código Significado
/b Espacio atrás. /0 Nulo.
/f Salto de página. // Barra invertida.
/n Salto de línea. /v Tabulación vertical.
/r Retorno de carro. /a Alerta.
/t Tabulación horizontal. /o Constante Octal.
/” Comillas dobles. /x Constante Hexadecimal.
/’ Comillas simples.

Constantes definidas:
Estas constantes pueden recibir nombres simbólicos mediante la directiva #define. C++ sustituirá los valores al
encontrarse dichas constantes. Ejemplo:
#define PI 3.1416
#define Tab ‘t’

Constantes declaradas:
El cualificador const permite dar nombres simbólicos a constantes. Su formato general es:
const tipo nombre_identificador = valor;

Constantes enumeradas:
Estas constantes permiten crear listas de elementos afines. Por ejemplo:
enum frutas {manzana, pera, plátano, cereza, papaya}

Cuando dicha sentencia es procesada, el compilador asigna un valor que comienza en 0 a cada uno de los
elementos enumerados. Después de declarar un tipo de dato enumerado, se pueden crear variables de ese tipo. Por
ejemplo se puede definir una variable de tipo frutas:
frutas fruta_preferida=manzana;

Declaración de Variables:
C++ nos exige declarar y definir todas las variables antes de ser usadas. Dicha declaración deberá indicar el tipo de
la variable y su nombre. Si esta declaración aparta memoria para la variable, entonces estaremos hablando de una
definición.

La declaración de variables permite separar por comas una lista de variables, así como también asignarles un valor.
Ejemplo:
int secuencia;
char letra, codigo;
float cantidad=25.50;
int valor=1, dato=5;

Errores más comunes.
• La conversión de un tipo de datos más alto en la jerarquía de promoción a un tipo menor puede cambiar su valor.

• Utilizar el operador de incremento o decremento en una expresión que no sea nombre de variable simple, por ejemplo: ++(x+1), es
un error de sintaxis.

• Aunque 3<x<7 es una condición matemáticamente correcta, en C++ no se evalúa correctamente. Para obtener en C++ la
evaluación correcta, utilice (3<x && x<7)

ANSI: El instituto Estadounidense de Estándares Nacionales, es una organización de científicos y representantes de la industria que nombran comités encargados de crear estándares para
lenguajes de programación y otras cosas. En 1989 se estableció el comité ANSI para estandarizar C++. En 1991, ISO, la organización Internacional de Estándares (un cuerpo similar a
ANSI) se unió al proyecto ANSI de C++. En noviembre de 1997 el comité unido aprobó el estándar de C++.

Bibliotecas estándar de C y C++.

La biblioteca estándar de C contiene el código objeto de las funciones proporcionadas con el compilador. Para la
mayor parte de los compiladores de C la biblioteca estándar está contenida en un archivo. Sin embargo, algunas
implementaciones han agrupado las funciones relacionadas en sus propias bibliotecas por razones de eficiencia o
restricciones de tamaño.

El C del estándar ANSI tiene definido el contenido y la forma de la biblioteca estándar de C. Sin embargo, muchos
compiladores incorporan funciones que no están especificadas por el estándar. Por ejemplo, es muy común encontrar
funciones gráficas, rutinas de manejo de ratón además de las normales. Mientras que no transporte los programas que
escriba a un nuevo entorno, es perfectamente válido utilizar esas funciones no estándar. Sin embargo, si su código debe ser
portable, debe restringir su uso.

Aunque las bibliotecas son parecidas a los archivos objeto, hay una diferencia crucial: no todo el código de una
biblioteca se añade a su programa. Cuando enlaza un programa que consiste en varios archivos objeto, todo el código de
cada archivo objeto se convierte en parte del programa ejecutable final. Esto ocurre se esté o no utilizando el código. En
otras palabras, todos los archivos objeto especificados en tiempo de enlace se unen para formar el programa. Sin embargo,
este no es el caso de los archivos de biblioteca.

Una biblioteca es una colección de funciones. A diferencia de un archivo objeto, un archivo de biblioteca guarda el
nombre de cada función, los códigos objeto de las funciones y la información de re-ubicación necesaria para el proceso de
enlace. Cuando su programa se refiera a una función contenida en una biblioteca, el enlazador toma esa función y añade el
código objeto a su programa. De esta forma, sólo se añadirán al archivo ejecutable aquellas funciones que realmente se
utilicen en el programa.

Como las funciones se añaden de forma selectiva al programa cuando se utiliza una biblioteca, las funciones
estándar de C están contenidas en bibliotecas en lugar de archivos objetos.

Archivos de cabecera:
Muchas funciones que se encuentran en la biblioteca estándar trabajan con sus propios tipos de datos y variables a
las que su programa debe acceder. Estas variables y tipos están definidos en los archivos de cabecera, proporcionados junto
con el compilador, y deben incluirse (utilizando #include) en cualquier archivo que utilice funciones especificas que hagan
referencias a ellas.

Por ejemplo, para utilizar la función de raíz cuadrada, sqrt(valor) es necesario incluir el archivo de cabecera como
#include “math.h”

En la siguiente tabla se muestran los archivos de cabecera definidos por el estándar ANSI.

Archivo de Cabecera Propósito
ALLOC.H Funciones de asignación dinámica.
ASSERT.H Define la macro assert( ).
BCD.H Define la clase bcd (C++).
BIOS.H Funciones del ROM-BIOS.
COMPLEX.H Define la clase número complejo (C++).
CONIO.H Funciones de manejo de pantalla.
CTYPE.H Funciones de manejo de caracteres.
DIR.H Funciones de manejo de directorios.
DOS.H Funciones de interfaz con el DOS.
ERRNO.H Define códigos de error.
FCNTL.H Define constantes usadas por la función open( ).
FLOAT.H Define valores en coma flotante dependientes de la implementación.
FSTREAM.H Definiciones de clases de E/S de archivos (C++).
GENERIC.H Macros para falsificar declaraciones de clase genérica (C++).
GRAPHICS.H Funciones de gráficos.
IO.H Rutinas de E/S de tipo UNIX.
IOMANIP.H Define manipuladores de E/S (C++).
IOSTREAM.H Define clase flujo de E/S (C++).
LIMITS.H Define varios límites dependientes de la implementación.
LOCALE.H Funciones de especificación de país e idioma.
MATH.H Definiciones para la biblioteca matemática.
MEM.H Funciones de manipulación de memoria.
PROCESS.H Funciones spawn( ) y exec( ).
SETJMP.H Soporte a saltos no locales.
SHARE.H Compartición de archivos.
SIGNAL.H Define valores de señalización.
STDARG.H Soporte a listas de argumentos de longitud variable.
STDDEF.H Define algunas constantes de uso común.
STDIO.H Definiciones y declaraciones para secuencias de E/S estándar.
STDLIB.H Declaraciones variadas.
STREAM.H Definiciones para la antigua clase de flujo (C++).
STRSTREA.H Definiciones de clase Instrstream y ostrstream (C++).
STRING.H Soporte a las funciones cadena.
SYSSTAT.H Define constantes para la apertura de archivos.
SYSTIMEB.H Declaraciones necesarias para la función ftime( ).
SYSTYPES.H Declaraciones de tipo usadas con las funciones de tiempo.
TIME.H Soporte a las funciones de tiempo del sistema.
VALUES.H Constantes dependientes de la máquina.

Sentencias de Entrada y salida.

C es prácticamente único en su tratamiento de las operaciones de entrada/salida. Esto se debe a que el lenguaje C
no define ninguna palabra clave para realizar la E/S. Por el contrario, la entrada y salida se realizan a través de funciones de
biblioteca.

Las funciones más simples de E/S son getchar(), que lee un carácter del teclado y putchar(), que imprime un
carácter en la pantalla.

La función getchar() espera hasta que se pulsa una tecla y entonces devuelve su valor. La tecla pulsada aparece
automáticamente en la pantalla. La función putchar() escribe su argumento de carácter en la pantalla en la posición actual
del cursor. Los prototipos de estas funciones son:
int getchar(void);
int putchar(int c);

El archivo de cabecera requerido para estas funciones es STDIO.H

Existen algunos problemas potenciales con getchar(). El ANSI ha definido getchar() de forma que sea compatible
con la versión original de C basada en UNIX. En su forma original esta función guarda lo que llega hasta que se pulsa
ENTER (esto se debe a que los terminales de línea de los sistemas UNIX originales guardaban en un buffer la entrada y
había que pulsar ENTER para que la entrada fuera enviada a la computadora). Esto hace que se queden uno o más
caracteres esperando en la cola de entrada una vez que getchar() vuelve, lo cual es problemático en entornos interactivos.

Alternativas:
Dos de las funciones alternativas son getch() y getche(), que tienen estos prototipos:
int getch(void);
int getche(void);

La función getch() espera que se pulse una tecla e inmediatamente después devuelve el valor, pero no muestra el
carácter en la pantalla.

La función getche() trabaja de la misma forma que la anterior la diferencia es que si muestra el carácter en la
pantalla.
El archivo de cabecera requerido es CONIO.H

Escritura y lectura de cadenas:
El siguiente paso en la E/S de consola, en términos de complejidad y potencia, son las funciones gets() y puts().
Estas permiten leer y escribir cadenas de caracteres por la consola.

La función gets() lee una cadena de caracteres introducida por el teclado y la sitúa en la dirección apuntada por su
argumento de tipo puntero a carácter. Se pueden escribir caracteres por el teclado hasta pulsar un salto de carro. El salto de

carro no formará parte de la cadena; en su lugar, un terminador nulo es situado al final y después gets() termina. De hecho,
no se puede utilizar gets() para devolver un salto de carro (aunque getchar() puede hacerlo). Se pueden corregir errores de
escritura utilizando la tecla de retroceso antes de pulsar INTRO. El prototipo de esta función es:
char *gets(char *cadena);

Donde cadena es un array de caracteres donde se colocan los caracteres tecleados por el usuario. gets() también
devuelve un puntero a cadena. El prototipo de esta función se encuentra en STDIO.H.

Para la función puts() escribe su argumento de tipo cadena en la pantalla seguido de un carácter de salto de línea.
Su prototipo es:
int puts(char *s);

Una llamada a puts() requiere mucho menos tiempo que la misma llamada a printf(), porque puts() sólo puede
imprimir una cadena de caracteres, no puede imprimir números o hacer conversiones de formato. Por esto, requiere menos
espacio y se ejecuta más rápido. Esta función se utiliza a menudo cuando es importante tener un código muy optimizado. Es
importante también saber que devuelve EOF si ocurre algún error. Si no devuelve un valor distinto de cero. Sin embargo,
cuando se está escribiendo en la consola, se puede asumir que no va a ocurrir ningún error.

Función: Operación:
getchar() Lee un carácter del teclado, espera un salto de carro.
getche() Lee un carácter con eco. No espera un salto de carro. No está definida por el ANSI, pero es
una extensión común.
getch() Lee un carácter sin eco. No espera un salto de carro. No está definida por el ANSI, pero es
una extensión común.
putchar() Escribe un carácter en la pantalla.
gets() Lee una cadena del teclado.
puts() Escribe una cadena en la pantalla.

E/S por consola con formato.
Las funciones printf() y scanf() realizan la entrada y salida con formato. La función printf() escribe datos en la
consola y la función scanf(), su complementaria, lee datos desde el teclado. Ambas funciones pueden operar sobre
cualquiera de los tipos de datos existentes, incluyendo caracteres, cadenas y números.

Función printf()
El prototipo de esta función se encuentra en STDIO.H. Esta función devuelve el número de caracteres escritos o
bien un valor negativo si produce error.
int printf (char * cadena_de_control,lista_argumentos);

La cadena de Control esta formada por dos tipos de elementos, el primer elemento es el carácter que se mostrará en
pantalla. El segundo elemento contiene especificadores de formato que definen la forma en que se muestran los argumentos
posteriores. El especificador de formato empieza con un % y va seguido por el código del formato. Debe haber exactamente
el mismo número de argumentos que especificadores de formato y ambos deben coincidir en su orden de aparición de
izquierda a derecha. Por ejemplo:
printf(“El %c es muy %s”,’C’,”facil”);

La siguiente tabla muestra los especificadores de formato que acepta esta función.

Código Formato
%c Carácter.
%d Enteros decimales con signo.
%i Enteros decimales con signo.
%e Notación Científica (e minúscula).
%E Notación Científica (E mayúscula).
%f Coma Flotante.
%g Usar %e o %f, el más corto.
%G Usar %E o %F, el más corto.
%o Octal sin signo.
%s Cadena de caracteres.
%u Enteros decimales sin signo.
%x Hexadecimales sin signo (letras minúsculas).
%X Hexadecimales sin signo (letras mayúsculas).
%p Mostrar puntero.
%n El argumento asociado es un puntero a entero al que se asigna el numero
de caracteres escritos.
%% Imprimir el signo %.

Notas Importantes:
• Para imprimir un solo carácter se utiliza %c, para una cadena se utiliza %s.
• Los especificadores %d y %i son equivalentes.
• Para imprimir una dirección de memoria utilice %p.

El especificador de formato %n es diferente al resto. En lugar de hacer que printf() imprima algo, produce en
printf() el efecto de cargar la variable apuntada por su correspondiente argumento con un valor igual al número de caracteres
que han sido impresos. En otras palabras, el valor que corresponde al especificador de formato %n debe ser un puntero a
una variable.

Después de terminada la ejecución de printf() esa variable tendrá el número de caracteres que se han impreso
hasta el punto en el cual se encontró %n.

Para alterar el numero de dígitos a imprimir en los formatos entero y flotante se pone el numero de lugares que
necesite entre el signo de porciento y el especificador de formato. (%05d muestra 00123). Este formato se utiliza
principalmente para crear tablas alineadas. De igual forma este formato se utiliza para especificar las posiciones decimales a
imprimir.

Función scanf()

Es la rutina de entrada por consola de propósito general. Puede leer todos los tipos de datos que suministra el
compilador y convierte los números automáticamente al formato interno apropiado. Su prototipo se encuentra en STDIO.H y
este es:
int scanf(char *cadena _de control, lista de argumentos)

Esta función devuelve el número de datos a los que se ha asignado un valor con éxito. Si se produce un error
devuelve EOF. La cadena de control determina cómo se leen los valores en las variables a las que se hace referencia en la
lista de argumentos.

La siguiente tabla muestra los especificadores de formato que acepta esta función.

Código Formato
%c Leer un único carácter.
%d Leer un entero decimal.
%i Leer un entero decimal.
%e Leer un número de tipo coma flotante.
%f Leer un número de tipo coma flotante.
%g Leer un número de tipo coma flotante.
%o Leer un número octal.
%s Leer una cadena.
%x Leer un número hexadecimal.
%p Leer un puntero.
%n Recibe un valor entero igual al número de caracteres leídos.
%u Leer un entero sin signo.
%[ ] Muestrea un conjunto de caracteres.

Estructuras de Control:

El estándar ANSI clasifica las sentencias de C en los siguientes grupos:
De selección.
De iteración.
De salto.
De etiquetado.
De expresión.
De bloque.

Entre las sentencias de selección se incluyen if y switch (a menudo se usa “sentencia condicional” en lugar de
“sentencia de selección”. Sin embargo, el estándar ANSI utiliza selección). Las sentencias de iteración son while, for y do
while. También se conocen normalmente como sentencias de bucles. Las sentencias de salto son break, continue, goto y
return. Las sentencias de etiquetado son case, default y label. Las sentencias de expresión son las compuestas por
expresiones válidas en C. Las sentencias de bloque son simplemente bloques de código.

Muchas sentencias de C se basan en una prueba condicional que determinan la acción que se ha de llevar a cabo.
Una expresión condicional tiene como resultado un valor cierto o falso. A diferencia de muchos lenguajes cualquier valor
distinto de cero es cierto, incluyendo los números negativos. El cero es el único valor falso.

Sentencias de Selección:
Como se menciono anteriormente C soporta las sentencias if y switch. Además, el operador ? puede ser utilizado
para ciertas situaciones.

If:
Su forma general es: Representación Gráfica:
if (expresión) sentencia;
else sentencia; Condición
V F

Sentencia o Bloque Sentencia o Bloque
de Sentencias de Sentencias

Sentencias

Donde sentencia puede ser una sentencia simple, un bloque de sentencias o nada (en el caso de sentencias
vacías). La cláusula else es opcional.

Si la expresión de if es cierta, se ejecuta la sentencia o el bloque de sentencias que constituye el objeto del if. En
cualquier otro caso se ejecuta la sentencia o bloque de sentencias que constituye el objetivo del else, si existe. Recuerde que
sólo se ejecuta el código asociado al if o al else, nunca ambos.

La sentencia condicional que controla el if debe producir un resultado escalar. Un escalar es cualquiera de los tipos
entero, de carácter o de coma flotante. Sin embargo, es raro usar un número en coma flotante para controlar una sentencia
condicional, ya que disminuye la velocidad de ejecución considerablemente.

Ifs anidados.

Un if anidado es un if que es el objeto de otro if o else. Los ifs anidados son muy comunes en programación. En c
una sentencia else siempre se refiere al if más próximo que esté en el mismo bloque que el else y que no esté ya asociado a
un if.

Por Ejemplo.

If (i) {
If (j) sentencia 1;

If (k) sentencia 2;
Else sentencia 3;
}
else sentencia 4;

If-else-if
Una construcción común en programación es la escala if-else-if. Su forma general es:

If (expresión) sentencia;
Else
Else
.
.
.
Else sentencia;

Las condiciones se evalúan desde arriba hasta abajo. Tan pronto como se encuentre una condición cierta, se
ejecuta la sentencia asociada con ella y se pasa por alto el resto de la escala. Si ninguna de las condiciones es cierta, se
ejecuta el else final. Es decir, si todas las pruebas condicionales fallan, se ejecuta la última sentencia else. Si no hay else
final, no tiene lugar ninguna acción si todas las condiciones son falsas.
Switch

Esta sentencia de selección múltiple compara sucesivamente el valor de una expresión con una lista de constantes
enteras o de caracteres. Cuando se encuentra una correspondencia, se ejecutan las sentencias asociadas con la constante.

Su forma general es: Su representación gráfica es:

switch (expresión) {
case constante 1:
Constante 1 default
secuencia de sentencias; Variable
break;
case constante 2: Constante 2 Constante n
secuencia de sentencias;
Secuencia de Secuencia de
break; Sentencias Sentencias
.
. Secuencia de ... Secuencia de
. Sentencias Sentencias
.
.
case constante n:
break; Sentencias
default:
}

Se comprueba el valor de la expresión, por orden, con los valores de las constantes especificadas en las sentencias
case. Cuando se encuentra una correspondencia, se ejecuta la secuencia de sentencias asociadas con ese case, hasta que
se encuentra la sentencia break. La sentencia default se ejecuta si no se ha encontrado ninguna correspondencia. Esta
ultima sentencia es opcional y si no esta presente no se ejecuta ninguna acción al fallar todas las comparaciones.

El estándar ANSI especifica que una sentencia switch debe poder tener al menos 257 sentencias case. En la
practica, se limita el número de estas sentencias a muchas menos por razones de eficiencia. Cabe aclarar que la sentencia
case, aunque es una sentencia de etiquetado, no tiene efecto fuera del switch.

La sentencia break es una de las sentencias de salto del lenguaje C. Cuando se encuentra una de estas sentencias
dentro de una sentencia switch, la ejecución del programa salta a la línea de código que sigue a dicha sentencia switch.

Importante:
• La sentencia switch se diferencia de la sentencia if en que switch sólo puede comprobar la igualdad, mientras if puede evaluar
expresiones relacionales o lógicas.
• No puede haber dos constantes case en el mismo switch que tengan los mismos valores. Por supuesto, una sentencia switch
puede estar contenida dentro de otra.
• Si se utilizan constantes de tipo carácter en la sentencia switch, se convierten automáticamente en valores enteros.

Switch anidados:
Se puede tener un switch formando parte de la secuencia de sentencia de otro switch. Incluso si las constantes
case del switch interior y del exterior contienen valores comunes, no provocara ninguna dificultad.

Ejemplo:
switch (expresión) {
case constante 1:
switch (expresión)
{
case constante 1:
.
.
.
}
break;
case constante 2:
break;
.
.
.
case constante n:
break;
default:
}

El operador condicional ?:

Se puede usar este operador para reemplazar las sentencias if-else con la forma general:
if (condición)
Expresión
else
Expresión

Sin embargo, el objetivo de if y else debe ser una expresión simple, no otra sentencia de C.

La ? es un operador ternario, ya que necesita tres operandos y tiene la forma general:

Exp1? Exp2: Exp3

Donde Exp1, Exp2 y Exp3 son expresiones. Observe el uso y la posición de los dos puntos.

El valor de una expresión con ? se determina de esta forma: se evalúa Exp1. Si es cierta, se evalúa Exp2 y se
convierte en el valor de la expresión completa. Si Exp1 es falsa, se evalúa Exp3 y su valor se convierte en el valor de la
expresión completa. Por ejemplo:

x = 10; x = 10;
y = x > 9 ? 100 : 200; if (x>9) y = 100;
else y = 200;

El uso del operador ? para sustituir las sentencias if-else no está limitado únicamente a sentencias de asignación.
Es posible utilizar funciones como parte de las expresiones que formen la parte verdadera y/o falsa del operador condicional.

Estatutos de ciclos: Iteración

Para empezar diremos que un ciclo (bucle, lazo, loop, etc.) es un segmento de un algoritmo o programa, cuyas
instrucciones se repiten un número determinado de veces mientras se cumple una determinada condición. Se debe
establecer un mecanismo para determinar las tareas repetitivas. Este mecanismo es una condición que puede ser verdadera
o falsa y que se comprueba una vez a cada paso o iteración del ciclo.

Un ciclo consta de tres partes:
1. Decisión,
2. Cuerpo del ciclo,
3. Salida del ciclo.

Ciclos en programas: while, for, do-while.

for:
El formato general del ciclo for de C se encuentra de una forma o de otra en todos los lenguajes de programación
procedimentales. Su forma general es:

for(inicialización ; Expresión_de_verificación ; Actualización) sentencia;

Representación gráfica:
F
Inicialización

Expresión de
verificación
V
Actualización

Secuencia de
Sentencias

Este bucle permite muchas variantes. Sin embargo, la inicialización normalmente es una sentencia de asignación
que se utiliza para iniciar la variable de control del bucle. La Expresión de verificación o condición es una expresión relacional
que determina cuando finaliza el bucle. La actualización define como cambia la variable de control cada vez que se repite el
bucle. Estas tres secciones principales deben estar separadas por punto y coma. El bucle for continua ejecutándose
mientras que la condición sea cierta. Una vez que la condición se hace falsa, la ejecución del programa continua por la
sentencia siguiente al for.

Bucle infinito:
Aunque se puede utilizar cualquier sentencia de bucle para crear un bucle infinito, es for el que se usa
tradicionalmente para este propósito. Como no se necesita ninguna de las tres expresiones que lo constituyen se puede
conseguir que el bucle no tenga fin dejando la expresión condicional vacía.

Es permitido poner expresiones de inicialización y de incremento, pero es más común entre los programadores de C
utilizar for(;;) para expresar un bucle infinito.

Realmente, dicha construcción de for no garantiza un bucle infinito, ya que la sentencia break, cuando se encuentra
en cualquier lugar dentro del cuerpo de un bucle da lugar a la terminación inmediata. El control del programa sigue en el
código que sigue al bucle.

while
Casi todos los programas incluyen alguna acción que se repite varias veces. Por ejemplo, un programa que calcula
la paga neta de un empleado. Si la compañía tiene 100 empleados, un programa de nómina más completo repetiría el
cálculo cien veces. Esto se puede realizar de diferentes formas y una de ella es utilizar el ciclo while.


while (condición) sentencia;

Condición V

F Sentencia o bloque
de sentencias

Sentencia o bloque
de sentencias

Donde sentencia puede ser una sentencia vacía, una sentencia simple o un bloque de sentencias que se
repiten mientras la condición sea verdadera. La condición puede ser cualquier expresión verdadera y cualquier
valor distinto de 0 es verdadero.

Al igual que el bucle for, el bucle while comprueba la condición al principio, lo que supone que el código del
mismo se ejecuta 0 o más veces.

Do-while:
Si sabemos que pase lo que pase el cuerpo del bucle while se debe ejecutar al menos una vez, usamos la
instrucción do-while. Esta instrucción a diferencia del while y for analiza la condición al final del bucle.


do Bloque de Sentencias
{
bloque de sentencias
Condición
V
} while(condición);

F
Bloque de Sentencias

Ciclos de conteo y ciclos condicionales.

Ciclo de conteo.
También llamados de repetición controlada o definida, porque se sabe con anticipación y exactitud el
número de veces que se ha de repetir el ciclo. Para este tipo de ciclo se hace uso de una variable que controla el
número de veces que se va a repetir el ciclo. Esta variable de control debe estar cambiando (incrementándose o
decrementándose) cada vez que se ejecuta el grupo de sentencias del ciclo.

Cuando el valor de la variable de control indica que se ha ejecutado el número exacto de repeticiones, termina
el ciclo, y entonces se continua ejecutando la siguiente sentencia en el programa.

Ciclo condicional.
A veces llamado de repetición indefinida, porque no se sabe con anticipación el número de veces que se
ejecutará el ciclo. Es aquel en que se va a estar ejecutando el ciclo mientras que una condición se cumpla. La
mayoría de las veces este tipo de ciclos involucra enunciados que deben obtener datos cada vez que el ciclo se
ejecuta. Cuando la condición no se cumple, se ejecuta la siguiente sentencia en el programa.

Diseño de ciclos.
De acuerdo al problema que se plantea resolver, el programador tiene que: primero entender y analizar el
problema, luego determinar el tipo de acciones a realizar. Entonces, se verifica el tipo de ciclo que conviene utilizar
para la solución. Una vez identificado el tipo de ciclo, es decir, cual de las estructuras de ciclo es más conveniente
usar para la solución. Si el programador generó una o más soluciones entonces debe escoger aquella que sea la más
óptima posible.

Ciclos anidados.
En algunas aplicaciones se requieren utilizar ciclos simples, en otras aplicaciones se requiere utilizar
operaciones cíclicas dentro de ciclos. A esto se le llama ciclos anidados.

El estándar ANSI estipula que al menos se deben soportar 15 niveles de anidamiento (la mayoría de los
compiladores permiten más). Los ciclos anidados se utilizan para resolver una gran variedad de problemas de
programación.

Sentencias Break y Continue
Las Sentencias break y continue se pueden usar para modificar la ejecución de estructuras de control
predefinidas, como los ciclos, cuando se presentan ciertas condiciones. En general, la sentencia break se usa para
terminar un ciclo inmediatamente y la sentencia continue se usa para pasar por alto una iteración de un ciclo.

Break:
Esta sentencia tiene dos usos. Se puede usar para finalizar un case en una sentencia switch o se puede usar
para forzar la terminación inmediata de un bucle, saltando la evaluación condicional normal del ciclo.

Cuando se encuentra esta sentencia dentro de un bucle, el bucle termina inmediatamente y el control pasa a
la siguiente sentencia en el programa.

La sentencia break generalmente se utiliza como parte de la estructura if dentro de un ciclo para terminar la
estructura del mismo si ocurren ciertas condiciones. A esto le llamaremos forzar la terminación inmediata de un
ciclo.

Importante:
• La sentencia break normalmente se utiliza en ciclos donde una condición especial puede dar lugar a la terminación
inmediata.
• Un break utilizado en un switch o en un ciclo, solo afecta a ese switch o a ese ciclo en especial, tome en cuenta esto
cuando maneje switch o ciclos anidados.
• La principal función del break es el romper ciclos cuando existe el potencial para un ciclo infinito.

Continue:
La sentencia continue funciona de una forma similar al break. Sin embargo, en lugar de forzar la terminación,
continue fuerza una nueva iteración del ciclo y salta cualquier código que exista en forma intermedia.

Importante:
• Para los ciclo while y do-while, una sentencia continue hace que el control del programa pase a la prueba condicional y
continúe el proceso de iteración.
• Para el ciclo for, hace que se ejecute la parte de incremento del ciclo, seguida de la prueba condicional.
• Para ciclos anidados, el continue solo ignora la iteración del ciclo donde se encuentra.

Etiquetas y goto:
El uso del goto ha decaído desde hace algunos años, La idea principal que los programadores tienen sobre el
mismo es que tiende a hacer los programas ilegibles. Sin embargo, hay veces en las que el uso del goto realmente
clarifica el flujo del programa más que confundirlo.

Se indica que no hay situaciones de programación que necesiten de su uso; más bien, es conveniente y
puede ser beneficioso, si se usa apropiadamente, en ciertas situaciones de programación.

En un lenguaje como C, que tiene un rico conjunto de estructuras de control y permite un control adicional
usando break y continue, no es muy necesario.

La sentencia goto necesita de una etiqueta para operar. Una etiqueta es un identificador válido de C que se
sigue por dos puntos.

Depuración y prueba de programas.

Una equivocación en un programa es un bug (error de programación), y el proceso de eliminar tales errores
se llama depuración. Hay varias historias acerca del origen de la terminología. La más interesante es que los
términos se originaron en los primeros días de la computación, cuando el hardware era extremadamente sensible. La
contraalmirante Grace Murray Hopper (1906-1992) fue “la tercera programadora de la primera computadora digital a
gran escala en el mundo”. Cuando Hopper estaba trabajando con la computadora Mark I de Harvard, bajo las órdenes
del profesor Howard H. Aiken de Hardvar, cuando una polilla hizo que fallara un revelador. Hopper y los demás
programadores pegaron con cinta adhesiva el cadáver de la polilla a la bitácora, y anotaron en ésta: “Primer caso
comprobado de “bug” hallado”. La bitácora se exhibe actualmente en el Museo Naval de Dahlgren, Virginia. Éste
fue el primer “bug” de computadora documentado. El profesor Aiken solía visitar las instalaciones en momentos de
poca actividad y preguntar si se estaban calculando números. Los programadores contestaban que estaban “limpiando
de bichos” (debugging) la computadora. Hoy en día, un bug es un error en un programa.

Tipos de errores en los programas:
El compilador detecta ciertos tipos de errores y despliega un mensaje de error cuando encuentra una
equivocación. Además, detecta los llamados errores de sintaxis, ya que son en general, violaciones de la sintaxis
(reglas gramaticales) del lenguaje de programación, tal como omitir un punto y coma.

Si el compilador descubre que el programa contiene un error de sintaxis, indicará dónde es probable que
esté y qué tipo de error podría ser. Si el compilador dice que el programa contiene un error de sintaxis, podemos
estar seguros de que así es. Sin embargo, el compilador podría no estar en lo correcto acerca de la ubicación o la
naturaleza del error. El compilador es más hábil para determinar la ubicación de un error, dentro de un margen de una
o dos líneas, que para determinar la causa del error. La razón es que el compilador tiene que adivinar qué es lo que el
programador quiso escribir, y fácilmente podría errar al adivinar. Los mensajes de error subsecuentes al primero tienen
mayores posibilidades de ser incorrectos con respecto a la ubicación o a la naturaleza del error. Esto también se debe
a que el compilador tiene que adivinar nuestra intención. Si la primera conjetura del compilador fue incorrecta, esto
afectará su análisis de los errores futuros, ya que el análisis se basará en una suposición falsa.

Si nuestro programa contiene algo que viola directamente las reglas de sintaxis del lenguaje de programación,
el compilador producirá un mensaje de error. Sin embargo, hay ocasiones en que el compilador sólo genera un
mensaje de advertencia, lo que significa que hemos hecho algo que no es, en términos técnicos: una violación de las
reglas del sintaxis del lenguaje de programación, pero que es lo bastante inusitado como para indicar un probable
error. Cuando recibimos un mensaje de advertencia, el compilador nos está preguntando “¿Estás seguro de que
esto es lo que quieres?” Es recomendable tratar todas las advertencias como si fueran errores.

Hay ciertos tipos de errores que el sistema de computación sólo puede detectar cuando se ejecuta el
programa. Por ello, reciben el nombre de errores de tiempo de ejecución.

Casi todos los sistemas de computación detectan ciertos errores de este tipo y despliegan un mensaje de
error apropiado. Muchos errores de tiempo de ejecución tienen que ver con cálculos numéricos. Por ejemplo, si la
computadora intenta dividir un número entre cero, eso normalmente es un error de tiempo de ejecución.

El hecho de que el compilador apruebe el programa y éste se ejecute una vez sin mensajes de error de
tiempo de ejecución, no garantiza que el programa sea correcto. Recordemos que el compilador sólo nos indica si
hemos escrito un programa en C sintácticamente correcto. No nos dice si el programa hace lo que queremos que
haga. Las equivocaciones en el algoritmo subyacente o en la traducción del algoritmo al lenguaje se llaman errores de
lógica. Por ejemplo, si usáramos por equivocación el signo de suma + en lugar del signo de multiplicación * en un
programa donde tendríamos que calcular el Iva, entonces dicho programa tendría un error de lógica. El programa se
compilaría y ejecutaría sin contratiempos, pero daría una respuesta equivocada. Si el compilador aprobó nuestro
programa y no hay errores de tiempo de ejecución, pero el programa no funciona debidamente, sin duda contiene un
error de lógica. Estos errores son los mas difíciles de diagnosticar, porque la computadora no nos da mensajes de
error que nos ayuden a encontrarlos.

Una de las formas para detectar los errores de lógica o de tiempo de ejecución es la “Prueba de
escritorio”, ésta es un procedimiento similar a revisar una carta o manuscrito. La idea es seguir el programa en papel
para asegurarse que éste trabaja en forma lógica. Debe considerar varias posibilidades de entrada y escribir cualquier
resultado generado durante la ejecución del programa. En particular, tratar de determinar que hará el programa con
datos no muy comunes considerando posibilidades de entrada que no deberían pasar.

En resumen recordemos:
Una buena definición del problema y un buen planteamiento evitará errores en el programa. Sin embargo,
siempre habrá unas cuantas fallas que no son detectadas. Depurar el programa consume más tiempo en todo el
proceso de programación. Thomas Edison decía, “la Programación es un 10% de inspiración y un 90% de
depuración”. Todos los buenos programadores son buenos depuradores.

Para hacer más fácil el proceso de depuración le aconsejamos seguir los siguientes pasos:
1. Darse cuenta que tienen un error.
2. Localizar y determinar la causa del error.
3. Corregir el error.

Cuando se empieza a programar es muy común que emitan la fase de “prueba de escritorio” ¿Porque no
esperar a correr el programa una vez que lo haya escrito?. Se dará cuenta, conforme obtenga experiencia, que se
puede ahorrar tiempo con la prueba de escritorio.

• Contador: es una variable cuyo valor se incrementa o decrementa en una cantidad constante en cata iteración.
• Acumulador: es una variable cuya misión es almacenar cantidades variables resultantes de sumas sucesivas. Realiza la
misma función que un contador, con la diferencia de que el incremento o decremento de cada suma se variable en lugar de
constante, como en el caso del contador.

C ++ Estatutos ciclos

Recommandé

Recommandé

Contenu connexe

Tendances

Tendances (20)

Similaire à C ++ Estatutos ciclos

Similaire à C ++ Estatutos ciclos (20)

Dernier

Dernier (20)

C ++ Estatutos ciclos