copy constructor overloaded is ambiguous

[justontime41]

Ok so I felt like I followed my book and professor's videos pretty well, but I keep getting an ambiguous error on my copy constructor. How do I fix an ambiguous error?

Error message:

test.cpp: In copy constructor ‘Circle::Circle(const Circle&)’:
test.cpp:281:38: error: call of overloaded ‘Shape()’ is ambiguous
Circle::Circle(const Circle &circleIn)
^
test.cpp:281:38: note: candidates are:
test.cpp:29:1: note: Shape::Shape(int)
Shape::Shape(int sidesIn = -1)
^
test.cpp:23:1: note: Shape::Shape()
Shape::Shape()

  
#include <iostream>
#include <cmath>
using std::cout;
using std::endl;

class Shape
{
protected:
   int numSides;

public:
   Shape();               //default constructor
   Shape(int);               //constructor with parameter
   Shape(const Shape &);   //copy constructor
   ~Shape();               //deconstructor
   double area();           //to be overridden by child classes
   double perimeter();       //to be overridden by child classes
   int getSides();           //returns the number of sides
};


//default constructor
Shape::Shape()
{
   numSides = -1;
}

//normal case constructor
Shape::Shape(int sidesIn = -1)
{
   numSides = sidesIn;
}

//copy constructor
Shape::Shape(const Shape &shapeIn)
{
   numSides = shapeIn.numSides;
}

//deconstructor
Shape::~Shape()
{
   // << "Shape deconstructor has run." << endl;
}

//function that will be typically overrided by childs function
double Shape::area()
{
   return -1;
}

//function that will be typically overrided by childs function
double Shape::perimeter()
{
   return -1;
}

//function that returns the number of sides
int Shape::getSides()
{
   return numSides;
}

class Triangle : public Shape
{
private:
   double side1;
   double side2;
   double side3;

public:
   Triangle();                           //default constructor
   Triangle(double, double, double);   //constructor with parameters
   Triangle(const Triangle &);           //copy constructor
   ~Triangle();                       //deconstructor
   double area();                       //returns area
   double perimeter();                   //returns perimeter
   void incSides(int);                   //increases each side recursively n times
   double getSide1();                   //returns side1 value
   double getSide2();                   //returns side2 value
   double getSide3();                   //returns side3 value
};

//default constructor
Triangle::Triangle() : Shape(3)
{
   side1 = -1;
   side2 = -1;
   side3 = -1;
}

//normal case constructor w/default values
Triangle::Triangle(double side1In = -1, double side2In = -1, double side3In = -1) : Shape(3)
{
   side1 = side1In;
   side2 = side2In;
   side3 = side3In;
}

//copy constructor
Triangle::Triangle(const Triangle &triangleIn)
{
   side1 = triangleIn.side1;
   side2 = triangleIn.side2;
   side3 = triangleIn.side3;
}

//deconstructor
Triangle::~Triangle()
{
   //cout << "Rectangle deconstructor has run.";
}

//increases each side recursively n times
void Triangle::incSides(int n)
{
   if (n == 1)
   {
       return;
   }
   incSides(n - 1);
   side1 += side1;
   side2 += side2;
   side3 += side3;
}

//calculates and returns area
double Triangle::area()
{
   if (side1 == -1 || side2 == -1 || side3 == -1) return 0;
   else
   {
       double s = (side1 + side2 + side3) / 2;
       double area = sqrt(s* (s - side1)*(s - side2)*(s - side3));
       return area;
   }
}

//calculates and returns perimeter
double Triangle::perimeter()
{
   if (side1 == -1 || side2 == -1 || side3 == -1) return 0;
   else
   {
       return side1 + side2 + side3;
   }
}

//getters for testing
double Triangle::getSide1()
{
   return side1;
}

double Triangle::getSide2()
{
   return side2;
}

double Triangle::getSide3()
{
   return side3;
}

class Rectangle : public Shape
{
private:
   double side1;
   double side2;

public:
   Rectangle();                   //default constructor
   Rectangle(double, double);       //constructor with parameters
   Rectangle(const Rectangle &);   //copy constructor
   ~Rectangle();                   //deconstructor
   double area();                   //returns area
   double perimeter();               //returns perimeter
   void incSides(int);               //increases each side recursively n times
   double getSide1();                   //returns side1 value
   double getSide2();                   //returns side2 value
};

