scanf
En C, la función scanf() (scan-format, analizar con
formato), en realidad representa a una familia de funciones que analizan una
entrada de datos con formato y cargan el resultado en los argumentos que se pasan por referencia a dicha función o funciones:
·
La función scanf() lee los datos de
entrada en el stdin (flujo
de entrada estándar).
·
La función fscanf() (file-scanf)
lee en un flujo de entrada dado, por lo general un fichero (file) abierto para lectura.
·
La función sscanf() (string-scanf)
obtiene la entrada que se va a analizar de una cadena
de caracteres dada (string).
Todas ellas leen caracteres, los interpretan según un formato, y almacenan
los resultados en sus argumentos. Cada uno cuenta con varios argumentos: por un
lado, un formato de la secuencia del control (se describe más abajo), por otro,
un sistema de argumentos del indicador que señala dónde la entrada convertida
debe ser almacenada. El resultado es indefinido si hay escasos argumentos para
dar formato. Si se agota el formato mientras que sigue habiendo las argumentos,
los argumentos sobrantes son evaluados pero no procesados de ninguna otra
manera.
printf
Numerosos lenguajes
de programación implementan una
función printf (print formatted), para mostrar una cadena con
formato. Esta, originaria del lenguaje
de programación C, tiene un prototipo similar al
siguiente:
int printf(const char* formato,...)
La cadena constante formato provee una descripción de la salida,
con placeholders marcados por caracteres
de escape "%", para especificar la localización relativa y el tipo de
salida que la función debe producir.
Por ejemplo en C:
printf("Color %s, numero1 %d, numero2
%05d, hex %x, real %5.2f.\n", "rojo", 12345, 89, 255, 3.14);
imprimirá la siguiente línea (incluyendo el caracter de nueva línea \n):
Color rojo, numero1 12345, numero2 00089, hex
ff, real 3.14.
Cout
Imagina un canal por el que circula agua, si echamos al canal objetos que
floten, estos se moverán hasta el final de canal, siguiendo el flujo del agua.
Esta es la idea que se quiere transmitir cuando se llama "stream" a
algo en C++. Por ejemplo, en C++ el canal de salida es cout, los objetos
flotantes serán los argumentos que queremos extraer del ordenador o del
programa, la salida del canal es la pantalla. Sintaxis:
cout << <variable/constante> [<<
<variable/constante>...];
Completando el símil,
en la orden:
Los operadores "<<"
representarían el agua, y la dirección en que se mueve. Cualquier cosa que
soltemos en el agua: "hola", " " o endl, seguirá
flotando hasta llegar a la pantalla, y además mantendrán su orden.
En esta biblioteca se
definen algunas de las funciones aplicables a los "streams", pero aún
no estamos en disposición de acceder a ellas. Baste decir de momento que
existen cuatro "streams" predeterminados:
·
cin, canal de entrada estándar.
·
cout, canal de salida estándar.
·
cerr, canal de salida de errores.
·
clog, canal de salida de diario o
anotaciones.
Cin
Sobre el uso de cin, que es el
único canal de entrada predefinido, tenemos que aclarar cómo se usa, aunque a
lo mejor ya lo has adivinado.
cin >> <variable> [>> <variable>...];
Donde cada variable irá tomando el valor
introducido mediante el teclado. Los
espacios y los retornos de línea actúan como
separadores.
Ejemplo:
Escribir un programa que lea el nombre,
la edad y el número de teléfono de un usuario y los muestre en pantalla.
#include
<iostream>
using namespace std;
int main() {
char Nombre[30]; // Usaremos una cadena
para almacenar
// el nombre (29
caracteres)
int Edad; // Un entero para la
edad
char Telefono[8]; // Y otra cadena para el número de
// teléfono (7 dígitos)
// Mensaje para el usuario
cout << "Introduce tu
nombre, edad y número de teléfono" << endl;
// Lectura de las variables
cin >> Nombre >> Edad
>> Telefono;
// Visualización de los datos leídos
cout << "Nombre:"
<< Nombre << endl;
cout << "Edad:"
<< Edad << endl;
if
En la programación es escencial el manejo de bifurcaciones (si-entonces),
en el Lenguaje C se usa la sentencia if().
Modo de Uso
if(condicion)
{
Acciones
}
{
Acciones
}
Las acciones dentro de las llaves {} se ejecutarán siempre
y cuando se cumpla la condición especificada entre los peréntesis ().
También es posible omitir las llaves si se fuera a ejecutar una sola acción.
La condición puede ser cualquier expresión lógica como por ejemplo a<=b ó x!=0 ó z+10<a&&b>0,
etc.
Ejemplos:
1. Escriba un programa en Lenguaje C que solicite el ingreso de un número
entero e indique si es mayor que cero y si es par.
Solución:
#include <stdio.h>
void main()
{
int a;
printf("Ingrese un numero: ");
scanf("%d",&a);
if(a>0)
printf("El numero es mayor que cero\n");
if(a%2==0)
printf("El numero ingresado numero es
par\n");
}
2. Escriba un programa en Lenguaje C que solicite el ingreso de un número
entero por teclado,
si el número es menor que 12 lo incremente en uno y lo
multiplique por diez; si el número
ingresado es mayor o igual que 12 lo multiplique por
diez y luego lo incremente en uno. Mostrar
el resultado por pantalla.
Solución:
#include <stdio.h>
void main()
{
int a;
printf("Ingrese un numero: ");
scanf("%d",&a);
if(a<12)
{
a++;
a*=10;
}
if(a>=12)
{
a*=10;
a++;
}
printf("El resultado es: %d\n",a);
//Nótese que el orden es importante XD
}
sentencia else.
Veamos otra variante del ejemplo 2 usando la sentencia
else
#include <stdio.h>
void main()
{
int a;
printf("Ingrese un numero: ");
scanf("%d",&a);
if(a<12)
{
a++;
a*=10;
}
else //Si un número no es
menor que 12, entonces es mayor o igual
al mismo
{
a*=10;
a++;
}
printf("El resultado es: %d\n",a);
for
Instrucciones para ciclos resuelven el
problema de repetir todo el programa o cierta parte del programa mas de una
vez.
Este ciclo es uno de los mas usados para
repetir una secuencia de instrucciones, sobre todo cuando se conoce la cantidad
exacta de veces que se quiere que se ejecute una instrucción simple o
compuesta.
Su formato general es:
for (inicialización; condición;
incremento)
{ instrucción(es); };
ejemplo:
for(x=1;x⇐10;x=x+1)
{ puts(” MAMA ”); };
En su forma simple la inicialización es
una instrucción de asignación que carga la variable de control de ciclo con un
valor inicial.
La condición es una expresión relacional
que evalúa la variable de control de ciclo contra un valor final o de parada
que determina cuando debe acabar el ciclo.
El incremento define la manera en que la
variable de control de ciclo debe cambiar cada vez que el computador repite un
ciclo.
Se deben separar esos 3 argumentos con
punto y coma (;)
EJEMPLO
Codigo
prog6.cpp
#include <stdio.h>
#include <conio.h>
#include <string.h>
void main()
{
clrscr();
// declaracion variables
int x;
// instruccion for
for(x=1;x<=10;x=x+1)
{ gotoxy(10, x+4); printf("%d MAMA",x); };
getchar();
}
corrida:
Casos Particulares del ciclo for;
1.- El ciclo comienza en uno y se
incrementa de uno en uno este es el caso mas general.
2.- Pero el valor inicial puede se
diferente de uno, ejemplo;
for(x=5;x⇐15;x=x+1){ etc.};
3.- Incluso el valor inicial puede ser
negativo, ejemplo;
for (x = -3 ;x⇐ 8; x=x+1) {
etc.};
4.- Los incrementos también pueden ser
diferentes al de uno en uno, ej.;
for (x=1; x⇐ 20; x=x+3){ etc. };
5.- Incluso pueden ser decrementos, solo
que en este caso, recordar;
5.1.-el valor inicial de la variable debe
ser mayor que el valor final.
5.2.-cambiar el sentido de la condición.
ejemplo;
for (x= 50 ; x >= 10; x= x-4 ) { etcétera };
6.- Solo para los casos de incrementos y
decrementos de una en una
UNIDAD substituir en el for:
el x = x + 1 por x++
switches
La instrucción switch() es una instrucción de decisión
múltiple, donde el compilador prueba o busca el valor contenido
en una variable contra una lista deconstantes ints o chars, cuando
el computador encuentra el valor de
igualdad entre variable y constante, entonces ejecuta
el grupo de instrucciones asociados a dicha constante,
si no encuentra el valor de igualdad entre variable y constante,
entonces ejecuta un grupo de instrucciones asociados
a un default, aunque este ultimo es opcional.
El formato de esta instrucción
es el siguiente;
capturar o asignar variable de condición;
switch(var int o char)
{
case const1: instrucción(es);
break;
case const2: instrucción(es);
break;
case const3: instrucción(es);
break; ………………
default: instrucción(es);
};
Mejor un ejemplo practico:
Prog5.cpp
#include <stdio.h>
#include <conio.h>
#include <string.h>
void main()
{
// declaracion variables
char letra;
//capturando
clrscr();
gotoxy(10,5);printf("dame una
letra : ");
letra=getchar();getchar();
//empieza switch()
switch(letra)
{
case 'a':
gotoxy(30,5);puts("aguila");break;
case 'b': case 'B':
gotoxy(30,5);puts("baca");break;
case 'c': gotoxy(30,5);puts("caballo
");puts("camello");break;
default:gotoxy(30,5);puts("no
hay");
}
getchar();
}
Uso de sentencias
Sentencia de
ruptura
El uso de
esta sentencia dentro de un bucle, una sentencia de selección o de un bloque,
transfiere la ejecución del programa a la primera sentencia que haya a
continuación. Esto es válido para sentencias switch, como vimos hace un rato, pero
también lo es para sentencias while,do...while, for e if.
En
general, una sentencia break transfiere la ejecución secuencial a la
siguiente sentencia, abandonando aquella en que se ejecuta.
Sintaxis:
break
Ejemplo:
int c = 0;
{
for(int x=0; x < 100; x++) c+=x;
break;
c += 100;
}
c /= 100;
En este
ejemplo, la sentecia
c += 100; no se ejecutará, ya que la sentencia break transfiere la ejecución secuencial fuera del
bloque.
Otro ejemplo:
y = 0;
x = 0;
while(x < 1000)
{
if(y == 1000) break;
y++;
}
x = 1;
En este
otro ejemplo el bucle no terminaría nunca si no fuera por la línea del break, ya que x no cambia.
Después del break el programa continuaría en la línea
x = 1.
Sentencia continue
El uso de esta sentencia dentro de
un bucle ignora el resto del código de la iteración actual, y comienza con la
siguiente, es decir, se transfiere la ejecución a la evaluación de la condición
del bucle. Sintaxis:
continue
Ejemplo:
y = 0;
x = 0;
while(x < 1000)
{
x++;
if(y >= 100) continue;
y++;
}
En este
ejemplo la línea
y++ sólo se ejecutaría mientras y sea menor
que 100, en cualquier otro caso el control pasa a la siguiente iteración, con
lo que la condición del bucle volvería a evaluarse.
Sentencia de salto
Con el uso de esta sentencia el
control se transfiere directamente al punto etiquetado con el identificador
especificado.
Nota: El goto es un mecanismo que está en guerra permanente,
y sin cuartel, con la programación estructurada. Las sentenciasgoto no se deben usar cuando se resuelven problemas mediante
programación estructurada, se incluye aquí porque existe, pero siempre
puede y debe ser eludido. Existen mecanismos suficientes para hacer de otro
modo todo aquello que pueda realizarse con mediante goto.
En cualquier caso, nosotros somos los programadores, y podemos decidir que para cierto programa o fragmento de programa, las ventajas de abandonar la programación estructurada pueden compensar a los inconvenientes. A veces es imperativo sacrificar claridad en favor de velocidad de ejecución. Pero de todos modos, serán situaciones excepcionales.
En cualquier caso, nosotros somos los programadores, y podemos decidir que para cierto programa o fragmento de programa, las ventajas de abandonar la programación estructurada pueden compensar a los inconvenientes. A veces es imperativo sacrificar claridad en favor de velocidad de ejecución. Pero de todos modos, serán situaciones excepcionales.
Sintaxis:
goto <identificador>
Ejemplo:
x = 0;
Bucle:
x++;
if(x < 1000) goto Bucle;
Este
ejemplo emula el funcionamiento de un bucle for como el siguiente:
for(x = 0; x < 1000; x++);
Sentencia de retorno
Esta es la sentencia de salida de
una función, cuando se ejecuta, se devuelve el control a la rutina que llamó a
la función.
Además, se usa para especificar el
valor de retorno de la función. Sintaxis:
return [<expresión>]
Ejemplo:
int Paridad(int x)
{
if(x % 2) return 1;
return 0;
}
Este ejemplo ilustra la
implementación de una función que calcula la paridad de un valor pasado como
parámetro. Si el resto de dividir el parámetro entre 2 es distinto de cero,
implica que el parámetro es impar, y la función retorna con valor 1. El resto
de la función no se ejecuta. Si por el contrario el resto de dividir el
parámetro entre 2 es cero, el parámetro será un número par y la función
retornará con valor cero.
Es
importante dejar siempre una sentencia return sin condiciones en todas las funciones. Esto
es algo que a veces no se tiene en cuenta, y aunque puede no ser extrictamente
necesario, siempre es conveniente. El ejemplo anterior se podría haber escrito
de otro modo, sin tener en cuenta esto:
int Paridad(int x)
{
if(x % 2) return 1;
else return 0;
}
En este
caso, para nosotros está claro que siempre se ejecutará una de las dos
sentencias return, ya que
cada una está en una de las alternativas de una sentencia if...else. Sin embargo, el
compilador puede considerar que todas las sentencias return están en sentencias de selección, sin
molestarse en analizar si están previstas todas las salidas posibles de la
función, con lo que puede mostrar un mensaje de error.
El primer ejemplo es mejor, ya que
existe una salida incondicional. Esto no sólo evitará errores del compilador,
sino que nos ayudará a nosotros mismos, ya que vemos que existe un
comportamiento incondicional.
El único
caso en que una sentencia return no requiere una expresión es cuando el valor
de retorno de la función es void.
Existe un mal uso de las sentencias return, en lo que respecta a la
programación estructurada. Por ejemplo, cuando se usa una sentenciareturn para abandonar una función si se detecta un
caso especial:
int Dividir(int numerador, int denominador)
{
int cociente;
if(0 == denominador) return 1;
cociente = numerador/denominador;
return cociente;
}
Esta función calcula el cociente
de una división entera. Pero hemos querido detectar un posible problema, ya que
no es posible dividir por cero, hemos detectado ese caso particular, y decidido
(erróneamente) que cualquier número dividido por cero es uno.
Sin
embargo, en este caso, el primer return se comporta como una ruptura de secuencia, ya
que se abandona la función sin procesarla secuencialmente. Siendo muy puristas (o pedantes), podemos considerar que esta
estructura no corresponde con las normas de la programación estructurada. Un
ejemplo más conforme con las normas sería:
int Dividir(int numerador, int denominador)
{
int cociente;
if(0 == denominador) cociente = 1;
else cociente = numerador/denominador;
return cociente;
}
Sin
embargo, a menudo usaremos estos atajos para abandorar funciones en caso de error,
sacrificando el método en favor de la claridad en el código.
Uso de las sentencias de salto y la programación estructurada
Lo dicho
para la sentencia goto es válido en general para todas las sentencias
de salto. En el caso de la sentencia break podemos ser un poco más tolerantes, sobre todo
cuando se usa en sentencias switch, donde
resulta imprescindible. En general, es una buena norma huir de las sentencias
de salto.
Comentarios
Los comentarios no son sentencias,
pero me parece que es el lugar adecuado para hablar de ellos. En C++ pueden
introducirse comentarios en cualquier parte del programa. Su función es ayudar
a seguir el funcionamiento del programa durante la depuración o en la
actualización del programa, además de documentarlo. Los comentarios en C, que
también se pueden usar en C++, se delimitan entre /* y */, cualquier cosa que
escribamos en su interior será ignorada por el compilador.
Sólo está prohibido su uso en el
interior de palabras reservadas, de identificadores o de cadenas literales. Por
ejemplo:
int main(/*Sin argumentos*/void)
está permitido, pero sin embargo:
int ma/*función*/in(void)
es ilegal.
Esto no es una limitación seria, a
fin de cuentas, se trata de aclarar y documentar, no de entorpecer la lectura
del código.
En C++ existe otro tipo de
comentarios, que empiezan con //. Estos comentarios no tienen marca de final,
sino que terminan cuando termina la línea. Por ejemplo:
int main(void) // Esto es un comentario
{
return 0;
}
El cuerpo de la función no forma
parte del comentario
No hay comentarios:
Publicar un comentario