What is the program to find the area of polygons using c plus plus?

Answer 1

#include<iostream>

#include<vector>

#include<assert.h>

// Typdefs to hide unnecessary implementation detail and remove verbosity.

using Coordinates = std::pair<int,int>;

using Polygon = std::vector<Coordinates>;

// Calculate the area of a given polygon.

int area (const Polygon& polygon)

{

// The given polygon must list all vertices in the correct sequence

// either clockwise or anti-clockwise. It does not matter which

// vertex begins the sequence, but the last vertex is assumed to

// join the first.

// Initialise an accumulator.

int accumulator = 0;

// A polygon with less than 3 vertices is no polygon!

if (polygon.size() < 3)

return accumulator;

// The last vertex is the previous vertex to the first vertex.

// We'll deal with this specific pair of vertices first.

size_t previous = polygon.size() - 1;

// Iterate through all vertices in sequence.

for (size_t current=0; current<polygon.size(); ++current)

{

// The previous and current vertices form an edge. We need to calculate

// the area of the imaginary rectangle extending horizontally from this

// edge until it meets the Y-axis. This edge may not be vertical so we

// also extend in the opposite direction by the same amount. That is,

// for vertices {x1, y1} and {x2, y2}, the imaginary rectangle's opposing

// corners will be at imaginary vertices {0, y1}, {x1+x2, y2}. The area

// of this imaginary rectangle is therefore (x1+x2)*(y1-y2).

// Note: the imaginary rectangle's area may be negative but that's OK.

// It'll simply be subtracted from the accumulator and that's exactly

// what we want.

accumulator +=

(polygon[previous].first + polygon[current].first) *

(polygon[previous].second - polygon[current].second);

// The current vertex now becomes the previous vertex

// in readiness for the next iteration.

previous = current;

}

// Remove the sign (make absolute).

accumulator *= (accumulator<0) ? -1 : 1;

// At this point the accumulated total is guaranteed to be an even

// number (as we'll see). But let's play safe and assert that fact.

assert (accumulator % 2 == 0);

// Since each imaginary rectangle was exactly double what we needed

// (because we extended in both directions), divide the accumulated

// total by 2. It's more efficient to do that here, once, rather

// than for each individual rectangle. We don't have to worry about

// fractions since the accumulator is guaranteed to be even.

return accumulator / 2;

}

// Driver to test the function.

int main()

{

Polygon square;

square.push_back (Coordinates (0, 0));

square.push_back (Coordinates (0, 10));

square.push_back (Coordinates (10, 10));

square.push_back (Coordinates (10, 0));

assert (area (square) == 100);

std::cout << "Square (10 x 10) has area " << area (square) << std::endl;

Polygon triangle;

triangle.push_back (Coordinates (0, 0));

triangle.push_back (Coordinates (0, 6));

triangle.push_back (Coordinates (8, 0));

assert (area (triangle) == 24);

std::cout << "Right-angled triangle (width 8, height 6) has area " << area (triangle) << std::endl;

Polygon irregular;

irregular.push_back (Coordinates (0, 0));

irregular.push_back (Coordinates (0, 14));

irregular.push_back (Coordinates (8, 14));

irregular.push_back (Coordinates (8, 4));

irregular.push_back (Coordinates (12, 4));

irregular.push_back (Coordinates (12, 0));

assert (area (irregular) == 128);

std::cout << "6-sided irregular polygon has area " << area (irregular) << std::endl;

Polygon line;

line.push_back (Coordinates (0, 0));

line.push_back (Coordinates (0, 4));

line.push_back (Coordinates (0, 8));

assert (area (line) == 0);

std::cout << "3 points on a line of length 8 has area " << area (line) << std::endl;

}