Apuntes PROII parcial 1

Tema 1:
1. Estructura de un programa.
#include <iostream> //incluye entradas/salidas
//demás librerías
using namespace std;
# include "...." // todos los .h de todas las librerías que implementamos;
//entre comillas dobles porque están dentro de nuestro programa.
const tipo NOMBRE = valor;
zona de definición de tipos de datos
clases
prototipos de las funciones
int main(){....
}
Implementación de las funciones.
*Las funciones tienen 3 vistas:
1. Prototipo encima del main.
2. Implementación debajo del main
3. Llamadas a la función, utilización de la función, en cualquier parte donde sea necesario.
2. E/S estándar.
cin >> //entrada de datos.
cout << //salida estándar.
cerr << //funciona igual que el cout pero para mensajes de error
Por ejemplo:
int main(){
int num = 5;
cout << num;
cin >> num;
return -1
}
3. Creación de clases, objetos.
class Clase {
public:
//funciones miembro de la clase
private:
//atributos de la clase.
};
1. Constructor:
Clase(); //Constructor por defecto
Clase(.....); //Constructor parametrizado, sirve para instanciar un objeto.
2. Destructor:
~Clase(); // Sirve para destruir un objeto.
3. Setter y getter:
tipoAtributo getNombre();
void setNombre( tipoAttributo a);
valorRetorno Clase::NombreFuncion(args){
.....
}
4. Argumentos predeterminados. // Aquellos valores que damos por defecto a una función.
El valor solo se pone en el prototipo de la función.
P.ej.:
void sumar ( int a, int b = 3); // valores por defecto siempre al final de la lista de args
//no pueden ser pasados por referencia.Arg& no.
Ejemplo de paso por valor y referencia.
void suma ( int a, int b ){
a = a + b;
cout << a;
//Modificamos el valor de una copia de a
}
void suma(int &a, int b){ // Trabajamos con la dirección de memoria de a
a = a +b;
cout << a;
}
int main(){
int num1 = 3;
int num2 = 4;
suma (num1,num2); // si usamos la 2a a quedaría modificada en su dirección.
cout << num1;
return -1;
}
5. Funciones inline.
Realizar las implementaciones dentro de las propias clases.
O poner inline Clase::funcion(){.....}al lado del prototipo metemos el código.
6. Asignación de objetos.
Empleado pepe;
Empleado jose;
pepe = jose;
7. Paso de objetos a funciones.
void visualizar (Empleado e);
8. Arrays de objetos.
clase nombreArray[tamaño]; // esto vale si tenemos constructir por defecto
clase nombreArray[tamaño] = { Clase ( args, ... ), ... }
TEMA 2: PUNTEROS.
1. Definición.
Tipo de dato para almacenar una dirección.
Sintaxis:
//Siendo el tipo de dato a almacenar un int
int *nombrePuntero = NULL; //inicializar a null para que no coja celdas de memoria aleatorias.
int numero = 2;
nombrePuntero = №
// con el & direccionamos una variable, obtenemos la dirección de una variable, en este caso número
numero = 5; //modificamos el numero contenido en la variable número
*nombre = 6; //Modificamos el valor de lo que apunta el puntero cambiando el 5 por un 6.
//Con el asterisco accedemos a lo que apunta el puntero.
//Solo con el nombre accedemos a la dirección.
//& operador de direccionamiento.
Ejemplo:
char caracter = 'c';
char *puntero = &caracter;
*puntero = 'a';
Ejemplo:
int main(){
int *ptr;
//inicializamos el puntero
int x = 5; //inicializamos la variable
ptr = &x; // hacemos que el puntero apunte a x
*ptr = 6; //cambia el valor de x a través del puntero
cout << "x es: " << x << endl;
return 0;
}
Ejemplo:
int main()
{
int i = 7;
int *p = NULL;
int *q = NULL;
int *r = &i;
return 0;
}
//r apunta a la dirección de i.
2. Expresiones con punteros.
1. Asignación.
int num = 5;
int *p1 = #
int *p2 = NULL;
p2 = p1;
*p2 = *p1;
2. Aritmética.
p1++; incrementa en 1 la dirección a la que apunta el puntero.
!= *p1++ aumenta 1 a lo que apunta p1, se incrementa el contenido.
3. Relacionales.
(p1 == p2)
Avanzar en matrices con un puntero: formula puntero + j + (i*numero de columna)
// j es el número de columna e i número de fila.
3. Colecciones de punteros.
*Primer elemento del array.
int array [10]; // el nombre de un array es siempre un puntero a su 1er elemento
// apunta a la dirección de la primera posición
array[0] equivale a *array;
array[1] equivale a *(array+1);
.
.
.
array[9] equivale a *(array+9);
*Arrays de punteros.
tipo * nombreArray[tamaño];
int nombreArray[10];
Ejemplo:
int * numeros[10];
int a = 2;
for(int i = 0; i < 10; i++)
numeros[i] = &a;
(numeros +i) = &a;
//2 maneras, forma indexada
//forma aritmética.
4. Punteros a punteros.
Sintaxis:
int ** puntero;
int * intermedio;
int numero = 5;
intermedio = №
puntero = &intermedio;
**puntero = 4; // modificamos el valor de numero a través de un puntero a un puntero a un entero.
Tema 3: memoria dinámica.


Estática: memoria que se reserva en tiempo de compilación.
Dinámica: memoria que se reserva en tiempo de ejecución.
5 pasos:
1.
2.
3.
4.
5.
Declaración de un puntero.
Reservar con el operador new la memoria.
Validar que tenemos espacio en la memoria.
Utilizar esa zona de memoria.
Eliminar la reserva con el operador delete
Ejemplo:
int main()
{
int num;
int * puntero;
//Paso 1.
cout << "Introduzca el num de elementos:"
cin num;
puntero = new (nothrow) int [num];
//Paso 2.
//nothrow devuelve un null si no se ha podido reservar esa memoria
if ( puntero == null ){
cerr << "Error de memoria dinámica";
exit (-1);
}
//Paso 3.
for ( int i = 0; i < num; i++ )
{
cout << "Introduzca el valor" << i << endl;
cin puntero[i]; // equivalente a *(puntero+i)
}
//Paso 4.
delete [] puntero;
//Paso 5.
return 1;
}
En una clase:
1.
2.
3.
4.
5.
Declaración del puntero como atributo de la clase.
La reserva con new en el constructor.
Validación del espacio disponible en el constructor.
Uso de esa memoria en los diferentes métodos.
Delete en el destructor.