C++ Orientado A Objetos Rombo

Question

Estoy teniendo problemas con una tarea que se me ha dado, el problema es que no puedo encontrar a los recursos de todos modos similar al código que me han dado.He leído a través de tantos documentos tratando de encontrar similitudes, pero no puede encontrar nada útil.

Necesito ayuda para tratar de entender este código y cómo usarlo para crear un Rombo. Las únicas cosas que no puedo comprender es cómo crear un Rombo de forma que pertenece a la clase Shape.Aplicar un centro de gravedad para que el Rombo y, a continuación, agregar vértices utilizando un push_back método. Por desgracia, este empuje hacia atrás el método debe ser usado, yo no aprobó el examen con sólo usar drawLine(10,10,40,10);etc para dibujar líneas a donde yo quería.

Voy a ser molienda esto para un sólido de semana, así que debería responder con rapidez.

//This is the rhombus.cpp file
#include "rhombus.h"

Rhombus::Rhombus(Vertex point, int radius) : Shape(point)
{
    if((radius>centroid.getX()/2) || (radius>centroid.getY()/2)) // Inteded to be a y?
    {
        cout << "Object must fit on screen." << endl;
        system("pause");
        exit(0);
    }

    Rhombus shape1(20, 20);
    shape1.plotVertices();

}

void Rhombus::plotVertices()
{
    //vertices.push_back(Vertex(centroid.getX(), centroid.getY() + radius));
    //vertices.push_back(Vertex(centroid.getX(), centroid.getY()));
    //vertices.push_back(Vertex(centroid.getX(), centroid.getY()));
    //vertices.push_back(Vertex(centroid.getX(), centroid.getY()));
}

---

// This is the rhombus.h file
#include "shape.h"

class Rhombus : public Shape 
{
    int radius;
    void plotVertices();
    Rhombus(Vertex point, int radius = 10);
    int area();
    int perimeter();
};

---

// This is the shape.cpp file
#include "shape.h"

Shape::Shape(Vertex point) : centroid(point)
{
    // constructs a shape

}

void Shape::drawShape()
{

    list<Vertex>::iterator current = vertices.begin();
    list<Vertex>::iterator previous = vertices.begin();
    while(current!=vertices.end())
    {
        Console::gotoXY((*current).getX(),(*current).getY());
        cout << "*";
        if(current!=vertices.begin())
            drawLine((*current).getX(),(*current).getY(), (*previous).getX(),            (*previous).getY());
        previous = current;
        current++;
    }
    previous = vertices.begin();

    //Debug assertion error here.
    drawLine(vertices.back().getX(), vertices.back().getY(), vertices.front().getX(),     vertices.front().getY());
}

void Shape::drawLine(int x1, int y1, int x2, int y2)
{      

    bool steep = (abs(y2 - y1) > abs(x2 - x1));
    if(steep)
    {
        swap(x1, y1);
        swap(x2, y2);
    }

    if(x1 > x2)
    {
        swap(x1, x2);
        swap(y1, y2);
    }

    int dx = x2 - x1;
    int dy = abs(y2 - y1);

    float error = dx / 2.0f;
    int ystep = (y1 < y2) ? 1 : -1;
    int y = y1;
    int maxX = x2;

    for(int x=x1; x<maxX; x++)
    {
        if(steep)
        {
            Console::gotoXY(y,x);
            cout << "*";
        }
        else
        {
            Console::gotoXY(x,y);
        cout << "*";
        }
        error -= dy;
        if(error < 0)
        {
            y += ystep;
            error += dx;
        }
    }
}


double Shape::round(double x)
{
    if (ceil(x+0.5) == floor(x+0.5))
    {
        int a = (int) ceil(x);
        if (a%2 == 0)
            return ceil(x);
        else
            return floor(x);
    }
    else 
        return floor(x+0.5);
}

void Shape::outputStatistics()
{

}

---

// This is the shape.h file
#pragma once
#include "console.h"
#include "vertex.h"
#include <iostream>
#include <list>
#include <cstdlib>
#include <cmath>
using namespace std;

#define PI 3.14159265358979323846

class Shape
{
    list<Vertex>::iterator itr;
protected:
    list<Vertex> vertices;
    Vertex centroid;
    void drawLine(int x1, int y1, int x2, int y2);

    Shape(Vertex point);
    double round(double x);

public:
    void drawShape();
    virtual int area() = 0;
    virtual int perimeter() = 0;
    virtual void outputStatistics();
    void rotate(double degrees);
    void scale(double factor);
};

Answer 1

Como se puede ver, Rhombus ya es una subclase de Shape (class Rhombus : public Shape) tan sólo tienes que crear una instancia de Rhombus para todos los que la magia suceda.

Shape está definido de tal forma que el Vertex pasado (como el point parámetro) se utiliza para inicializar el centroid variable de instancia de forma automática;así que usted puede utilizar centroid como el centro de gravedad de cualquier operación que requiera centroide relacionados con los datos, ya sea desde dentro Shape o desde dentro de una de sus subclases como Rhombus.

Del mismo modo, la lista de vertices está disponible para Shape y todas sus subclases como una variable de instancia.Si miramos el resto del código (por ejemplo, Shape::drawShape), te darás cuenta de cómo vertices ha sido utilizado para la manipulación de los vértices de la forma actual.

Lo que tienes que hacer aquí es bastante similar.Por ejemplo,

Rhombus::Rhombus(Vertex point, int radius) : Shape(point)
{
    if((radius>centroid.getX()/2) || (radius>centroid.getY()/2)) // Inteded to be a y?
    {
        cout << "Object must fit on screen." << endl;
        system("pause");
        exit(0);
    }

    // create vertices for a rhombus with horizontal and vertical diagonals
    vertices.push_back(Vertex(point.getX() - radius, point.getY()));
    vertices.push_back(Vertex(point.getX(), point.getY() - radius));
    vertices.push_back(Vertex(point.getX() + radius, point.getY()));
    vertices.push_back(Vertex(point.getX(), point.getY() + radius));
}

Cuando usted está dentro de Rhombus::Rhombus (el constructor), que ya están dentro de un rombo que ha sido creada;usted no tiene que crear una Rhombus objeto de nuevo.Sólo tienes que "decorar" la instancia mediante la adición de los vértices, y la definición de un centroide (que se ha hecho ya).

Imagínese que usted está creando un Rhombus de un Shape;usted necesita para crear 4 vértices y agregarlos a la estructura que sigue la pista de la lista de todos los vértices.