Embed Size (px)
Citation preview
Introducción
Idea: Calcular el valor absoluto de un número x
Datos Resultadosx=4 ¿ x∨¿ 4x=−8 ¿ x∨¿8
Algoritmo:
x real
ER x>0 ¿ x∨¿ x
Es x<0 o x=0 ¿ x∨¿−x
Algoritmo: Es una secuencia de pasos lógicos que llevan a la consecución de un objetivo.
Entrada: Datos asignados a ciertas variables.
Salida: El resultado obtenido por el algoritmo.
Variable: Son posiciones de memoria que pueden almacenar valores y que cambian en el transcurso del programa.Las variables deben ser nombradas empezando siempre con una letra y no acepta caracteres especiales
Caracteres no admitidos: ( ) + - * / > < [ ]Ejemplos correctos: f_X, funcion, valor_absoluto, X_absEjemplos incorrectos: f(x), x+y, x^2
Constantes: Es una variable cuyo valor no cambia en el transcurso del programa.Las contantes son nombradas generalmente con mayúsculas y siguen las mismas reglas que las variables.
Tipos de datos
NuméricosEnteros (x∈Z )Reales (x∈ R)
No NuméricosBoléanos (bool)Caracteres (char)cadenas de caracteres (string)
Operadores
Aritméticos: Suma +Resta -Multiplicación *División /Módulo %
de comparación:Igual ==
Diferente !=Mayor >Menor <Mayor o Igual >=Menor o Igual
<=
de asignación:Igual =
Lógicos:
Ejemplo:6%4=210%5=0
Ejemplo:x==7
x_abs = -x
x_abs = x
x
x < 0
x_abs
si
no
Negación (NO) !Conjunción (Y) &&Disyunción (O) ||
Flujogramas
Es un diagrama que expresa gráficamente los distintos operadores que componen un algoritmo por medio de símbolos y figuras. Muestra la estructura del algoritmo o la secuencia cronológica de los pasos.
Leer el valor de una variable
Ejecutar una operación
Condicional
Escribir el valor de una variable
Ejemplo: Cálculo del valor absoluto
x,x_abs real
a
c = a + b
c ==
a
Pseudo-Código
Es una forma de expresar un algoritmo en una estructura que tiene características de lenguaje de programación.Muestra la lógica y estructura de los algoritmos, la naturaleza de los datos y es de fácil lectura e interpretación.Un algoritmo escrito en pseudo-código es fácil pasarlo a cualquier lenguaje de programación.
SintaxisPROGRAMA: NombreVar: Variable con tipo de datos;const: CONSTANTES;INICIO: NombreInstrucciones;FIN: Nombre
Propiedades: Las variables y contantes deben ser nombradas de acuerdo a la definición de
variables. Al final de cada instrucción se ingresa el símbolo ; Cualquier conjunto de instrucciones deben estar delimitados por Proceso -
Fin Proceso.
Dentro de las instrucciones podemos anotar las siguientes:
Lectura/EscrituraLeer(x) Lee el valor de la variable xEscribir(x) Escribir el valor de la variable x
Si se necesita un texto se ingresa entre comillas.Ejemplo:
Escribir("El valor de x es", x);
Instrucciones de Selección
Selección Binaria: Permite elegir una opción de dos posibles que dependen de una condición. Su sintaxis es:
Si(condición)entoncesProceso
Instrucción; (condición verdadera)Fin ProcesoCaso ContrarioProceso
Instrucción; (condición falsa)Fin Proceso
El caso contrario es opcional.
Si(condición)entoncesProceso
Instrucciones;Fin proceso
Ejemplo:
Si(x>7)entoncesProcesox=x+2;Escribir(“x=”,x);Fin Procesoy=x*x;
Instrucciones de Repetición
Mientras: Repite las instrucciones contenidas mientras la condición de finalización sea verdadera. Su sintaxis es:
Mientras (condición)Proceso
Instrucción;Fin proceso
Ejemplo: Presentar las números enteros en [0,10]
x=0;Mientras(x<=10)Proceso
Escribir(x,”_”9);x=x+1;
Fin proceso
Repetir-Mientras: Es similar al anterior. Repite hasta que la condición sea falsa. Esta instrucción dispone la condición al final por lo que se asegura la ejecución de al menos una instrucción. Su sintaxis es:
RepetirProceso
Instrucciones;Fin procesoMientras(condición);
Para: Esta instrucción se la usa cuando se conoce el número de interacciones y en dicho proceso se ejecuta una o más instrucciones. Su sintaxis es:
Para(variable=L_inferior hasta L_superior; incremento)Proceso
Instrucciones;Fin Proceso
Ejemplo:
Para(x=0 hasta x=10; x=x+1)Proceso
Escribir(x,”-“);Fin proceso
Programación en C++
Ahora nos concentraremos sobre el lenguaje C++. Empezamos definiendo los tipos de datos.
Con estos tipos de datos, nosotros podemos declarar variables o constantes bajo la siguiente sintaxis:
tipo_dato Nombre_Variable;
Para declarar una constante se antepone la palabra const. Generalmente las constantes son nombradas con mayúsculas:
const tipo_dato NOMBRE_CONST=Valor;
Ejemplo:
double x=4, y;int z=8;const double EPS=0,001;
Operadores
Aritméticos: Permiten realizar las operaciones básicas; suma (+), resta (-), multiplicación (*), división (/), módulo (%).
De comparación: Entre ellos podemos mencionar; menor (<), mayor (>), menor o igual (<=), mayor o igual (>=), igualdad (==), distinto (!=).
Lógicos: conjunción (y, and, &&), disyunción (o, or, ||), negación (no, not, !).
De asignación: Atribuyen a una variable un determinado valor. Entre ellos podemos anotar:
= x=x+4;+= x=x+4; x+=4;-= x=x-4; x-=4;*= x=x*4; x*=4;++ x=x+1; x++;-- X=x-1; x--;
De Flujo:Entrada >>Salida <<
Sentencias
Simple: Es una expresión de algún tipo terminada en punto y coma.
Compuesta: Es un conjunto de sentencias simples encerradas entre llaves {…} (Proceso - Fin proceso)
Tipos de datos
Numéricos
Enteros: int, long int
Reales: float, double, long double
No numéricos
Caracter: char
Cadena de caracteres: string
Booleano: bool
Ejemplo:int x;x=x+2;
Ejemplo:{
int x, y=4;x=y+10;y++;
}
Estructura de un programa de C++
#include <iostream>using namespace std;int main (){
···return 0;
}
#includeEn un programa de C++ es necesario incluir librerías estándar, que son archivos pre-programados y que están incluidos en el compilador. La llamada a dichas librerías se realiza mediante #include.El archivo iostream.h escrito entre paréntesis de ángulo <…> permite realizar la entrada/salida de datos.
namespaceCuando se desarrolla un programa complejo en C++ suele ser necesario combinar varias librerías: librerías de C++, del programador o externas. Puede ocurrir que las dos librerías ejecuten distintos procesos bajo un mismo nombre o identificador (funciones, variables) generando errores en la ejecución. A si los namespace intentan resolver estos problemas definiendo distintos ambientes y se los declara bajo la siguiente sintaxis.
namespace Nombre;{
variable;funciones;constantes;
}
Y se accede a sus elementos mediante ::
Ejemplo:namespace Uno{
int x;double y;
}namespace Dos{
int x;double y;
}int main(){
Uno::x=10;Dos::x=50;int y=Uno::x+Dos::x;std::cout << “y=” << y;return 0;
}
En la versión actual, todas las variables, constantes, funciones se encuentran en el namespace std.
Si solo se maneja este ambiente se incluye:using namespace std;
int main()Todos los programas de C++ disponen de una función principal donde se ejecutan los procesos. Esta función es la denominada main(). El valor int devuelto por esta función indica al sistema operativo si el programa se ejecutó correctamente, es decir retornando el valor 0 o si se presentó algún error retorna un valor distinto de 0.
int main (){
···return 0;
}
ComentariosLa misión de los comentarios es de explicar o aclarar los hechos en un determinado programa. Los comentarios no son considerados en el proceso de compilación. Existen dos formas de introducir comentarios:
//comentario de una línea
/*comentarioen varias líneas
*/
Lectura/Escritura de datosPara utilizar las funciones de lectura y escritura necesitamos incluir la librería iostream, es decir:
#include<iostream>
Dentro de este archivo se encuentra:
cout consola de salidacin consola de entradaendl salto de línea
Estas funciones deben ser usadas con los operadores de flujo.
Ejemplo:int a, b;cin >> a;b=a*a;cout << “b=” << b << endl;
Control de flujo de ejecuciónLas sentencias de un programa de C++ se realizan secuencialmente, es decir, se inicia en la primera línea y termina en la última (return 0;). Todo lenguaje dispone de estructuras de control de esta ejecución.
Instrucciones de selección
if: Esta instrucción permite seleccionar una opción de dos posibles, basadas en una condición. Su sintaxis es:
if (condiciones){
sentencias; //caso verdadero}else{
sentencias; //caso falso}
La inclusión de else es opcional. Se pueden incluir instrucciones de selección if anidadas.
Ejemplo:int x, y, a;cin >> x >> y;if (x>y){
x++;y--;
}a=x+y;
switch: Es una instrucción de selección múltiple y se la puede describir como una instrucción if con varias ramificaciones. La sintaxis de switch es la siguiente:
switch (variable){
case valor_cte:{
sentencias;}case valor_cte:{
sentencias;}···default: //ocurre cuando no se ejecuta ningún caso{
sentencias;}
}
Ejemplo:int main(){
int 5;cin >> s;switch (s){
case 1:{
cout << “Ingreso 1”;}case 2:{
int x=4, y;y=x+s;cout << y << endl;
}case 3:{
string k=“caso 3”;char c=’R’;cout << k << “ ” << c << endl;
}default:{
cout << “opción incorrecta”;}
}return 0;
}
Instrucciones de repetición
A demás de las instrucciones de selección en C++ se definen instrucciones que permiten repetir una o más instrucciones dependiendo de una condición.
while: Esta instrucción permite ejecutar repetidamente un bloque de sentencias mientras la condición asociada es verdadera. Si sintaxis es:
while (condición){
sentencias;}
do-while: Es muy similar a la instrucción anterior y la diferencia es que la condición se encuentra al final. Se asegura que se ejecuta al menos una iteración. Su sintaxis es:
do{
sentencias;}while (condición);
for: Es quizá la instrucción de repetición más utilizada. Se la usa cuando se conoce el número de iteraciones y su sintaxis es:
for (inicialización; expresión de control; incremento){
sentencias;}
Exempla:int i=1;double x=0;
while (i<=100){
x=x+i*i;i++;break;
}cout << “x=” << X;
do{
x=x+i*i;i++;
}while (i<=100);
for (int j=1; j<=100; j++){
x=x+i*i;}
Asociados a las instrucciones de repetición están:
break: Termina la instrucción de repetición sin importar si la condición es verdadera.
while (condición){
···break;…
}
continue: Inicia una nueva iteración en la posición donde se encuentre, sin importar si las instrucciones restantes no fueron ejecutadas.
for (inicialización; expresión de control; incremento){
···continue;···
}
Ejemplo: Identificar el punto x∈Z en el cual la función no está definida.
f ( x )= 1x3+3x2+5 x−9
,∀ xϵ [−100,100]
int x=-100;double fx;while (x<=100){
fx=x*x*x+3x*x+5*x-9;if (fx==0){
cout << “f(x) no definida en” << x;break;
}x++;
}
Ejemplo: Calcular la suma de todos los números enteros en [1,100] excepto los múltiplos de 7.
double s=0;for (int i=1; i<=100; i++){
if (i%7==0){
Continue;}s=s+i;
}
void función_cuadrática(double a, double b, double c)
double factorial(int n)
tipo_de_retorno Nombre_función(lista de argumentos)
Funciones
Una función es una parte de código independiente del programa principal y de otras funciones manteniendo gran independencia entre las variables, facilitando el desarrollo y mantenimiento del programa, evitando errores, ahorrando memoria y reduciendo el trabajo del programador. Las funciones pueden ser llamadas/ejecutadas asignándolos a ciertos valores de entrada (o incluso sin ellos), para que realice un conjunto de tareas y proporcione un resultado.
Una misma función puede ser llamada varias veces por lo que no es necesario reescribirlaEjemplo:
x= n!r !(n−r )!
⇒ factorial (n)factorial (r )∗factorial(n−r )
Mediante el uso de funciones se puede lograr un código limpio, claro y elegante.
Función: Una función consiste en la definición del código necesario para que realice un conjunto de tareas. La declaración de la función debe realizarse en algún archivo del programa. La sintaxis es la siguiente
tipo_de_retorno Nombre_función(lista de argumentos){
declaración_variables (locales);sentencias;return expresión o variable;
}
La primera parte de las funciones se la conoce como, el encabezado y el resto encerrado entre llaves es el cuerpo de la misma.Dentro de los tipos_de_retorno podemos considerar los siguientes:
El nombre de las funciones debe respetar las mismas reglas de la declaración de variables.
La lista de argumentos son declaraciones de variables separadas por comas, precedidas por su correspondiente tipo de dato. Las variables declaradas en la lista de argumentos no pueden ser inicializadas en el encabezado.Ejemplo:
Toda función puede disponer de sus propias variables/constantes declaradas dentro del cuerpo de la función, y que por defecto son tipo local.
Variable local: Una variable local es aquella cuyo ámbito se restringe específicamente a la función donde fue declarada. Esto implica que dicha variable puede ser manipulada dentro de la función, pero no podrá ser usada fuera de la misma.
Variable global: Una variable global es aquella que fue declarado fuera de cualquier función (generalmente se los declara al inicio del programa, luego de las librerías).
El ámbito de estas variables/constantes es toda función que compone el programa.
cuando una sola variable es soluición
double
int
string
bool
La función retorna un valor nulo (no
retorna ningun valor)VOID
Ejemplo:#include<iostream>using namespace std;const double INFINITO=1e20;string s_error=“Se ha producido un error”;double factorial(int n){
double f=1;for(int i=1; i<=n; i++){
f=f*i;}return f/INFINITO;
}
Cuando una función es ejecutada, esta debe algún tipo de valor (valor_de_retorno) cuyo tipo se encuentra especificado en el encabezado.La sentencia “return” permite devolver el control al programa que la a esa función. “return” debe ir seguirá de una variable o expresión que almacena el resultado de esa función.
Todas las funciones cuyo tipo_de_retorno, es distinto de “void” debe tener el “return” asociado a alguna variable o expresión.
Cuando una función se encuentra constantemente declarada, esta puede ser llamada por el programa principal o por otras funciones. El llamado se lo hace incluyendo el nombre de la función seguido de un conjunto de argumentos actuales (listas de argumentos con valores).
Llamadas de funciones tipo VOIDdouble x=4, y=6, z=10;funcion_cuadratica(x , y, z);
Nombre función Lista de argumentos actuales
Llamadas de funciones distintas de VOID, la función debe ser asignada a una variable al momento de ser llamada.
(tipo_de_retorno={doublé, int, string, …})int x=4;double f;f=factorial(x);
Variable Función
Paso de argumentos por referencia
Cuando se realiza el llamado de una función, los argumentos actuales son evaluados y se crean copias de dichos valores. El modificar una copia no afecta a la variable original. A este mecanismo se lo conoce como paso de argumentos por valor.
A si por ejemplo si consideramos una función para permutar los valores de dos variables.
void permutar(int x, int y){
int aux=x;x=y;y=aux;
}Copiando y ejecutando esta función se nota que el valor de las variables x, y, solo cambian dentro de la función y vuelven a sus valores originales fuera de ella. La razón, es que los cambios se ejecutaron sobre las copias. Las variables originales pueden ser modificadas si recibieron sus direcciones.
void permutar(int &x, int &y)
A este mecanismo se lo conoce como paso de argumentos por referencia y se lo debe utilizar siempre que una función deba devolver variables modificadas y se lo obtiene anteponiendo el operador & al nombre de la variable. (Lista de argumentos de la función): Con esto, una versión correcta de la función permutar es:
void permutar(int &x, int &y){
int aux=x;x=y;y=aux;
}
Funciones recursivas
La recursividad es la posibilidad de que una función se llame a sí misma, en forma directa o indirecta. Un ejemplo típico es el cálculo del factorial.
n !=n (n−1 )!¿n ( (n−1 ) (n−2 ) !)¿n (n−1 )… (2 ) (1! )
La función escrita en forma recursiva será:
double factorial(int n){
double f;if((n==1) || (n==0)){
f=1;}else{
f=n*factorial(n-1);}return f;
}
Por lo general la recursividad no ahorra memoria no tampoco incrementa la velocidad de cálculo. La ventaja de estas funciones es que a menudo son más sencillos de escribir y fáciles de entender.
Compilación de Programas con varios archivos
Cuando se escribe programas grandes es necesario organizar mediante la división en módulos; es decir, crear programas usando varios archivos por separado, donde la función main debería estar ubicada en el archivo principal (por ejemplo en la función main.cpp) y el resto de archivos contendrán todas las demás funciones.Estos archivos pueden ser considerados como bibliotecas propias y pueden ser compartidas con varios programas.
#includeInstruye al compilador para incluir otro archivo fuente al proyecto. El archivo fuente, con extensión “.h”, debe ser incluido usando “ ” o <>
#include <iostream>#include “examen.h”
Cuando se usa <…> se dice al compilador que busque el archivo “.h” en la carpeta “include” del sistema.Si se usa “…” el archivo debe estar ubicado en la carpeta del proyecto.Estos archivos .h se denominan archivos de cabecera
Archivos de cabeceraPor lo general solo contienen declaraciones de funciones (encabezados), definiciones de tipos de datos, declaraciones de variables y constantes y comandos del C++. Estos archivos tienen extensión “.h” y el código relacionado con las declaraciones de dicho archivo se debe incluir en otro archivo con extensión “.cpp”. Estos dos archivos deben estar incluidos en el proyecto.La sintaxis de un archivo de cabecera es:
#ifndef NOMBRE_H#define NOMBRE_H#include <bibliotecas_del_sistema>#include “bibliotecas_nuevas.h”using namespace std;variables;constantes;encabezados de funciones;declaración de tipos de datos;#endif
C++ dispone de un conjunto de bibliotecas que pueden ser utilizadas por el programador, por ejemplo: cmath, cstdlib, ctime, fsteam, vector, etc.
#include <cmath>
Esta biblioteca contiene funciones, variables y constantes matemáticas que son fáciles de usar.
Entre las funciones tenemos:double pow(double x, double y) devuelve el valor de x y, con x , y∈Rdouble sqrt(double x) devuelve √ x , x∈ ¿double max(double x, double y) devuelve el máximo de x , y∈Rdouble min(double x, double y) devuelve el mínimos de x , y∈Rdouble floor(double x) devuelve el entero inferior ⌊ x ⌋, x∈ Rdouble ceil(double x) devuelve el entero superior ⌈ x⌉, x∈ Rdouble log10(double x) devuelve log10 x, x∈ Rdouble log(double x) devuelve ln x, x∈ Rdouble exp(double x) devuelve ex, x∈ Rdouble fmod(double x, double y) devuelve x%y , con x , y∈Rdouble sin(double x) devuelve el sen ( x ), x∈ Rdouble cos(double x) devuelve el cos ( x ), x∈ R
double tan(double x) devuelve la el tan ( x ), x∈ {R−π2R}
double fabs(double x) devuelve el valor absoluto |x|, x∈ R
Entre las constantes tenemos:M_PI devuelve el valor numérico de πM_E devuelve el valor numérico de e
Entrada/Salida de Archivos
El archivo de cabecera “fstream” contiene las clases/tipos de datos “ofstream” y “ifstream” que sirven para ejecutar operaciones de escritura y lectura de datos desde un archivo. Para trabajar con estas clases es necesario crear un objeto de acuerdo con las siguientes operaciones.
ofstreamPermite generar operaciones de escritura sobre un archivo, para lo cual debemos declarar un objeto de este tipo.
ofstream Nombre;
Para determinar el archivo con el que se va a trabajar se utiliza la función miembro “open.” Para acceder a toda función miembro dentro de una clase se usa el operador punto (.).
Nombre.open(“Nombre_Archivo.extension”);
Con los pasos anteriores, el archivo se encuentra abierto y podemos ingresar la información mediante el operador de flujo <<.
Nombre << “Primera Linea” << endl;int x=10;Nombre << x;
Finalmente es necesario cerrar el archivo mediante la función “close”.
Nombre.close();
El nombre de un archivo puede ser un tipo “string” o una cadena de tipo “char.”
string N_ARCH=“Prueba.txt”;Nombre.open (N_ARCH.c_str());
char N_ARCH1[50]=“Prueba.txt”;Nombre.open(N_ARCH1);
Al especificar la apertura de un archivo como se ha mostrado anteriormente, el programa sobrescribe (si es que existe) cualquier archivo bajo el mismo nombre.
En ciertos casos esa operación no es necesaria y se puede incluir ciertas propiedades que lo impiden, como las siguientes:
ios::app Operación de añadiduraios::no create Si el archivo existe se suspende la operaciónios::moreplace Crea un archivo, pero si existe uno con el mismo
nombre se suspende la operación.
Estas propiedades deben ser incluidas en la función “open.”
Extensión para generar archivo de texto .txt Extensión para generar archivo de Word .rtfExtensión para generar archivo de Exel .csv
Ejemplo:Nombre.open(N_ARCH1,ios::app);
Ejemplo: Lanzar dos dados y el resultado almacenarlo en un archivo.
void dados(int n){
ofstream archivo;archivo.open(“Prueba.txt”);for(int i=1; i<=n; i++){
double d1, d2;d1=1+rand()%6;d2=1+rand()%6;d3=2+rand()%11;archivo << i << “ “ << d1+d2 << “=” << d3 << endl;
}archivo.close();
}
ifstreamEs un tipo de dato que permite leer información desde un archivo. El proceso es muy similar a lo especificado para “ofstream:”
ifstream Nombre;Nombre.open(“Nombre_archivo.extensión”);
Recibir información mediante el operador de flujo >>.
int x;Nombre >> x;Nombre.close();
Cuando se genera la operación, se realiza desde el inicio del archivo hasta el final del mismo. Este tipo de dato dispone de un conjunto de propiedades:
eof() Reporta “true” si se encuentra en el final del archivo
is_open() Verifica si el archivo fue abiertofail() Reporta “true” si se produjo un error
Ejemplo: Supongamos que se dispone de un archivo bajo el formato
Tipos de datos más generales que los anteriores son los tipos de datos “istream”/”ostream” derivados por herencia de la clase “ios”. Estos dos tipos de datos permiten realizar operaciones de escritura/lectura con o sin formato. Estos incluyen salidas hacia pantalla o un archivo (ostream) y entradas desde pantalla o un archivo (istream).
#include <iostream>#include <fstream>
using namespace std;
double prod_interno(string archivo){
int n;ifstream f;f.open(archivo.c_str());if(f.is_open()==true);f >> n;
double prod=0,v,u; for(int i=1; i<=n; i++) { f >> v; f >> u; prod=prod+u*v; cout << "<" << v << "," << u << ">" << endl; } return prod; f.close();}
int main(){ string s; cout << "Ingrese el nombre del archivo: "; cin >> s; //s=s+".txt" si lo que se quiere es que el programa adieera la extensión al nombre del archivo double p=prod_interno(s); cout << "<u,v>=" << p; return 0;}
5-1 24 42 3
-1 83 10
ios
ostream istream
ifstreamofstream iostream
herencia
Medición de tiempos
Se refiere a la manipulación del reloj del computador el cual puede ser utilizado en los siguientes procesos
Conocer el timpo Tomar el tiempo de un proceso o propgrama Cambiar semillas de generación de números aleatorios
Alfgunas funcion es básicas usadas para estas tareas se encuentran en la biblioteca “ctime”, es decir, se necesita incluir:
#include <ctime>
Dentro de estas funciones podemos mencionar:
clock() devuelve el tiempo trascurrido medido en clocksCLOCKS_PER_SEC define el número de cloks por segundo, permite
transformar las medidas en clocks a segundostime_t time(time_t*t) devuelve el tiempo transcurrido medido en
segundos, considerado desde la época:0 segundos, 0 minutos, y 0 horas.
Ejemplo:
#include <iostream>#include <ctime>
using namespace std;
int main(){ double t1,t2,t_total; time_t tt1,tt2,tt_total; t1=clock(); time(&tt1); double x=0; for(int i=1; i<1e9; i++) { x=x+1.0/i; } cout << "suma=" << x << endl; t2=clock(); time(&tt2); t_total=(t2-t1)/CLOCKS_PER_SEC; tt_total=tt2-tt1; cout << "tiempo por cloks=" << t_total << endl << "tiempo por time=" << tt_total; return 0;}
(i
b
a-b
Números aleatorios
Los números aleatorios son útiles para representar eventos que dependen del azar, tales como: juegos, simulaciones, experimentos. En la práctica ninguna función o proceso produce números totalmente aleatorios, ya que disponen de una fórmula para su generación. A este tipo de número se los conoce como pseudo-aleatorios. Lo más cercano a una generación aleatoria es usar distinta semilla de generación.
Si se realiza una generación con la misma semilla, los datos siempre serán los mismos. Para cambiar la semilla de generación y que en cada corrida inicie con distinta semilla se usa el reloj.
time(0)
Para usar las funciones básicas para producir números pseudo-aleatorios se debe incluir:
#include<cstdlib>
Que contiene las siguientes funciones:double rand() Produce un número pseudo-aleatorio entre 0
y RAND_MAX=215-1.double rand()%k Produce un número pseudo-aleatorio entre 0
y k-1, con k>0 e ingresado por el programador.void srand(int semilla) Establece una nueva semilla para la próxima
generación. Es suficiente con ingresar una solavez en el programa.
Programación Orientada a Objetos
Idea: ¿Es posible crear una estructura para almacenar números complejos?
Definimos un número complejo zϵ C como un par ordenado z=(a , b) o en su forma binaria z=a+ib, donde se definen las siguientes operaciones.
(a ,b )+ (c ,d )=(a+c , b+d)
(a ,b )−(c ,d )=(a−c , b−d )
(a ,b )× (c , d )=(a·c−b·d , a·d+b·c )
(a ,b )=(c ,d )⇔a=c∧ b=d
El conjugado de un complejo se define como
z=(a ,b )⇔z=(a ,−b )
Se define como el módulo de un número complejo z=(a ,b)
|z|=√a2+b2
Programación Orientada a Objetos
La Programación Orientada a Objetos permite realizar grandes programas mediante la unión de elementos más simples, que pueden ser diseñados y comprobados de manera independiente del programa principal.
Muchos de estos elementos podrán ser usados en otros programas. A estas piezas, módulos o componentes se los denominan objetos. Estos objetos contienen información y funciones que interactúan entre sí.
La definición de estos objetos se los realiza mediante las clases, que contiene una completa y detallada información de las variables, funciones y operadores que dispondrá el objeto. Así por ejemplo, consideremos la creación de un objeto llamado alumno.
Es decir, un alumno dispone de cuatro datos: nombre, edad, semestre, nota.
Al crear en C++ una clase se está definiendo un nuevo tipo de dato y puede ser utilizado como los ya existentes (int, double, float, …)
Clases
En un lenguaje orientado a objetos, el centro no son las funciones sino los datos (objetos) los que disponen de datos y funciones que permiten manipular y trabajar sobre ellos.
Al ser los datos la parte principal de las clases se define el concepto de ocultamiento o abstracción de datos.
Los miembros de una clase pueden ser divididos en públicos o privados. Los miembros públicos son aquellos a los cuales se pueden acceder libremente desde cualquier parte del programa. Los miembros privados solamente pueden ser accedidos por los métodos de su propia clase. Mediante estos dos ambientes se garantiza que se hace un buen uso de los objetos.La sintaxis para declarar una clase es la siguiente:
class Nombre_clase{
private:Declaración de Variables;Declaración de Funciones;
public:Declaración de Variables;Constructores;Destructores;Funciones Miembro;Funciones Amigos;Sobrecarga de Operadores;
};
Una clase ofrece un conjunto de funciones públicas a través de las cuales se puede actuar sobre las variables privadas (Interface de la clase).
Alumno
Nombre
Edad
Semestre
Nota
class Alumno{
private:string Nombre;int Edad;int Semestre;
public:double Nota;
};
Constructores y DestructoresLos constructores se llaman automáticamente cada vez que se crea un objeto y su misión es que todas las variables miembro se encuentran inicializadas. Los constructores siempre deben ser declarados en la parte pública de la clase y deben ser declarados bajo el mismo nombre de la clase y sin ningún tipo de retorno, no siquiera void; es decir, estas son funciones especiales.Los destructores permiten eliminar los objetos dinámicos declarados dentro de la clase, y se los declara mediante el nombre de la clase y anteponiendo ~
Funciones MiembroSon las funciones que son declaradas dentro de la clase y que tienen acceso a las variables privadas y públicas de la clase. Obsérvese que estas funciones pueden ser consideradas pertenecientes a la clase y para acceder a ellos se usa el operador (.); es decir, no son funciones independientes.
Funciones AmigasEs una clase de función que no pertenece a la clase pero tiene acceso a las variables ubicadas en la parte privada por medio del operador (.), sin tener que recurrir a las funciones miembro de la clase.Para declarar una función o una clase como amiga es necesario declararlo en la clase que debe autorizar el acceso a sus datos privados y se logra anteponiendo la palabra fríen a ser declaraciones.
Sobrecarga de OperadoresLa sobrecarga se refiere a que podemos redefinir ciertos operadores existentes en C++ para que ejecuten una determinada tarea asociada al nuevo tipo de dato que estamos construyendo. Esto es muy útil por ejemplo para definir operaciones
básicas +,-,*,/ o manipular ciertos operadores como: <<, >>, <=, >=, ==, !=, … de manera que puedan ejecutar las tareas relacionadas a los datos de la clase y definidos por el programador. Se realizan como funciones amigas declaradas bajo el nombre operator seguido del operador a sobrecargar.
class Alumno{
private:string Nombre;int Edad;int Semestre;double Nota;
public://costructor sin argumentosAlumno(){
Nombre= "S/N";Edad=0;Nota=0.0;
}//constructor con argumentosAlumno(string Nb, int e, int s){
Nombre=Nb;Edad=e;Semestre=s;Nota=0.0;
}//Destructor()~Alumno();//Funciones Miembro(.)string Obtener_Nombre(){
return Nombre;}void Modificar_ Nota(doublé n){
Nota=n;}void escribir_datos();// continua en la siguiente página…
//Funciones Amigasfriend presentar_Datos(Alumno al){
cout << al.Nombre << endl << "Nota=" << al.Nota;
}friend double retornar_nota(Alumno x);//Sobrecarga de Operadoresfriend ostream& operator << (ostream& os, Alumno x);freindl Alumno operator + (Alumno x, Alumno y);
};//Fin delaración clase
Si en una clase se declara solo el encabezado de una función, el código relacionado a dicha función sebe ser escrito fuera de la clase.
Funciones MiembroEs necesario especificar a qué clase pertenece dicha función y se logra anteponiendo el nombre de la clase :: al nombre de la función.
void Alumno::escribir_datos(){
cout << Nombre << endl << "Edad=" << Edad << endl << "Semestre=" << Semestre;
}
Funciones AmigosNo se especifica a que clase pertenece y se elimina la palabra friend.
