School Work > Essays & Theses">
Construccion Del Comportamiento de Un Objeto
Construccion Del Comportamiento de Un Objeto
Construccion Del Comportamiento de Un Objeto
NOMBRE DE LA MATERIA:
FUNDAMENTOS DE PROGRAMACION
DOCENTE:
ESPECIELIDAD:
PRESENTA:
MARIA ELENA CASTILLO ANTONIO
SEMESTRE
GRUPO
1º “A”
Los métodos y funciones en C++ pueden devolver una variable u objeto, bien sea por valor
(se devuelve una copia), por puntero o por referencia. Java no soporta punteros, así que no
puede devolver nada por puntero.
Para devolver un valor se utiliza la palabra clave return. La palabra clave return va seguida de
una expresión que será evaluada para saber el valor de retorno. Esta expresión puede ser
compleja o puede ser simplemente el nombre de un objeto, una variable de tipo primitivo o
una constante.
En C++, si un programa devuelve un puntero a un objeto situado en memoria dinámica y el
valor de ese puntero no se asigna a una variable, la posibilidad de devolver la memoria al
sistema se pierde y se producirá un memory leak, asumiendo que la dirección no está ya
disponible para almacenar ninguna otra variable.
en C++ el tipo del valor de retorno debe coincidir con el tipo de retorno que se ha indicado en
la declaración del método; aunque en Java, el tipo actual de retorno puede ser una subclase
del tipo que se ha indicado en la declaración del método, lo cual no se permite en C++.
DIAGRAMAS DE FLUJO:
Un diagrama de flujo es la representación gráfica de un algoritmo. También se puede decir que es la
representación detallada en forma gráfica de cómo deben realizarse los pasos en la computadora para
producir resultados.
Esta representación gráfica se da cuando varios símbolos (que indican diferentes procesos en la
computadora), se relacionan entre sí mediante líneas que indican el orden en que se deben ejecutar los
procesos. Los símbolos utilizados han sido normalizados por el instituto norteamericano de
normalización (ANSI):
Símbolo Descripción
El pseudocódigo nació como un lenguaje similar al inglés y era un medio representar básicamente
las estructuras de control de programación estructurada. Se considera un primer borrador, dado
que el pseudocódigo tiene que traducirse posteriormente a un lenguaje de programación. Cabe
señalar que el pseudocódigo no puede ser ejecutado por una computadora.
El pseudocódigo utiliza para representar las acciones sucesivas palabras reservadas en inglés
(similares a sus homónimos en los lenguajes de programación), tales como star,begin, end, stop,
if-then-else, while, repeat-until….etc
Las acciones sucesivas se escriben en cajas sucesivas, y, como en los diagramas de flujo,
se pueden escribir diferentes acciones en una caja.
Los Diagramas Estructurados, son una técnica que permite formular algoritmos mediante
una representación geométrica y de asignación de espacios de un bloque específico.
Algoritmos estáticos, es decir, algoritmos que funcionan siempre igual, independientemente del
tipo de problema tratado. Por ejemplo, los sistemas basados en el método de resolución.
Algoritmos probabilísticos, es decir, algoritmos que no utilizan valores de verdad booleanos sino
continuos. Por ejemplo, los sistemas basados en lógica difusa.
Algoritmos adaptativos, es decir, algoritmos con cierta capacidad de aprendizaje. Por ejemplo, los
sistemas basados en redes neuronales.
No determinísticos, sí existe uno ó más pasos en el algoritmo, para el cual es posible predecir
cuál será la salida.
función
//C es el conjunto de candidatos//
si solución(S) entonces
devolver //S es una solución//
si no
devolver //No hay soluciones//
4.2 OPERADORES
Esta es una lista de los operadores de los lenguajes C++ y C. Todos los operadores
listados existen en C++. La tercera columna indica si también está presente en C. También
hay que tener en cuenta que C no permite la sobrecarga de operadores.
Los siguientes operadores son puntos de secuencia en ambos lenguajes (cuando no están
sobrecargados): &&, ||, ?:, y , (el operador coma).
C++ también incluye los operadores de conversión de tipos const_cast, static_cast,
dynamic_cast y reinterpret_cast que no están listados en la tabla por brevedad. El formato
de estos operadores significa que su nivel de precedencia no es importante.
Estos operadores que están en C (con la excepción del operador coma y el operador flecha
también se encuentran en Java, Perl, C# y PHP con la la misma precedencia, asociatividad y
semántica. Con una única excepción: la asociatividad del operador ternario en PHP es de
izquierda a derecha.
Para los objetivos de esta tabla a, b y c representan valores válidos (literales, valores de
variables o valores de retorno), nombres de objetos o valores según el caso.
Operadores aritméticos
Nombre del operador Sintaxis Sobrecargable Incluido en C
Más unitario +a Sí Sí
Suma a + b Sí Sí
Preincremento ++a Sí Sí
Postincremento a++ Sí Sí
Asignación con suma a += b Sí Sí
Menos unitario (negación) -a Sí Sí
Resta a - b Sí Sí
Predecremento --a Sí Sí
Postdecremento a-- Sí Sí
Asignación con resta a -= b Sí Sí
Multiplicación a * b Sí Sí
Asignación con multiplicación a *= b Sí Sí
División a / b Sí Sí
Asignación con división a /= b Sí Sí
Módulo (Resto) a % b Sí Sí
Asignación con módulo a %= b Sí Sí
Operadores de comparación
Nombre del operador Sintaxis Sobrecargable Incluido en C
Menor que a < b Sí Sí
Menor o igual que a <= b Sí Sí
Mayor que a > b Sí Sí
Mayor o igual que a >= b Sí Sí
No igual que a != b Sí Sí
Igual que a == b Sí Sí
Negación lógica !a Sí Sí
AND lógico a && b Sí Sí
OR lógico a || b Sí Sí
Operadores a nivel de bit
Nombre del operador Sintaxis Sobrecargable Incluido en C
Desplazamiento a la izquierda a << b Sí Sí
Asignación con desplazamiento a la izquierda a <<= b Sí Sí
Desplazamiento a la derecha a >> b Sí Sí
Asignación con desplazamiento a la derecha a >>= b Sí Sí
Complemento a uno ~a Sí Sí
AND binario a & b Sí Sí
Asignación con AND binario a &= b Sí Sí
OR binario a | b Sí Sí
Asignación con OR binario a |= b Sí Sí
XOR binario a ^ b Sí Sí
Asignación con XOR binario a ^= b Sí Sí
Otros operadores
Nombre del operador Sintaxis Sobrecargable Incluido en C
Asignación básica a = b Sí Sí
Llamada a función a() Sí Sí
Índice de Array a[b] Sí Sí
Indirección (Desreferencia) *a Sí Sí
Dirección de (Referencia) &a Sí Sí
Miembro de puntero a->b Sí Sí
Miembro a.b No Sí
Desreferencia a miembro por puntero a->*b Sí No
Desreferencia a miembro por objeto a.*b No No
Conversión de tipo (tipo) a Sí Sí
Coma a , b Sí Sí
Condicional ternario a ? b : c No Sí
Resolución de ámbito a::b No No
Puntero a función miembro a::*b No No
sizeof a
Tamaño de sizeof(tipo) No Sí
typeid(a)
Identificación de tipo typeid(tipo) No No
Asignar almacenamiento new tipo Sí No
Asignar almacenamiento (Vector) new tipo[n] Sí No
Desasignar almacenamiento delete a Sí No
Desasignar almacenamiento (Vector) delete[] a Sí No
Precedencia de operadores
La tabla siguiente es una lista que muestra el orden de precedencia y la asociatividad de
todos los operadores del lenguaje de programación C++. Están listados de arriba a abajo por
orden de precedencia descendente y con la misma descendencia en la misma celda
(pueden haber varias filas de operadores en la misma celda). La precedencia de los
operadores no cambia por la sobrecarga.
Una tabla de precendencias, aunque adecuada, no puede resolver todos los detalles. Por
ejemplo el operador ternario permite expresiones arbitrarias como operador central
independientemente de la precedencia del resto de operadores. Así a ? b , c : d es
interpretado como a ? (b, c) : d en vez de (a ? b), (c : d). También hay que tener en cuenta
que el resultado sin paréntesis de una expresión de conversión en C no puede ser el
operando de sizeof. Por eso sizeof (int) * x es interpretado como (sizeof(int)) * x y no como
sizeof ((int) *x).
Operador Descripción Asociatividad
:: Resolución de ámbito (solo C++) Izquierda a
Post- incremento y decremento derecha
++ -- Llamada a función
()
[] Elemento de vector
. Selección de elemento por referencia
-> Selección de elemento con puntero
typeid() Información de tipo en tiempo de ejecución (solo C++)
const_cast Conversión de tipo (solo C++)
dynamic_cast
Conversión de tipo (solo C++)
reinterpret_cast
static_cast Conversión de tipo (solo C++)
Conversión de tipo (solo C++)
++ -- Pre- incremento y decremento Derecha a
+- Suma y resta unitaria izquierda
!~ NOT lógico y NOT binario
(type) Conversión de tipo
* Indirección
&
sizeof Dirección de
new new[]
Tamaño de
delete delete[]
Asignación dinámica de memoria (solo C++)
Desasignación dinámica de memoria (solo C++)
.* ->* Puntero a miembro (solo C++) Izquierda a
*/% Multiplicación, división y módulo derecha
+- Suma y resta
<< >> Operaciones binarias de desplazamiento
< <= Operadores relaciones "menor que", "menor o igual que",
> >= "mayor que" y "mayor o igual que"
== != Operadores relaciones "igual a" y "distinto de"
& AND binario
^ XOR binario
| OR binario
&& AND lógico
|| OR lógico
c?t:f Operador ternario Derecha a
= izquierda
+= -=
*= /= %= Asignaciones
<<= >>=
&= ^= |=
throw Operador Throw (lanzamiento de excepciones, solo C++)
Izquierda a
, Coma
derecha
4.2.1 ARITMETICOS
Los operadores aritméticos nos permiten, básicamente, hacer cualquier operación aritmética, que
necesitemos (ejemplo: suma, resta, multiplicación, etc). En la siguiente tabla se muestran los
operadores de los que disponemos en C y su función asociada.
División
x = 6 2; // x vale 3
Módulo x = 5 % 2; // x vale 1
Decremento x = 1; x ; // x vale 0
Incremento x = 1; x ; // x vale 2
4.2.2 LOGICOS
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
Comentario:
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>
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);
Representación explícita
Los operadores lógicos entre valores lógicos &&, ||, !; la relación de desigualdad !=; algunos de los
operadores lógicos entre bits (&, |, ^, ~) y sus expresiones compuestas (&=, |=, ^=), tienen una
representación realmente difícil de leer, con la desventaja adicional que sus símbolos no siempre están
fácilmente accesibles en ordenadores con teclados distintos del estándar USA. Para resolver este
problema, el Estándar C++ ha introducido nuevas formas para su representación; las denominamos
formas explícitas o naturales, en razón de que se parecen más a las palabras correspondientes del
lenguaje natural. Las nuevas formas constituyen palabras-clave, y la tabla de equivalencias es la
siguiente:
Palabra
Símbolo Descripción
clave
and && Operador Y lógico
or || Operador O lógico
Nota: ni el compilador Borland C++ 5.5 ni MS VC++ 6.0 soportan esta característica del
estándar, aunque el de Microsoft anuncia en su documentación que pueden utilizarse
"defines". Por ejemplo:
#define bitand &
#define bitor |
#define and_eq &=
#define or_eq |=
#define not_eq !=
Por su parte, el compilador GNU gcc dispone de la opción de compilación -fno-operator-
names, que permite que las palabras-clave and, bitand, bitor, compl, not, y or, no sean
tratadas como sinónimos de los operadores correspondientes.
4.2.3 JERARQUIA DE OPERADORES
Jerarquía de Operaciones:
()
signo
Potencia
Producto y división
Div
Mod
Suma y resta
Concatenación
Relacionales
Negación
And
Or
Datos de tipo entero tienen los operadores +, -, *, /, div, mod, abs, sqr, sqrt, ln, exp, sin, cos,
tan, pow, etc. Los datos de tipo real tienen los mismos operadores enteros y además trunc,
round, int, y otros. La suma y multiplicación de datos de tipo real cumplen la propiedad
conmutativa, pero no siempre la asociativa y la distributiva.
Para resolver una expresión aritmética se deben seguir las siguientes reglas:
· Primero se resuelven las expresiones que se encuentran entre paréntesis.
· Se procede aplicando la jerarquía de operadores.
· Al evaluar una expresión, si hay dos operadores con la misma jerarquía, se procede a
evaluar de izquierda a derecha.
· Si hay expresiones relacionales, se resuelven primero paréntesis, luego se encuentran los
valores de verdad de las expresiones relacionales y por último se aplica jerarquía de
operadores lógicos. En caso de haber iguales, proceder de izquierda a derecha.
4.3 EXPRECIONES
En programación, una expresión es una combinación de constantes, variables o funciones,
que es interpretada (evaluada) de acuerdo a las normas particulares de precedencia y
asociación para un lenguaje de programación en particular. Como en matemáticas, la
expresión es su "valor evaluado", es decir, la expresión es una representación de ese valor.
Ejemplos de expresiones
• Expresión aritmética: 3+2, x+1, ...
• Expresión lógica: x OR y, NOT x, ...
• Expresión con predicados: P(a) AND Q(b), ...
Nota: Si existe sola una instrucción o sentencia dentro de la condición no es necesario marcarlos con inicio y
fin, en caso contrario si, como se muestra en el diagrama anterior.
Selectiva doble o compuesta.- evalúa una condición, si esta es verdadera ejecuta la acción o acciones
especificadas, si es falsa ejecuta otra acción o acciones.
Nota: Si existe sola una instrucción o sentencia dentro de la condición no es necesario marcarlos con inicio y
fin como en este caso que la condición fue falsa, en caso contrario si, en este ejemplo cuando la condición fue
verdadera.
Ejemplo: Imprimir si un número es positivo o negativo
int main()
{
� int Lower, Upper, Step;
� float Fahr, Celsius;
� Lower = 0;
� Upper = 300;
� Step = 20;
� Fahr = Lower;
NOTAS:
a;
while(b)
{
� ...
� ...
� c;
}
Ejemplo:
/* Tabla de conversión de grados F a Celsius
utilizando constantes simbólicas y bloque for */
#include <stdio.h>
#define LOWER 0
#define UPPER 300
#define STEP 20
main()
{
int Fahr;
int main()
{
� int n, error;
� do {
����� printf("Ingrese un número entero entre 1 y 10: ");
����� scanf("%d", &n);
����� if (error = (n < 1 || n > 10))
�������� printf("\nERROR: Intentelo nuevamente!!\n\n");
�����} while(error);
��� return 0;
} /* fin del main */