polyset · Cristi

▶ Aprender polyset (Cristi) paso a paso · explicación de polyset

Otras versiones: Optim

Código línea a línea

Tres columnas: el código, el trozo del subject o del main que obliga a escribir esa línea, y el por qué.

searchable_array_bag.hpp

Código	Subject	Por qué
`#pragma once`		Que el .hpp no se incluya dos veces.
`#include "array_bag.hpp"`	array_bag: an implementation of a bag with an array an underlying data	Te lo dan: el bag con array del que heredo.
`#include "searchable_bag.hpp"`	searchable_bag: an abstract class representing a bag with the ability to	Te lo dan: la clase abstracta con `has` que tengo que cumplir.

`class searchable_array_bag : public array_bag, public searchable_bag {`	that will inherit from array_bag and tree_bag and implement the searchable bag abstract class.	Hereda de los dos: de `array_bag` los métodos hechos; de `searchable_bag` la obligación de tener `has`.

`public:`	You will find in this dir a main that must compile with your code.	Todo lo que usa el main.
`searchable_array_bag() {}`	`searchable_bag *a = new searchable_array_bag;`	Vacío: el padre se construye solo.
`searchable_array_bag(const searchable_array_bag &oth) : array_bag(oth) {}`	`const searchable_array_bag tmp(static_cast<searchable_array_bag &>(*a));`	Copia: se la paso al padre, que tiene los datos.
`searchable_array_bag &operator=(const searchable_array_bag &oth) { array_bag::operator=(oth); return *this; }`	All classes should be under orthodox canonical form.	Que copie el padre y me devuelvo a mí.
`~searchable_array_bag() {}`		Nada que liberar.

`bool has(int value) const {`	Since a bag without a searching function isn't very useful, implement two	Lo único nuevo. `const` porque `tmp` es const.
`for (int i = 0; i < size; i++)`		Recorro `data[0..size)`: `size` y `data` vienen de `array_bag`.
`if (data[i] == value)`		¿Es este?
`return true;`		Encontrado.
`return false;`		Recorrí todo y no está.
`}`
`};`

searchable_array_bag.cpp

Código	Subject	Por qué
`#include "searchable_array_bag.hpp"`	Expected File: searchable_array_bag.cpp, searchable_array_bag.hpp,	El .cpp incluye su .hpp.

searchable_tree_bag.hpp

Código	Subject	Por qué
`#pragma once`		Que el .hpp no se incluya dos veces.
`#include "tree_bag.hpp"`	tree_bag: an implementation of a bag with a binary search tree as underlying	Te lo dan: el bag con árbol del que heredo.
`#include "searchable_bag.hpp"`	searchable_bag: an abstract class representing a bag with the ability to	Te lo dan: la clase abstracta con `has` que tengo que cumplir.

`class searchable_tree_bag : public tree_bag, public searchable_bag {`	that will inherit from array_bag and tree_bag and implement the searchable bag abstract class.	Lo mismo con el árbol: `tree_bag` trae lo hecho, `searchable_bag` pide `has`.

`public:`	You will find in this dir a main that must compile with your code.	Todo lo que usa el main.
`searchable_tree_bag() {}`	`searchable_bag *t = new searchable_tree_bag;`	Vacío: el padre se construye solo.
`searchable_tree_bag(const searchable_tree_bag &oth) : tree_bag(oth) {}`		Copia: se la paso al padre.
`searchable_tree_bag &operator=(const searchable_tree_bag &oth) { tree_bag::operator=(oth); return *this; }`		Que copie el padre y me devuelvo a mí.
`~searchable_tree_bag() {}`		Nada que liberar.

`bool has(int value) const {`	Since a bag without a searching function isn't very useful, implement two	Lo único nuevo. `const` porque `tmp` es const.
`node *cur = tree;`		Empiezo en la raíz.
`while (cur) {`		Mientras haya nodo.
`if (cur->value == value)`		¿Es este?
`return true;`		Encontrado.
`cur = value < cur->value ? cur->l : cur->r;`	binary search tree	Menor → izquierda, si no → derecha.
`}`
`return false;`		Recorrí todo y no está.
`}`
`};`

searchable_tree_bag.cpp

Código	Subject	Por qué
`#include "searchable_tree_bag.hpp"`	searchable_tree_bg.cpp, searchable_tree_bag.hpp, set.cpp, set.hpp	El .cpp incluye su .hpp.

set.hpp

Código	Subject	Por qué
`#pragma once`		Que el .hpp no se incluya dos veces.
`#include "searchable_bag.hpp"`	searchable_bag: an abstract class representing a bag with the ability to	Te lo dan: la clase abstracta con `has` que tengo que cumplir.

`class set {`	Implement the class set that will wrap a searchable_bag and turn it into a set.	Envuelve una bag: no la copia, trabaja sobre ella.

`private:`		Solo lo toca la clase.

`searchable_bag &bag;`	wrap a searchable_bag	Referencia a la bag del main: el set NO tiene datos propios.

