República Bolivariana de Venezuela

Ministerio del Poder Popular para la Defensa

Universidad Nacional Experimental Politécnica de la Fuerza Armada

Núcleo Barinas

LENGUAJE DE
PROGRAMACION

Autor (es):
Sánchez Elvis
C.I.N° 16.638.204
Sección: “A”
Ingeniería en Sistemas

Barinas, marzo de 2011

PERFIL DEL PROFESIONAL DE INGENIERÍA EN SISTEMAS

El Ingeniero en Sistemas está capacitado para desempeñarse en el medio industrial,
empresarial u oficial y en todas las áreas de aplicación de esta especialidad, razón por la
cual también debe estar en capacidad de:
•
• Organizar con base en principio administrativo, la unidad, departamento o
servicio.
• Aplicar técnicas organización y métodos de trabajo para cumplir funciones
administrativos o de manufactura y control.
• Organizar, administrar y manejar información.
• Aplicar criterios de racionalidad y orientar la Gerencia sobre las alternativas
posibles y óptimas para la solución de un problema planteado.
• Seleccionar equipos y maquinarias de sistemas computarizados de acuerdo con
sus potencialidades y limitaciones.
• Prácticas en equipos interdisciplinarios para el desarrollo de investigación y
proyectos.
• Elaborar informes dirigidos al equipo de trabajo, al supervisor inmediato y/o a las
autoridades a quienes compete.
• Participar en la realización de proyectos institucionales.
En la formación de los Ingenieros en Sistemas son diversas las habilidades, destrezas,
valores y actitudes necesarias para que ellos manifiesten por una parte, una conciencia
ciudadana para la conservación y mejoramiento del ambiente, calidad de vida y uso
racional de los recursos naturales y por otra parte, capacidad para ejercer
satisfactoriamente su profesión y promover su actualización y mejoramiento conforme a
las necesidades del desarrollo nacional y del proceso científico.
La lista de habilidades y destrezas, así como la de valores y actitudes que se necesitan
para el ejercicio de cada una de las funciones del Ingeniero de Sistemas es la siguiente:
• Capacidad para el mejoramiento de equipo.
• Capacidad de expresarse oralmente y por escrito.
• Capacidad de autoaprendizaje.
• Capacidad organizativa.
• Habilidad numérica.
• Capacidad de análisis y síntesis.
• Capacidad de evaluación.
• Capacidad para razonamiento abstracto.
• Capacidad de presentar ideas a partir de juicio propio, objetividad de criterio y
precisión de las observaciones.
• Creatividad: capacidad de generar nuevas ideas.
Valores y Actividades
• Socialmente responsable, ético y democrático.
 • Capacidad de liderazgo.
• Puntualidad, disciplina e iniciativa en el trabajo.
• Capacidad de adaptación al trabajo en sitios inhóspitos.
• Sociabilidad: capacidad de tratar bien a las personas y mantener contactos
personales adecuados.
• Autocrítica: capacidad de reconocer las propias limitaciones.
• Espíritu de cooperación: con la empresa o centro y con quienes le rodean.
• Identidad con la profesión: sentido de pertenencia, vocación de servicio.
• Compromiso con la tarea: abnegación, responsabilidad.
• Disponibilidad: asiduidad y constancia, disciplina en la aceptación de
responsabilidades.

2.- ¿Qué es programación, programa, lenguaje de programación, variable,

