Punt2D.

class Punt2D {
// Descripció: un punt en el pla
public:
// Constructors
Punt2D(); //Pre:--; Post: el punt és (0,0)
Punt2D(double x, double y); //Pre:--; Post: el punt és (x,y)
// Mètodes consultors
double coordenada_x() const;
//Pre: --; Post: retorna la coordenada x del punt
double coordenada_y() const;
//Pre: --; Post: retorna la coordenada y del punt
double distancia(Punt2D p) const;
//Pre: --; Post: retorna la distància del punt a p
void mostrar() const;
//Pre: --; Post: mostra el punt en forma (x,y)
bool es_igual(Punt2D p) const;
//: --; Post: retorna cert si el punt i p són iguals
Punt2D punt_mig(Punt2D p) const;
//Pre:--; Post: retorna el punt mig entre el punt i p
// Mètodes modificadors
void moure(double x, double y);
//Pre:--; Post: punt desplaçat amb vector (x,y)
void moure(Punt2D p);
//Pre:--; Post: punt desplaçat amb vector (0,0)->p
void llegir();
//Pre:--; Post: el punt és el llegit de teclat
private:
double a_x, a_y; // coordenades cartesianes
};

Rectangle2D.h

#include "Punt2D.h"
class Rectangle {
// Descripció: un rectangle en el pla 2D, alineat amb els eixos de coordenades
public:
// Constructors
Rectangle();
// Pre:--; Post: rectangle (0,0),(1,0),(1,1),(0,1)
Rectangle(Punt2D origen, double base, double altura);
// Pre: base,altura>0 ; Post: rectangle amb vertex_inferior_esquerre=origen i
base i altura
// Consultors
double base() const;
// Pre: --; Post: retorna base del rectangle
double altura() const;
// Pre: --; Post: retorna altura del rectangle
Punt2D origen() const;
// Pre: --; Post: retorna el punt origen del rectangle
double area() const;
// Pre: --; Post: retorna àrea del rectangle
double perimetre() const;
// Pre: --; Post: retorna perímetre del rectangle
Punt2D centre() const;
// Pre: --; Post: retorna centre del rectangle
void mostrar() const;
// Pre: --; Post: mostra origen (vèrtex inferior esquerre) i base i altura
void mostrar_vertexs() const;
// Pre: --; Post: mostra els 4 vèrtexs en sentit horari, començant per
inferior-esquerre
// Modificadors
void moure(double x, double y);
// Pre:--; Post: rectangle desplaçat segons vector (x,y)
void escalar_origen(double factor);
 // Pre: factor>0; Post: rectangle escalat segons factor, mantenint el seu
origen
void escalar_centre(double factor);
// Pre: factor>0; Post: rectangle escalat segons factor, mantenint el seu
centre
private:
// Atributs
Punt2D a_origen; // composició, vèrtex inferior esquerra
double a_base;
double a_altura;
// Definicions
static const int NOMBRE_VERTEXS=4;
typedef Punt2D Vector_punt2D_rectangle[NOMBRE_VERTEXS];
// Mètodes privats
void vertexs(Vector_punt2D_rectangle v_rec) const;
// Pre: --; Post: v_rec conté els 4 vèrtexs en sentit horari començant per
inferior-esquerre
};

Vector_punt2D.h

#include "Punt2D.h"
class Vector_punt2D {
// Descripció: vector de punts 2D ordenat de menor a major distància a l'origen
(si la distància és igual cal ordenar segons menor coordenada x)
public:
// Constructors
Vector_punt2D();
// Pre: --; Post: vector buit de punts
// Consultors
double nombre_punts() const;
// Pre: --; Post: retorna el nombre de punts
double mitjana_distancies_origen() const;
// Pre: nombre_punts()>0; Post: retorna la distància mitjana de tots els punts
del vector a l'origen
void mostrar() const;
// Pre: --; Post: mostra tots els punts del vector numerats de 0 al nombre de
punts-1
// Modificadors
void inserir_punt(Punt2D punt);
// Pre: nombre_punts()<MAX; Post: s'ha inserit ordenadament un punt en el
vector de punts
void esborrar_punt(int pos);
// Pre: nombre_punts()>0 i 0<=pos<nombre_punts(); Post: s'esborra el punt que
ocupa la posició pos
private:
// Constants
static const int MAX= 100;
// Atributs
Punt2D a_t[MAX]; // vector de punts
int a_n; // nombre de punts

// Mètodes privats
static bool es_menor(Punt2D p1, Punt2D p2);
// Pre: --; Post: retorna cert si el punt actual és menor (més proper a
l'origen) que p, fals en el cas contrari
};
a. Des del main (amb tots els includes necessaris, inclosos els de Punt2D,
Rectangle i Vector_punt2D)

