So, I am trying to take input and then put that input into temporary vector that then puts that temporary vector into a vector. The input is linked to an istream from a Point class. Whenever I try to cout an index of the polygon vector, it just displays default values from my point class. This is causing my program not to work correctly.
//Initialize variables
int32_t
nPolygon,
nVerticies[20],
nDarts,
poly{ 0 },
number;
Fraction
score,
area[100],
boardArea;
Point
corner,
dart;
bool
dartThrow;
std::vector<Point> temp(20);
std::vector<std::vector<Point>> polygons;
//input
std::cin >> corner;
std::cin >> nPolygon;
boardArea = corner.getX() * corner.getY(); // Used to calculate the area of the dart board
// Gets the points in each polygon and adds them to the polygon vector
for (int32_t i {0}; i < nPolygon; i++) {
std::cin >> number;
nVerticies[i] = number;
for (int32_t k{0}; k < number; k++) {
Point point;
std::cin >> point;
temp.push_back(point);
}
polygons.push_back(temp);
temp.clear();
area[i] = areaOfPolygon(i, number, polygons);
}
This is the input part of my code. Here is my point.h
#include <iostream>
#include "fraction.h"
#pragma once
class Point {
private:
Fraction
x,
y;
public:
explicit Point(Fraction _x = Fraction(), Fraction _y = Fraction());
~Point() = default ;
Point operator + (Point b);
Point operator - (Point b);
Fraction operator * (Point b); //Cross Product
Point operator * (Fraction rhs); //Scaling product
Point &operator = (Point b);
bool operator == (Point b);
bool operator != (Point b);
Fraction getX() const { return x; }
Fraction getY() const { return y; }
};
std::istream &operator >> (std::istream &is, Point &p);
std::ostream &operator << (std::ostream &os, Point p);
Here is my point.ccp
#include "point.h"
#include "fraction.h"
Point::Point(Fraction _x, Fraction _y) { //Sets x and y coordinates in a single point
x = _x;
y = _y;
}
Point Point::operator + (Point b) {
return Point(x + b.x,y +b.y);
}
Point Point::operator - (Point b) {
return Point(x - b.x, y - b.y);
}
Fraction Point::operator * (Point b) { //cross product;
return x * b.y - y * b.x;
}
Point Point::operator * (Fraction rhs) { //Scaling point by a fraction by multiplication (not the same as cross product)
return Point(x * rhs, y * rhs);
}
Point &Point::operator=(Point b) {
x = b.x;
y = b.y;
return *this;
}
bool Point::operator == (Point b) {
return x == b.x && y == b.y; //Returns true if point a is the same as point b
}
bool Point::operator != (Point b) {
return x != b.x || y != b.y; //Returns true if point a is different from point b
}
std::istream& operator >> (std::istream& is, Point& p) {
Fraction
x, y;
char
lPar, comma, rPar;
is >> lPar >> x >> comma >> y >> rPar;
p = Point(x,y);
return is;
}
std::ostream& operator << (std::ostream& os, Point p) {
os << "(" << p.getX() << ", " << p.getY() << ") ";
return os;
}
Here is my fraction.h
#include <iostream>
#include <cstdint> // Definitions for data type that prof likes to use. (Size)
//#ifndef _FRACTION_H // If not defined, compiler will see everything between if & endif
//#define _FRACTION_H // If defined, we will see nothing inside
#pragma once
class Fraction {
private:
int32_t
numerator,
denominator;
public:
explicit Fraction(int32_t _numerator = 0, int32_t _denominator = 1); // Constructor
~Fraction() = default; // Destructor. Purpose is to free memory space / cleanup
Fraction operator + (Fraction rhs);
Fraction operator += (Fraction rhs);
Fraction operator - (Fraction rhs);
Fraction operator * (Fraction rhs);
Fraction operator / (Fraction rhs);
Fraction& operator = (Fraction rhs);
bool operator == (Fraction rhs);
bool operator != (Fraction rhs);
bool operator <= (Fraction rhs);
bool operator >= (Fraction rhs);
bool operator < (Fraction rhs);
bool operator > (Fraction rhs);
double getNum() const { return numerator; }
double getDen() const { return denominator; }
};
std::istream& operator >> (std::istream& is, Fraction& f);
std::ostream& operator << (std::ostream& os, Fraction f);
//#endif
and lastly my fraction.cpp
#include "fraction.h"
int32_t gcd(int32_t a, int32_t b) {
int32_t
r;
// make sure a and b are not negative
a = (a < 0) ? -a : a; //if an is negative, flip it to positive
b = (b < 0) ? -b : b; //if b is negative, flip it to positive
while (b != 0) {
r = a % b;
a = b;
b = r;
}
return a;
}
Fraction::Fraction(int32_t _numerator, int32_t _denominator) {
int32_t
g;
if (_denominator < 0) {
_numerator = -_numerator;
_denominator = -_denominator;
}
g = gcd(_numerator, _denominator);
numerator = _numerator / g;
denominator = _denominator / g;
}
Fraction Fraction::operator + (Fraction rhs) {
int32_t
s, t;
s = numerator * rhs.denominator + rhs.numerator * denominator;
t = denominator * rhs.denominator;
return Fraction(s, t);
}
Fraction Fraction::operator += (Fraction rhs) {
int32_t
s, t;
s = numerator * rhs.denominator + rhs.numerator * denominator;
t = denominator * rhs.denominator;
return rhs + Fraction(s, t);
}
Fraction Fraction::operator - (Fraction rhs) {
int32_t
s, t;
s = numerator * rhs.denominator - rhs.numerator * denominator;
t = denominator * rhs.denominator;
return Fraction(s, t);
}
Fraction Fraction::operator * (Fraction rhs) {
int32_t
s, t;
s = numerator * rhs.numerator;
t = denominator * rhs.denominator;
return Fraction(s, t);
}
Fraction Fraction::operator / (Fraction rhs) {
int32_t
s, t;
s = numerator * rhs.denominator;
t = denominator * rhs.numerator;
return Fraction(s, t);
}
Fraction& Fraction::operator = (Fraction rhs) {
numerator = rhs.numerator;
denominator = rhs.denominator;
return *this;
}
bool Fraction::operator == (Fraction rhs) {
return numerator == rhs.numerator && denominator == rhs.denominator;
}
bool Fraction::operator != (Fraction rhs) {
return numerator != rhs.numerator || denominator != rhs.denominator;
}
bool Fraction::operator <= (Fraction rhs) {
return numerator * rhs.denominator <= denominator * rhs.numerator;
}
bool Fraction::operator >= (Fraction rhs) {
return numerator * rhs.denominator >= denominator * rhs.numerator;
}
bool Fraction::operator < (Fraction rhs) {
return numerator * rhs.denominator < denominator* rhs.numerator;
}
bool Fraction::operator > (Fraction rhs) {
return numerator * rhs.denominator > denominator * rhs.numerator;
}
std::istream& operator >> (std::istream& is, Fraction& f) {
int32_t
n, d;
char
slash;
is >> n >> slash >> d;
f = Fraction(n, d);
return is;
}
std::ostream& operator << (std::ostream& os, Fraction f) {
os << f.getNum() << " / " << f.getDen();
return os;
}