constante, datos?
La programación: es el proceso de diseñar, escribir, probar, depurar y mantener el
código fuente de programas computacionales. El código fuente es escrito en un lenguaje
de programación. El propósito de la programación es crear programas que exhiban un
comportamiento deseado. El proceso de escribir código requiere frecuentemente
conocimientos en varias áreas distintas, además del dominio del lenguaje a utilizar,
algoritmos especializados y lógica formal. Programar no involucra necesariamente otras
tareas tales como el análisis y diseño de la aplicación (pero si el diseño del código),
aunque si suelen estar fusionadas en el desarrollo de pequeñas aplicaciones.
Programa: es un conjunto de instrucciones que una vez ejecutadas realizarán una o
varias tareas en una computadora. Sin programas, estas máquinas no pueden funcionar.
Al conjunto general de programas, se le denomina software, que más genéricamente se
refiere al equipamiento lógico o soporte lógico de una computadora digital.
Lenguaje de programación: es un idioma artificial diseñado para expresar
computaciones que pueden ser llevadas a cabo por máquinas como las computadoras.
Pueden usarse para crear programas que controlen el comportamiento físico y lógico de
una máquina, para expresar algoritmos con precisión, o como modo de comunicación
humana. Está formado por un conjunto de símbolos y reglas sintácticas y semánticas
que definen su estructura y el significado de sus elementos y expresiones.
Variable: las variables son espacios reservados en la memoria que, como su nombre
indica, pueden cambiar de contenido a lo largo de la ejecución de un programa. Una
variable corresponde a un área reservada en la memoria principal del ordenador
pudiendo ser de longitud:
• Fija.- Cuando el tamaño de la misma no variará a lo largo de la ejecución del
programa. Todas las variables, sean del tipo que sean tienen longitud fija, salvo
algunas excepciones — como las colecciones de otras variables (arrays) o las
cadenas.
• Variable.- Cuando el tamaño de la misma puede variar a lo largo de la ejecución.
Típicamente colecciones de datos.
Constante: una constante es un valor que no puede ser alterado durante la ejecución de
un programa.
Una constante corresponde a una longitud fija de un área reservada en la memoria
principal del ordenador, donde el programa almacena valores fijos.
Por ejemplo:
• El valor de pi = 3.1416
Por conveniencia, el nombre de las constantes suele escribirse en mayúsculas en la
mayoría de lenguajes.
Dato: un dato es la expresión general que describe las características de las entidades
sobre las cuales opera un algoritmo.
Operadores Lógicos:
Los operadores lógicos producen un resultado booleano, 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 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).
&& 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

La operatoria es como sigue: El primer operando (de la izquierda) es convertido a bool.
Para ello, si es una expresión, se evalúa para obtener el resultado (esta computación
puede tener ciertos efectos laterales). A continuación, el valor obtenido es convertido a
bool cierto/falso siguiendo las reglas de conversión estándar. Si el resultado es false, el
proceso se detiene y este es el resultado, sin que en este caso sea necesario evaluar la
expresión de la derecha (recuérdese que en el diseño de C++ prima la velocidad).
Si el resultado del operando izquierdo es cierto, se continúa con la evaluación de la
expresión de la derecha, que también es convertida a bool. Si el nuevo resultado es
true, entonces el resultado del operador es true. En caso contrario el resultado es false.
Nota: la Norma informa que antes de ser evaluada la expresión derecha, han sucedido
todos los posibles efectos laterales de la expresión izquierda, a excepción de la
destrucción de los posibles objetos temporales que se hubiesen creado.
Ejemplo:
int m[3] = {0,1,2};
int x = 0;
if (m && x) cout << "Cierto.";
else cout << "Falso.";
Salida:
Falso.
El valor m, que es interpretado como un puntero al primer elemento de la matriz, es
transformado a un bool. Como es distinto de cero (no es un puntero nulo) el resultado es
cierto. A continuación, el valor x es convertido también a bool. En este caso la
conversión produce falso, con lo que este es el resultado del paréntesis de la sentencia
if.
Ejemplo
#include <iostream.h>

bool alto = true, bajo = false, blanco = true, negro = false;

int main (void) {

if (alto && bajo) { cout << "Uno cierto" << endl; }
else cout << "Uno falso" << endl;
if (alto && blanco) { cout << "Dos cierto" << endl; }
else cout << "Dos falso" << endl;
if (bajo && negro) { cout << "Tres cierto" << endl; }
else cout << "Tres falso" << endl;
}
Salida:
Uno falso
Dos cierto
Tres falso
|| Operador O lógico
Este operador binario devuelve true si alguno de los operandos es cierto. En caso
contrario devuelve false.
Sintaxis