Rectangle::Rectangle() : Shape(4)
{
   side1 = -1;
   side2 = -1;
}

//normal case constructor w/default values
Rectangle::Rectangle(double side1In = -1, double side2In = -1) : Shape(4)
{
   side1 = side1In;
   side2 = side2In;
}

//copy constructor
Rectangle::Rectangle(const Rectangle &rectangleIn)
{
   side1 = rectangleIn.side1;
   side2 = rectangleIn.side2;
}

//deconstructor
Rectangle::~Rectangle()
{
   //cout << "Rectangle deconstructor has run.";
}

//increases each side recursively n times
void Rectangle::incSides(int n)
{
   if (n == 1)
   {
       return;
   }
   incSides(n - 1);
   side1 += side1;
   side2 += side2;
}

//calculates and returns area
double Rectangle::area()
{
   if (side1 == -1 || side2 == -1) return 0;
   else
   {
       return side1 * side2;
   }
}

//calculates and returns perimeter
double Rectangle::perimeter()
{
   if (side1 == -1 || side2 == -1) return 0;
   else
   {
       return (2 * side1) + (2 * side2);
   }
}

//getters for testing
double Rectangle::getSide1()
{
   return side1;
}

double Rectangle::getSide2()
{
   return side2;
}

class Circle : public Shape
{
private:
   double radius;

public:
   Circle();                   //default constructor
   Circle(double);               //constructor with parameter
   Circle(const Circle &);       //copy constructor
   ~Circle();                   //deconstructor
   double getRadius();           //returns radius
   void setRadius(double);    //sets radius
   double area();               //returns area
   double perimeter();           //returns perimeter
   void incSides(int);           //increases length of the radius recursively n times
};

Circle::Circle() : Shape(0)
{
   radius = -1;
}

//normal case constructor
Circle::Circle(double radiusIn = -1) : Shape(0)
{
   radius = radiusIn;
}

//copy constructor
Circle::Circle(const Circle &circleIn)
{
   radius = circleIn.radius;
}

//deconstructor
Circle::~Circle()
{
   //cout << "Circle deconstructor has run.";
}

//gets radius
double Circle::getRadius()
{
   return radius;
}

//sets radius
void Circle::setRadius(double radiusIn)
{
   radius = radiusIn;
}

//returns area
double Circle::area()
{
   if (radius == -1) return 0;
   else
   {
       return 3.14 * (radius * radius);
   }
}

//returns perimeter
double Circle::perimeter()
{
   if (radius == -1) return 0;
   else
   {
       return 2 * 3.14 * radius;
   }
}

//increases length the radius recursively n times
void Circle::incSides(int n)
{
   if (n == 1)
   {
       return;
   }
   incSides(n - 1);
   radius += radius;
}

int main()
{
   //circle tests
   Circle newCircle = Circle(2);
   cout << "newCircle radius is: " << newCircle.getRadius() << endl;
   newCircle.incSides(3);
   cout << "newCircle radius is: " << newCircle.getRadius() << endl;
   std::cin.get();

   //rectangle tests
   Rectangle newRectangle = Rectangle(2, 3);
   cout << "newRectangle side1, side2: " << newRectangle.getSide1() << " , " << newRectangle.getSide2() << endl;
   newRectangle.incSides(3);
   cout << "newRectangle side1, side2: " << newRectangle.getSide1() << " , " << newRectangle.getSide2() << endl;
   std::cin.get();

   //triangle tests
   Triangle newTriangle = Triangle(5, 5, 5);
   cout << "newTriangle side1, side2, side3: " << newTriangle.getSide1() << " , " << newTriangle.getSide2() << " , " << newTriangle.getSide3() << endl;
   cout << "newTriangle's area: " << newTriangle.area() << endl;
   newTriangle.incSides(3);
   cout << "newTriangle side1, side2, side3: " << newTriangle.getSide1() << " , " << newTriangle.getSide2() << " , " << newTriangle.getSide3() << endl;
   std::cin.get();

   return 0;
}

[Moschops]

Your copy constructors for Circle, Triangle, Rectangle, need to call a Shape constructor. They don't know which one to call. See how your default constructors specify which Shape constructor to call? Do that on the copy constructors too.

[justontime41]

Wow, that seemed so much easier than I thought. Thanks Moschops