a.1. Donats dos rectangles r1 i r2, correctament construïts, com calcularies la

distància dist entre l'origen del rectangle r1 i el centre del rectangle r2? En
una sola instrucció.

double dist =

a.2. Donats dos rectangles r1 i r2, correctament construïts, com calcularies la

distància dist entre l'origen de coordenades (0,0) i el punt mig entre els centres
de r1 i r2?

-------------

a.3. És correcte aquest tros de codi? Per què?

Vector_punt2D v;
Punt2D p(1,4);
Rectangle r(p,2,3);
r.moure(-3,-2);
v.inserir_punt(r.origen());
v.inserir_punt(p);
v.esborrar_punt(1);

a.4. És correcte aquest tros de codi? Per què?

Punt2D p(1,4);
p.moure(2,2);
Rectangle r(p,2,3);
r.origen().moure(2,2);

a.5. És correcte aquest tros de codi? Per què?

Punt2D p(1,1);
Rectangle r1(p,1,1);
Rectangle r2 = r1;
r2.moure(2,2);
cout << "Origen: " << r2.origen() << endl;
cout << "Àrea: " << r2.area() << endl;

-------------

a.6. Donat un objecte de la classe Vector_punt2D, correctament construït, com ho

faries per eliminar la primera meitat dels seus elements? Exemple: si el nombre
d'elements fos 7, n'eliminaríem 3 (=7/2); si fos 1 no n'eliminaríem cap (=1/2).
Afegeix el codi que es demana al tros de codi següent:

Vector_punt2D v;
... // suposem que a v hi hem inserit un cert nombre (>0) de punts
...

a.7. Donat un objecte de la classe Vector_punt2D, correctament construït, com ho

faries per inserir-hi els 4 vèrtexs d'un rectangle r degudament construït. Cal
inserir-los en sentit horari començant per l'origen del rectangle. Afegeix el codi
que es demana al tros de codi següent:

Vector_punt2D v;
Punt2D p;
p.llegir();
double base, altura;
cin >> base >> altura;
Rectangle r(p,base,altura);
...

b. Implementació de la classe Rectangle

b.1. Crea un nou constructor de la classe Rectangle que inicialitza un rectangle a

partir de dos paràmetres p1 i p2 de tipus Punt2D, on p1 i p2 representen,
respectivament, on s'han de situar el vèrtex inferior esquerra i el vèrtex
superior dret del rectangle actual.

Rectangle::Rectangle(Punt2D p1, Punt2D p2) {

...
}

b.2. Implementa el següent mètode de la classe Rectangle (omplir només després de

"return"):

bool es_menor(Rectangle r) const; // a Rectangle.h

// Pre: --; Post: retorna true si el rectangle actual té menys àrea que r, fals en
cas contrari

bool Rectangle::es_menor(Rectangle r) const {

return ................................................................;
}

b.3. Si no vull fer servir el mètode moure de la classe Punt2D, seria correcta la
següent implementació del mètode moure de Rectangle? Per què?

void Rectangle::moure(double x, double y) {

// Pre:--; Post: rectangle desplaçat segons vector (x,y)
a_origen = Punt2D(a_origen.a_x + x, a_origen.a_y + y);
}

c. Implementació de la classe Vector_punt2D

c.1. Com canviaries la capçalera i l'especificació del mètode esborrar_punt per

tal que poguessis obtenir també l'objecte eliminat? El mètode ha de continuar
essent públic, modificador, void i d'instància. Implementa també aquest mètode.

Original:
void esborrar_punt(int pos);
// Pre: nombre_punts()>0 i 0<=pos<nombre_punts()
// Post: s'esborra el punt que ocupa la posició pos

Nou:
...

Implementació:
...

c.2. Especifica i implementa un mètode de la classe Vector_punt2D que ens doni el

punt del vector que estigui més proper al punt p que es passa com a paràmetre. Cal
que el nombre de punts del vector sigui més gran que zero. El mètode ha de ser
públic, consultor i d'instància.