expr-OR-logica || expresion-AND-logica
Este operador sigue un funcionamiento análogo al anterior. El primer operando
(izquierdo) es convertido a bool. Para ello, si es una expresión, se evalúa para obtener
el resultado (esta computación puede tener ciertos efectos laterales). A continuación el
valor obtenido es convertido a bool cierto/falso siguiendo las reglas de conversión
estándar. Si el resultado es true, el proceso se detiene y este es el resultado, sin que en
este caso sea necesario evaluar la expresión de la derecha (recuérdese que en el
diseño de C++ prima la velocidad).
Si el resultado del operando izquierdo es false, se continúa con la evaluación de la
expresión de la derecha, que también es convertida a bool. Si el nuevo resultado es
true, entonces el resultado del operador es true. En caso contrario el resultado es false.
Nota: el Estándar establece que antes de ser evaluada la expresión derecha, han
sucedido todos los posibles efectos laterales de la expresión izquierda, a excepción de la
destrucción de los posibles objetos temporales que se hubieran creado.
Ejemplo
#include <iostream.h>
bool alto = true, bajo = false, blanco = true, negro = false;

int main (void) {

if (alto || bajo) { cout << "Uno cierto" << endl; }
else cout << "Uno falso" << endl;
if (alto || blanco) { cout << "Dos cierto" << endl; }
else cout << "Dos falso" << endl;
if (bajo || negro) { cout << "Tres cierto" << endl; }
else cout << "Tres falso" << endl;
}
Salida
Uno cierto
Dos cierto
Tres falso
! Operador NO lógico:
Este operador es denominado también negación lógica y se representa en el texto
escrito por la palabra inglesa NOT (otros lenguajes utilizan directamente esta palabra
para representar el operador en el código).
Sintaxis

