QUE ES LA PROGRAMACION:
Sistema de símbolos y reglas que permite la construcción de programas con los que la computadora puede operar así como resolver problemas de manera eficaz.
Estos contienen un conjunto de instrucciones que nos permiten realizar operaciones de entrada / salida, calculo, manipulación de textos, lógica / comparación y almacenamiento / recuperación.
Los lenguajes de programación se clasifican en:
* Lenguaje Máquina: Son aquellos cuyas instrucciones son directamente entendibles por la computadora y no necesitan traducción posterior para que la CPU pueda comprender y ejecutar el programa. Las instrucciones en lenguaje maquina se expresan en términos de la unidad de memoria más pequeña el bit (dígito binario 0 ó 1).
* Lenguaje de Bajo Nivel (Ensamblador): En este lenguaje las instrucciones se escriben en códigos alfabéticos conocidos como mnemotécnicos para las operaciones y direcciones simbólicas.
* Lenguaje de Alto Nivel: Los lenguajes de programación de alto nivel (BASIC, pascal, cobol, fortran, etc.) son aquellos en los que las instrucciones o sentencias a la computadora son escritas con palabras similares a los lenguajes humanos (en general en ingles), lo que facilita la escritura y comprensión del programa.
QUE SON ALGORITMOS:
La palabra algoritmo se deriva de la traducción al latín de la palabra árabe alkhowarizmi, nombre de un matemático y astrónomo árabe que escribió un tratado sobre manipulación de números y ecuaciones en el siglo IX.
La solución a cualquier problema de cómputo involucra la ejecución de una serie de acciones en orden especifico. Un procedimiento para resolver un problema en términos de: a) Las acciones a ejecutarse y b) el orden en el cual estas acciones deben ejecutarse se llama algoritmo.
Un ejemplo de un algoritmo para llegar a la escuela
1. Salir de la cama
2. Quitarse la pijamas
3. Darse un baño
4. Vestirse
5. Desayunar
6. Utilizar el transporte ( autobús, carro , bicicleta, etc)
Las características de un buen algoritmo son:
Debe tener un punto particular de inicio.
Debe ser definido, no debe permitir dobles interpretaciones.
Debe ser general, es decir, soportar la mayoría de las variantes que se puedan presentar en la definición del problema.
Debe ser finito en tamaño y tiempo de ejecución.
DIAGRAMA DE FLUJO:
Un Diagrama de Flujo representa la esquematización gráfica de un algoritmo , el cual muestra gráficamente los pasos o procesos a seguir para alcanzar la solución de un problema . Su correcta construcción es sumamente importante porque , a partir del mismo se escribe un programa en algún Lenguaje de Programación. Si el Diagrama de Flujo está completo y correcto
,el paso del mismo a un Lenguaje de Programación es relativamente simple y directo.
Es importante resaltar que el Diagrama de Flujo muestra el sistema como una red de procesos funcionales conectados entre sí por " Tuberías " y "Depósitos" de datos que permite describir el movimiento de los datos a través del Sistema. Este describirá : Lugares de Origen y Destino de los datos , Transformaciones a las que son sometidos los datos, Lugares en los que se almacenan los datos dentro del sistema , Los canales por donde circulan los datos. Además de esto podemos decir que este es una representación reticular de un Sistema ,el cual lo contempla en términos de sus componentes indicando el enlace entre los mismos.
En el presente Trabajo se representará a través de un Diagrama de Flujo el Procedimiento que debe efectuarse para calcular el pago de los trabajadores de una Empresa .
OPERADORES ARITMETICOS:
A continuación se explican los tipos de operadores (aritméticos y de asignación) que permiten realizar operaciones matemáticas en lenguaje C.
Operadores aritméticos
Existen dos tipos de operadores aritméticos:
Los binarios:
<> +<> Suma
-<> Resta
*<> Multiplicación
/<> División
%<> Módulo (resto)
Los unarios:
<> ++<> Incremento (suma 1)
- -<> Decremento (resta 1)
-<> Cambio de signo
Su sintaxis es:
<> binarios:
<> unarios:
/* Uso de los operadores aritméticos */
#include
main() /* Realiza varias operaciones */
<>
{
<> int a=1,b=2,c=3,r;
r=a+b;
printf("%d + %d = %d\n",a,b,r);
r=c-a;
printf("%d - %d = %d\n",c,a,r);
b++;
printf("b + 1 = %d",b);
<>
}
Operadores de asignación
La mayoría de los operadores aritméticos binarios explicados en el capítulo anterior tienen su correspondiente operador de asignación:
<> =<> Asignación simple
+=<> Suma
-=<> Resta
*=<> Multiplicación
/=<> División
%=<> Módulo (resto)
Con estos operadores se pueden escribir, de forma más breve, expresiones del tipo:
<> n=n+3 se puede escribir n+=3
<> k=k*(x-2) lo podemos sustituir por k*=x-2
/* Uso de los operadores de asignación */
#include
main() /* Realiza varias operaciones */
<>
{
<> int a=1,b=2,c=3,r;
a+=5;
printf("a + 5 = %d\n",a);
c-=1;
printf("c - 1 = %d\n",c);
b*=3;
printf("b * 3 = %d",b);
<>
}
Jerarquía de los operadores
Será importante tener en cuenta la precedencia de los operadores a la hora de trabajar con ellos:
<> ( )<> Mayor precedencia
++, - -
<> *, /, %
<> +, -<> Menor precendencia
Las operaciones con mayor precedencia se realizan antes que las de menor precedencia.
Si en una operación encontramos signos del mismo nivel de precedencia, dicha operación se realiza de izquierda a derecha. A continuación se muestra un ejemplo sobre ello:
<> a*b+c/d-e
<> 1. a*b resultado = x
2. c/d resultado = y
3. x+y resultado = z
4. z-e
Fijarse que la multiplicación se resuelve antes que la división ya que está situada más a la izquierda en la operación. Lo mismo ocurre con la suma y la resta.
/* Jerarquía de los operadores */
#include
main() /* Realiza una operación */
{
int a=6,b=5,c=4,d=2,e=1,x,y,z,r;
x=a*b;
printf("%d * %d = %d\n",a,b,x);
y=c/d;
printf("%d / %d = %d\n",c,d,y);
z=x+y;
printf("%d + %d = %d\n",x,y,z);
r=z-e;
printf("%d = %d",r,a*b+c/d-e);
}
Salida / Entrada
Sentencia printf( )
La rutina printf permite la aparición de valores numéricos, caracteres y cadenas de texto por pantalla.
El prototipo de la sentencia printf es el siguiente:
<> printf(control,arg1,arg2...);
En la cadena de control indicamos la forma en que se mostrarán los argumentos posteriores. También podemos introducir una cadena de texto ( sin necesidad de argumentos ), o combinar ambas posibilidades, así como secuencias de escape.
En el caso de que utilicemos argumentos deberemos indicar en la cadena de control tantos modificadores como argumentos vayamos a presentar.
El modificador está compuesto por el caracter % seguido por un caracter de conversión, que indica de que tipo de dato se trata.
/* Uso de la sentencia printf() 1. */
#include
main() /* Saca por pantalla una suma */
{
int a=20,b=10;
printf("El valor de a es %d\n",a);
printf("El valor de b es %d\n",b);
printf("Por tanto %d+%d=%d",a,b,a+b);
}
Los modificadores más utilizados son:
<> %c<> Un único carácter
%d<> Un entero con signo, en base decimal
%u<> Un entero sin signo, en base decimal
%o<> Un entero en base octal
%x<> Un entero en base hexadecimal
%e<> Un número real en coma flotante, con exponente
%f<> Un número real en coma flotante, sin exponente
%s<> Una cadena de caracteres
%p<> Un puntero o dirección de memoria
/* Uso de la sentencia printf() 2. */
#include
main() /* Modificadores 1 */
{
char cad[]="El valor de";
int a=-15;
unsigned int b=3;
float c=932.5;
printf("%s a es %d\n",cad,a);
printf("%s b es %u\n",cad,b);
printf("%s c es %e o %f",cad,c,c);
}
El formato completo de los modificadores es el siguiente:
<> % [signo] [longitud] [.precisión] [l/L] conversión
Signo: indicamos si el valor se ajustará a la izquierda, en cuyo caso utilizaremos el signo menos, o a la derecha ( por defecto ).
Longitud: especifica la longitud máxima del valor que aparece por pantalla. Si la longitud es menor que el número de dígitos del valor, éste aparecerá ajustado a la izquierda.
Precisión: indicamos el número máximo de decimales que tendrá el valor.
l/L: utilizamos l cuando se trata de una variable de tipo long y L cuando es de tipo double.
/* Uso de la sentencia printf() 3. */
#include
main() /* Modificadores 2 */
{
char cad[ ]="El valor de";
int a=25986;
long int b=1976524;
float c=9.57645;
printf("%s a es %9d\n",cad,a);
printf("%s b es %ld\n",cad,b);
printf("%s c es %.3f",cad,c);
<>
}
Sentencia scanf( )
La rutina scanf permite entrar datos en la memoria del ordenador a través del teclado.
El prototipo de la sentencia scanf es el siguiente:
<> scanf(control,arg1,arg2...);
En la cadena de control indicaremos, por regla general, los modificadores que harán referencia al tipo de dato de los argumentos. Al igual que en la sentencia printf los modificadores estarán formados por el carácter % seguido de un carácter de conversión. Los argumentos indicados serán, nuevamente, las variables.
La principal característica de la sentencia scanf es que necesita saber la posición de la memoria del ordenador en que se encuentra la variable para poder almacenar la información obtenida. Para indicarle esta posición utilizaremos el símbolo ampersand ( & ), que colocaremos delante del nombre de cada variable. ( Esto no será necesario en los arrays ).
/* Uso de la sentencia scanf(). */
#include
main() /* Solicita dos datos */
<>
{
<> char nombre[10];
int edad;
printf("Introduce tu nombre: ");
scanf("%s",nombre);
printf("Introduce tu edad: ");
scanf("%d",&edad);
}
Operadores Relaciónales
Los operadores relacionales se utilizan para comparar el contenido de dos variables.
En C++ existen seis operadores relacionales básicos:
<> ><> Mayor que
<<> Menor que
>=<> Mayor o igual que
<=<> Menor o igual que
==<> Igual que
!=<> Distinto que
El resultado que devuelven estos operadores es 1 para Verdadero y 0 para Falso.
Si hay más de un operador se evalúan de izquierda a derecha. Además los operadores == y != están por debajo del resto en cuanto al orden de precedencia.
/* Uso de los operadores relacionales. */
#include
main() /* Compara dos números entre ellos */
{
int a,b;
printf("Introduce el valor de A: ");
scanf("%d",&a);
printf("Introduce el valor de B: ");
scanf("%d",&b);
if(a>b)
printf("A es mayor que B");
else if(a
printf("B es mayor que A");
else
printf("A y B son iguales");
}
Sentencia Condicionales<>
Este tipo de sentencias permiten variar el flujo del programa en base a unas determinadas condiciones.
Existen varias estructuras diferentes:
Estructura IF...ELSE
Sintaxis:
<> if (condición) sentencia;
La sentencia solo se ejecuta si se cumple la condición. En caso contrario el programa sigue su curso sin ejecutar la sentencia.
Otro formato:
<> if (condición) sentencia1;
else sentencia2;
Si se cumple la condición ejecutará la sentencia1, sinó ejecutará la sentencia2. En cualquier caso, el programa continuará a partir de la sentencia2.
/* Uso de la sentencia condicional IF. */
#include
main() /* Simula una clave de acceso */
{
int usuario,clave=18276;
printf("Introduce tu clave: ");
scanf("%d",&usuario);
if(usuario==clave)
printf("Acceso permitido");
else
printf("Acceso denegado");
}
Otro formato:
<> if (condición) sentencia1;
else if (condición) sentencia2;
else if (condición) sentencia3;
else sentencia4;
Con este formato el flujo del programa únicamente entra en una de las condiciones. Si una de ellas se cumple, se ejecuta la sentencia correspondiente y salta hasta el final de la estructura para continuar con el programa.
Existe la posibilidad de utilizar llaves para ejecutar más de una sentencia dentro de la misma condición.
/* Uso de la sentencia condicional ELSE...IF. */
#include
main() /* Escribe bebé, niño o adulto */
{
int edad;
printf("Introduce tu edad: ");
scanf("%d",&edad);
if (edad<1)
printf("Lo siento, te has equivocado.");
else if (edad<3) printf("Eres un bebé");
else if (edad<13) printf("Eres un niño");
else printf("Eres adulto");
}
Estructura SWITCH
Esta estructura se suele utilizar en los menús, de manera que según la opción seleccionada se ejecuten una serie de sentencias.
Su sintaxis es:
<> switch (variable){
case contenido_variable1:
sentencias;
break;
case contenido_variable2:
sentencias;
break;
default:
sentencias;
}
Cada case puede incluir una o más sentencias sin necesidad de ir entre llaves, ya que se ejecutan todas hasta que se encuentra la sentencia break. La variable evaluada sólo puede ser de tipo entero o carácter. default ejecutará las sentencias que incluya, en caso de que la opción escogida no exista.
/* Uso de la sentencia condicional SWITCH. */
#include
main() /* Escribe el día de la semana */
{
int dia;
printf("Introduce el día: ");
scanf("%d",&dia);
switch(dia){
case 1: printf("Lunes"); break;
case 2: printf("Martes"); break;
case 3: printf("Miércoles"); break;
case 4: printf("Jueves"); break;
case 5: printf("Viernes"); break;
case 6: printf("Sábado"); break;
case 7: printf("Domingo"); break;
}
}
Operadores Lógicos<>
Los operadores lógicos básicos son tres:
<> &&<> AND
||<> OR
!<> NOT (El valor contrario)
Estos operadores actúan sobre expresiones lógicas. Permiten unir expresiones lógicas simples formando otras más complejas.
V = Verdadero F = Falso
/* Uso de los op. lógicos AND,OR,NOT. */
#include
main() /* Compara un número introducido */
{
int numero;
printf("Introduce un número: ");
scanf("%d",&numero);
if(!(numero>=0))
printf("El número es negativo");
else if((numero<=100)&&(numero>=25))
printf("El número está entre 25 y 100");
else if((numero<25)||(numero>100))
printf("El número no está entre 25 y 100");
}
Bucles
Los bucles son estructuras que permiten ejecutar partes del código de forma repetida mientras se cumpla una condición.
Esta condición puede ser simple o compuesta de otras condiciones unidas por operadores lógicos.
Sentencia WHILE
Su sintaxis es:
<> while (condición) sentencia;
Con esta sentencia se controla la condición antes de entrar en el bucle. Si ésta no se cumple, el programa no entrará en el bucle.
Naturalmente, si en el interior del bucle hay más de una sentencia, éstas deberán ir entre llaves para que se ejecuten como un bloque.
/* Uso de la sentencia WHILE. */
#include
main() /* Escribe los números del 1 al 10 */
{
int numero=1;
while(numero<=10)
{
printf("%d\n",numero);
numero++;
}
}
Sentencia DO...WHILE
Su sintaxis es:
<> do{
sentencia1;
sentencia2;
}while (condición);
Con esta sentencia se controla la condición al final del bucle. Si ésta se cumple, el programa vuelve a ejecutar las sentencias del bucle.
La única diferencia entre las sentencias while y do...while es que con la segunda el cuerpo del bucle se ejecutará por lo menos una vez.
/* Uso de la sentencia DO...WHILE. */
#include
main() /* Muestra un menú si no se pulsa 4 */
{
char seleccion;
do{
printf("1.- Comenzar\n");
printf("2.- Abrir\n");
printf("3.- Grabar\n");
printf("4.- Salir\n");
printf("Escoge una opción: ");
seleccion=getchar();
switch(seleccion){
case '1':printf("Opción 1");
break;
case '2':printf("Opción 2");
break;
case '3':printf("Opción 3");
}
}while(seleccion!='4');
}
Sentencia FOR
Su sintaxis es:
<> for (inicialización;condición;incremento){
sentencia1;
sentencia2;
}
La inicialización indica una variable (variable de control) que condiciona la repetición del bucle. Si hay más, van separadas por comas:
<> for (a=1,b=100;a!=b;a++,b- -){
El flujo del bucle FOR transcurre de la siguiente forma:
/* Uso de la sentencia FOR. */
#include
main() /* Escribe la tabla de multiplicar */
{
int num,x,result;
printf("Introduce un número: ");
scanf("%d",&num);
for (x=0;x<=10;x++){
result=num*x;
printf("\n%d por %d = %d\n",num,x,result);
}
}
Sentencia BREAK
Esta sentencia se utiliza para terminar la ejecución de un bucle o salir de una sentencia SWITCH.
Sentencia CONTINUE
Se utiliza dentro de un bucle. Cuando el programa llega a una sentencia CONTINUE no ejecuta las líneas de código que hay a continuación y salta a la siguiente iteración del bucle.
Y aquí termina el capítulo dedicado a los bucles. Existe otra sentencia, GOTO, que permite al programa saltar hacia un punto identificado con una etiqueta, pero el buen programador debe prescindir de su utilización. Es una sentencia muy mal vista en la programación en C++.
/* Uso de la sentencia CONTINUE. */
#include
main() /* Escribe del 1 al 100 menos el 25 */
<>
{
int numero=1;
while(numero<=100)
{
if (numero==25)
<>
{
<> numero++;
continue;
}
printf("%d\n",numero);
numero++;
}
}
OPERADORES LOGICOS:
Operadores lógicos
§1 Sinopsis
Los operadores lógicos producen un resultado booleano, ( 3.2.1b), y sus operandos son también valores lógicos o asimilables a ellos (los valores numéricos son asimilados a cierto o falso según su valor sea cero o distinto de cero). Por contra, recuerde que las operaciones entre bits ( 4.9.3) producen valores arbitrarios.
Los operadores lógicos son tres; dos de ellos son binarios, el último (negación) es unario. Tienen una doble posibilidad de representación en el Estándar C++ actual: la representación tradicional que se indica a continuación, y la natural introducida recientemente que se detalla más adelante .
*
Y lógico && AND
*
O lógico || OR
*
Negación lógica ! NOT
Las expresiones conectadas con los operadores && y || se evalúan de izquierda a derecha, y la evaluación se detiene tan pronto como el resultado verdadero o falso es conocido (muchos programas tienen una lógica que se basa en este propiedad).
§2 && Operador Y lógico
También denominado por su nombre en inglés (generalmente en mayúsculas) AND lógico. Devuelve un valor lógico true si ambos operandos son ciertos. En caso contrario el resultado es false.
Sintaxis
expr-AND-logica && expresion-OR-inclusive
OPERADOES RELACIONALES:
Operadores relacionales
§1 Sinopsis
Los operadores relacionales, también denominados operadores binarios lógicos y de comparación, se utilizan para comprobar la veracidad o falsedad de determinadas propuestas de relación (en realidad se trata respuestas a preguntas). Las expresiones que los contienen se denominan expresiones relacionales. Aceptan diversos tipos de argumentos, y el resultado, que es la respuesta a la pregunta, es siempre del tipo cierto/falso, es decir, producen un resultado booleano ( 3.2.1b)
Si la propuesta es cierta, el resultado es true (un valor distinto de cero), si es falsa false (cero). C++ dispone de los siguientes:
< Menor que
> Mayor que
<= Menor o igual que
>= Mayor o igual que
== Igual que (identidad)
!= Desigual que (desigualdad)
§2 Sintaxis
expresión-relacional < shift-expresion
expresión-relacional > shift-expresion
expresión-relacional <= shift-expresion
expresión-relacional >= shift-expresion
expresión-de-igualdad == expresión-relacional
expresión-de-igualdad != expresión-relacional
COMO ES LA ESTRUCTURA DE UN PROGRAMA:
En general, un programa en C consta de las siguientes partes:
* Directivas al preprocesador.
* Definición de tipos de datos.
* Declaración de variables.
* Definición de funciones.
Cualquier programa debe poseer una función, llamada main, que es la función que toma el control cuando se corre el programa.
No hay comentarios:
Publicar un comentario