`set();`	All classes should be under orthodox canonical form.	Privado y sin cuerpo: una referencia no puede nacer vacía. Existe solo por la forma canónica.
`set(const set &oth);`	All classes should be under orthodox canonical form.	Privado: copiar un set no tiene sentido (compartirían bag).
`set &operator=(const set &oth);`	All classes should be under orthodox canonical form.	Privado: una referencia no se puede reasignar.

`public:`	You will find in this dir a main that must compile with your code.	Todo lo que usa el main.
`set(searchable_bag &b) : bag(b) {}`	`set sa(a);` `set st(t);`	La referencia se rellena en la lista `: bag(b)`, nunca dentro de `{}`.
`~set() {}`		No borra nada: la bag es del main.

`void insert(int value) { if (!bag.has(value)) bag.insert(value); }`	turn it into a set `st.insert(atoi(argv[i]));`	Solo si no está ya. Esto es lo que lo hace un set.
`void insert(int *values, int count) { for (int i = 0; i < count; i++) insert(values[i]); }`	`sa.insert(intArr, sizeof(intArr) / sizeof(int));`	Uno a uno con el `insert` de uno: sin repetidos.
`bool has(int value) const { return bag.has(value); }`	`sa.has(atoi(argv[i]));`	Se lo pasa a la bag.
`void print() const { bag.print(); }`	`sa.print();`	Se lo pasa a la bag. `const`: no toca nada.
`void clear() { bag.clear(); }`	`sa.clear();`	Se lo pasa a la bag.
`const searchable_bag &get_bag() const { return bag; }`	`sa.get_bag().print();`	Dos const: lo que doy no se toca, y yo no me toco.
`};`

set.cpp

Código	Subject	Por qué
`#include "set.hpp"`	set.cpp, set.hpp	El .cpp incluye su .hpp.

El main, comentado

El main del subject con una nota en cada línea: qué función de la clase obliga a escribir.

main.cpp

#include "searchable_bag.hpp"		// → te lo dan: bag + bool has(int) const = 0
#include "searchable_tree_bag.hpp"	// → tuyo
#include "searchable_array_bag.hpp"	// → tuyo
#include "set.hpp"					// → tuyo

#include <iostream>
#include <stdlib.h>

int main(int argc, char **argv)
{
	if (argc == 1)
		return 1;
	searchable_bag *t = new searchable_tree_bag;	// → searchable_tree_bag() · hereda de searchable_bag (si no, no cabe en un searchable_bag *)
	searchable_bag *a = new searchable_array_bag;	// → searchable_array_bag() · igual, con array_bag

	for (int i = 1; i < argc; i++) {
		t->insert(atoi(argv[i]));	// → insert ya viene hecho en tree_bag: no escribes nada
		a->insert(atoi(argv[i]));	// → insert ya viene hecho en array_bag
	}
	t->print();						// → print ya viene hecho
	a->print();

	for (int i = 1; i < argc; i++)
	{
		std::cout << t->has(atoi(argv[i])) << std::endl;		// → has() del árbol: izquierda si es menor, derecha si es mayor
		std::cout << a->has(atoi(argv[i])) << std::endl;		// → has() del array: recorre data[0..size)
		std::cout << t->has(atoi(argv[i]) - 1) << std::endl;	// → un número que NO está: tiene que dar 0
		std::cout << a->has(atoi(argv[i]) - 1) << std::endl;
	}

	t->clear();						// → clear ya viene hecho
	a->clear();

	const searchable_array_bag tmp(static_cast<searchable_array_bag &>(*a));	// → searchable_array_bag(const searchable_array_bag &): : array_bag(oth)
	tmp.print();					// → tmp es const: print tiene que ser const (ya lo es)
	tmp.has(1);						// → tmp es const: por ESTO has lleva const al final

	set sa(*a);						// → set(searchable_bag &b) : bag(b) · la referencia se rellena en la lista, no dentro de {}
	set st(*t);						// → el set NO copia la bag: trabaja sobre la del main
  int intArr[] = {1, 2, 3, 4};
	for (int i = 1; i < argc; i++)
	{
		st.insert(atoi(argv[i]));	// → set::insert(int): if (!bag.has(value)) bag.insert(value) · esto es lo que lo hace un set
		sa.insert(atoi(argv[i]));

		sa.has(atoi(argv[i]));		// → set::has(int) const: return bag.has(value)
		sa.print();					// → set::print() const: bag.print()
		sa.get_bag().print();		// → const searchable_bag &get_bag() const: dos const (lo que doy no se toca · yo no me toco)
		st.print();
		sa.clear();					// → set::clear(): bag.clear()
		sa.insert(intArr, sizeof(intArr) / sizeof(int));	// → set::insert(int *, int): un bucle que llama al insert de uno (así tampoco mete repetidos)
		std::cout << std::endl;
	}

  delete a;							// → delete de un searchable_bag *: por eso bag tiene virtual ~bag() (te lo dan)
  delete t;							// → set no borra nada en ~set(): la bag es del main
	return (0);
}