! expresion-cast
El operando expresion-cast (que puede ser una expresión que se evalúa a un resultado
es convertido a tipo bool, con lo que solo puede ser uno de los valores cierto/falso. A
continuación el operador cambia su valor: Si es cierto es convertido a falso y viceversa.
Resulta por tanto, que el resultado de este operador es siempre un tipo bool, aunque al
existir una conversión estándar por la que un cero es convertido a false, y cualquier
valor distinto de cero a true coloquialmente se dice que este operador convierte un
operando 0 en 1 y uno no-cero en 0. En otras palabras: este operador devuelve cierto
(true) si la expresión se evalúa a distinto de cero, en caso contrario devuelve falso
(false).
Ejemplo
#include <iostream.h>
bool alto = true, bajo = false;
int main (void) {
if (alto) { cout << "Uno cierto" << endl; }
else cout << "Uno falso" << endl;
if (!alto) { cout << "Dos cierto" << endl; }
else cout << "Dos falso" << endl;
if (!bajo) { cout << "Tres cierto" << endl; }
else cout << "Tres falso" << endl;
}
Salida:
Uno cierto
Dos falso
Tres cierto
Si E es una expresión, !E es equivalente a (0 == E). Como consecuencia, las
expresiones que siguen son equivalentes dos a dos:
if (! valid);
if (valid == 0);
...
if (valid);
if (valid != 0);
Operadores Aritméticos:
Los operadores aritméticos se usan para realizar cálculos de aritmética de números
reales y de aritmética de punteros. C++ dispone de los siguientes:
+ Dos posibilidades: Suma binaria ; más unitario .
++ Incremento unitario (dos clases )
- Dos posibilidades: Resta binaria ; menos unitario .
-- Decremento unitario (dos clases )
* Multiplicación (este símbolo tiene también otros usos )
/ División .
% Resto o módulo .
Nota: la aritmética de números reales es la clásica de la escuela primaria. La de
punteros es una aritmética un tanto especial y rudimentaria.
Observaciones
Los operadores aritméticos pertenecen a dos grupos: unos aceptan operandos de tipo
numérico; otros aceptan operandos de tipo puntero-a-tipoX. Además son de dos tipos;
unarios (que aceptan un solo operando) y binarios (que aceptan dos). La clasificación es
la siguiente:
Operadores aritméticos unarios:
+ más unitario.
++ Incremento unitario (dos clases)
- menos unitario.
-- Decremento unitario (dos clases)
Operadores artiméticos binaros:
+ Suma binaria.
- Resta binaria.
* Multiplicación
/ División.
% Resto o módulo.
Estos últimos pueden combinarse con el de asignación = para dar origen a operadores
compuestos son los siguientes:
+= Asigna suma
-= Asigna diferencia (resta)
*= Asigna producto
/= Asigna división
%= Asigna resto (módulo)

Tenga en cuenta que existen distintos operadores enmascarados bajo los mismos
símbolos + y -. Es un caso de sobrecarga incluida en el propio lenguaje. Como en el
resto de los casos de sobrecarga, el compilador deduce por el contexto de que versión
del operador se trata. Como veremos inmediatamente, en C++ es perfectamente válida
una expresión del tipo:
int x = *ptr+-*++ptr;
En el ejemplo siguiente se muestran los casos posibles:
int ai[] = {2, 3};
int* ptr = ai;
int r1 = +ai[0]; // L.3: más unitario sobre tipo numérico
int r2 = -ai[1] // L.3: menos unitario sobre tipo numérico
int r3 = ai[0] + ai[1]; // L.4: 2 + 3 suma binaria (de enteros)
int r4 = ai[1] - ai[0] // L.5: 3 - 2 resta binaria (de enteros)
int r5 = ai[0] + -ai[1]; // L.6: 2 +(-3) suma binaria seguida de menos unitario
int r6 = *ptr + -*++ptr; // L.7: Suma binaria (de enteros) a + (-b)

En L.7 coexisten tres operadores aritméticos no homogéneos (de izquierda a derecha):

+ Suma binaria entre valores numéricos tipo int. Los valores *ptr y -*++ptr
- Negación unitaria de un valor numérico tipo int ; el valor *(++ptr)
++ Preincremento de un puntero-a-int. Equivale a suma binaria de puntero y entero: +
+ptr == ptr = ptr + 1
Nota: aunque válida, la sentencia de L.7 es un ejemplo de expresión peligrosa y
desaconsejada. Se ha presentado una explicación del sorpresivo resultado ( 0 ) que se
obtiene para L.6.
Suma y resta binaria
En el primer caso: suma y resta binaria, caben dos posibilidades sintácticas:
a- expresión-suma + expresión-de-multiplicación
b- expresión-suma - expresión-de-multiplicación
Operador Suma binaria
Las posibilidades para los operandos en la expresión A + B son los siguientes:
1. A y B son tipos aritméticos, enteros o fraccionarios. En este caso ambos
operandos están sujetos a las posibles conversiones aritméticas estándar y el
resultado es la suma aritmética de ambos. Ejemplo:
int x = 10, y = 20;
int z = x + y; // z == 30
2. A es un entero y B es un puntero a objeto. Ejemplo:
int arr[5] = {1, 2, 3, 4, 5};
int* ptr = &arr[0]; // Señala a 1
int x = *(2 + ptr); // x == 3
3. A es un puntero a objeto y B es un entero. En estos dos últimos casos se aplican
las reglas de aritmética de punteros. Ejemplo:
int z = *(ptr + 3); // x == 4
Operador Resta binaria.
Las posibilidades para los operandos en la expresión A - B son los siguientes:
1. A y B son de tipo aritmético, entero o fraccionario; las posibilidades son las
mismas que en el caso 1 de la suma binaria expuesta anteriormente. El resultado
es la resta aritmética de ambos operandos. Ejemplo:
int x = 10, y = 20;
int z = x - y; // z == -10
2. A y B son punteros a objetos de tipos compatibles. Ejemplo:
int arr[5] = {1, 2, 3, 4, 5};
int* pt1 = &arr[0]; // Señala a 1
int* pt2 = &arr[4]; // Señala a 5
int x = pt2 - pt1; // x == 4
3. A es un puntero a objeto y B es un entero. En estos dos últimos casos se aplican
las reglas de aritmética de punteros. Ejemplo:
int arr[5] = {1, 2, 3, 4, 5};
int* ptr = &arr[4]; // señala a 5
int x = *(ptr - 2); // x == 3
Operadores ± Unitarios
Cuando los operadores + y - se utilizan como operadores unitarios, las posibilidades
sintácticas son:
+ <expresión-cast>
- <expresión-cast>
En ambos casos <expresión-cast> debe ser de tipo numérico. Los resultados son
respectivamente:
• Valor del operando expresión-cast después de cualquier promoción interna que
sea necesaria.
• Valor negativo del operando expresión-cast después de cualquier promoción
interna que se necesite.
Nota: recuerde que cuando + y - se utilizan como operadores unitarios, tienen mayor
precedencia que cuando se utilizan como suma y resta binarias.
Ejemplo
int x = 7, y = 3;
int r1 = - (y - x); // r1 == 4
int r2 = + (y - x); // r2 == -4
int r3 = - (x - y); // r3 == -4
int r4 = + (x - y); // r4 == 4
Operadores multiplicación y división
Los operadores binarios * (multiplicación) y / (división) realizan sus operaciones
aritméticas correspondientes con todos los tipos numéricos (enteros y fraccionarios).
Sintaxis
expresión-de-multiplicación * expresión-cast
expresión-de-multiplicación / expresión-cast
Operador módulo
El operador binario % (operador de módulo) devuelve el resto de la división de dos
enteros, no puede ser utilizado con números fraccionarios float o double.
Sintaxis
expresión-de-multiplicación % expresión-cast
Ejemplo
int resto = (6 % 4);
cout << "El resto de 6/4 es " << resto << endl;
Salida:
El resto de 6/4 es 2
Operadores incremento y decremento
Los operadores unitarios ++ (incremento) y -- (decremento), suman y restan
respectivamente una unidad al valor de la expresión. Existen dos variedades "Pre" y
"Post" para cada uno de ellos.
Las posibilidades sintácticas son:
postfix-expression ++ (postincremento)
++ expresión-unitaria (preincremento)
postfix-expression -- (postdecremento)
-- expresión-unitaria (predecremento)
En los ejemplos que siguen suponemos que originariamente n == 5.
El postincremento añade uno a la expresión después de que se ha evaluado:
x = n++ ; // -> x == 5 y n == 6
El preincremento añade uno antes de que sea evaluada la expresión.
x = ++n ; // -> x == 6 y n == 6
El postdecremento resta uno del valor de la expresión después de que sea evaluada.
x = n-- ; // -> x == 5 y n == 4
El predecremento resta uno antes de la evaluación de la expresión.
x = --n ; // -> x == 4 y n == 4
En ambos casos, el operando debe ser una variable, no una expresión. Por ejemplo:
(x+y)++ es ilegal.

Para evidenciar la diferencia entre preincremento y postincremento, observe las salidas

que se obtienen con este pequeño programa según se van ejecutando las diversas
líneas. Para interpretarlas correctamente debe tener en cuenta la precedencia de los
operadores y recordar que, en todos los casos, el argumento recibido por printf es un
puntero-a-carácter (char*). También deben recordarse las reglas de ámbito de los
argumentos pasados a funciones.
char * s = "Hola mundo";
printf("Letra: \"%c\"\n", *s); // Letra "H"
printf("Letra: \"%c\"\n", *s+1); // Letra "I"
printf("Letra: \"%c\"\n", *(s+1)); // Letra "o"
printf("Letra: \"%c\"\n", *s++); // Letra "H"
printf("Letra: \"%c\"\n", *s); // Letra "o"
printf("Letra: \"%c\"\n", *++s); // Letra "l"
printf("Letra: \"%c\"\n", *s); // Letra "l"

Lenguajes de programación mas conocidos:

• Fortran
• Prolog
• Java
• Visual
• ADA
• Clipper
• Smalltalk
• C/C++
• Fox Pro
• SQL

Nota: Profesor a la verdad voy a ser sincero con usted… en programación estoy mal, por
tal razón no pude responder la ultima pregunta… También el día sábado para mi es
difícil asistir a su clase y le plantee mi posición en la clase pasada. Le pido por favor
pueda darme una solución para esta situación… Dios le bendiga…