Przekonwertowanie kodu z Javy na C++

Question

Cześć. Jest to mój drugi temat odnośnie tego samego wątku. Potrzebuje wyświetlić x,y,długość i szerokość prostokąta powstałego jako część wspólna 2 prostokątów.

Wszystko już zrobiłem, ale zrobiłem to w Javie, ponieważ jest ona mi bliższa. Myślałem, że jak przekopiuje ten kod:

Rectangle createOverlappedRectangle(Rectangle firstRectangle, Rectangle secondRectangle) {
        Rectangle upperRect;
        Rectangle lowerRect;
        Rectangle leftRect;
        Rectangle rightRect;

        int overlapX;
        int overlapY;
        int overlapWidth;
        int overlapHeight;

        if (firstRectangle.getX() <= secondRectangle.getX()) {
            leftRect = firstRectangle;
            rightRect = secondRectangle;
        } else {
            leftRect = secondRectangle;
            rightRect = firstRectangle;
        }

        if (firstRectangle.getY() <= secondRectangle.getY()) {
            upperRect = secondRectangle;
            lowerRect = firstRectangle;

        } else {
            upperRect = firstRectangle;
            lowerRect = secondRectangle;
        }

        if (leftRect.getX() + leftRect.getWidth() <= rightRect.getX()) {
            return new Rectangle(0, 0, 0, 0);
        } else if (leftRect.getX() + leftRect.getWidth() >= rightRect.getX() + rightRect.getWidth())
            overlapWidth = rightRect.getWidth();
        else {
            overlapWidth = leftRect.getX() + leftRect.getWidth() - rightRect.getX();
        }


        if (upperRect.getY() + upperRect.getHeight() <= lowerRect.getY()) {
            return new Rectangle(0, 0, 0, 0);
        } else if (upperRect.getY() + upperRect.getHeight() >= lowerRect.getY() + lowerRect.getHeight()) {
            overlapHeight = lowerRect.getHeight();
        } else {
            overlapHeight = upperRect.getY() + upperRect.getHeight() - lowerRect.getY();
        }

        overlapX = rightRect.getX();
        overlapY = lowerRect.getY();

        return new Rectangle(overlapX, overlapY, overlapWidth, overlapHeight);
    }

To wszystko bedzie działać, ale wywalało mi błedy:

Użyłem więc konwertera.

Powstała mi taka funkcja:

Rectangle *ConditionChecker::createOverlappedRectangle(Rectangle *firstRectangle, Rectangle *secondRectangle)
{
    Rectangle *upperRect;
    Rectangle *lowerRect;
    Rectangle *leftRect;
    Rectangle *rightRect;

    int overlapX;
    int overlapY;
    int overlapWidth;
    int overlapHeight;

    if (firstRectangle->getX() <= secondRectangle->getX())
    {
        leftRect = firstRectangle;
        rightRect = secondRectangle;
    }
    else
    {
        leftRect = secondRectangle;
        rightRect = firstRectangle;
    }

    if (firstRectangle->getY() <= secondRectangle->getY())
    {
        upperRect = secondRectangle;
        lowerRect = firstRectangle;

    }
    else
    {
        upperRect = firstRectangle;
        lowerRect = secondRectangle;
    }

    if (leftRect->getX() + leftRect->getWidth() <= rightRect->getX())
    {
        return new Rectangle(0.0, 0.0, 0.0, 0.0);
    }
    else if (leftRect->getX() + leftRect->getWidth() >= rightRect->getX() + rightRect->getWidth())
    {
        overlapWidth = rightRect->getWidth();
    }
    else
    {
        overlapWidth = leftRect->getX() + leftRect->getWidth() - rightRect->getX();
    }


    if (upperRect->getY() + upperRect->getHeight() <= lowerRect->getY())
    {
        return new Rectangle(0.0, 0.0, 0.0, 0.0);
    }
    else if (upperRect->getY() + upperRect->getHeight() >= lowerRect->getY() + lowerRect->getHeight())
    {
        overlapHeight = lowerRect->getHeight();
    }
    else
    {
        overlapHeight = upperRect->getY() + upperRect->getHeight() - lowerRect->getY();
    }

    overlapX = rightRect->getX();
    overlapY = lowerRect->getY();

    return new Rectangle(overlapX, overlapY, overlapWidth, overlapHeight);
}

I tutaj pytanie, dlaczego działamy na wskaźnikach? Czemu nie można na zwykłych zmiennych?

I teraz drugie pytanie. Wynik z tego wyświetlałem za pomocą toStringa w Javie. Niestety nie potrafię tego zrobić w C++. Myślałem nad dodanie 'static', aby nie tworzyć instancji klasy ConditionChecker i zrobić coś takiego, a nastepnie wysweitlic za pomoca getterów:

Rectangle r3 = ConditionChecker::createOverlappedRectangle(r1,r2);

Niestety wywala inne błędy.

Wiecie jak wywołać tę funkcję? 

PS: Czy w metodzie muszę przesłać wskaźniki tych prostokątów r1 i r2?

Answer 1

W C++, w przeciwieństwie do Javy, obiekty możesz zwracać/przekazywać przez wartość. Więc jak funkcja zwraca obiekt klasy Rectangle, to nie możesz dać return new Rectangle(0.0, 0.0, 0.0, 0.0);, bo new tworzy obiekt na stercie i zwraca wskaźnik do niego. Powinno być return Rectangle(0.0, 0.0, 0.0, 0.0);

 

Zostań przy pierwotnej wersji, ale wywal new.

 

PS. obiekty stworzone przez new powinny zostać zwolnione przez delete, jak już będą niepotrzebne. To nie Java z GC ;)

Comments

dzięki.