Derived Classes Error - c++

Question

I finished a small program using derived classes and it compiles correctly, but the output is wrong.
The program uses an ordered pair (x, y) as the center for a circle. It then uses the center and the radius given to determine the area and circumference of the circle.
Outputting ordered pairs with the pointType class works fine, but when I tested the circleType class I expected to get (0, 0) as a default. Instead I got (2293512, 2293700)
Any help given will be appreciated!
Here's the point class code:
#ifndef POINTTYPE_H_INCLUDED
#define POINTTYPE_H_INCLUDED
#include <iostream>
class pointType{
public:
pointType (int=0, int=0);
int getX() const;
int getY() const;
void setX(int);
void setY(int);
void setValues(int, int);
friend pointType operator + (pointType, pointType);
friend pointType operator - (pointType, pointType);
friend std::ostream& operator << (std::ostream&, pointType);
private:
int x;
int y;
};
#endif // POINTTYPE_H_INCLUDED
Here's the point class implementation:
#include "pointType.h"
pointType::pointType (int X, int Y) : x(X), y(Y) {}
int pointType::getX () const {
return x;
}
int pointType::getY () const {
return y;
}
void pointType::setX (int new_x) {
x = new_x;
}
void pointType::setY (int new_y) {
y = new_y;
}
void pointType::setValues (int new_x, int new_y) {
x = new_x;
y = new_y;
}
pointType operator + (pointType lh, pointType rh){
pointType answer;
answer.x = lh.x + rh.x;
answer.y = lh.y + rh.y;
return answer;
}
pointType operator - (pointType lh, pointType rh){
pointType answer;
answer.x = lh.x - rh.x;
answer.y = lh.y - rh.y;
return answer;
}
std::ostream& operator << (std::ostream& out, pointType c){
out << "(" << c.x << ", " << c.y << ")";
return out;
}
Here's the circle class:
#ifndef CIRCLETYPE_H_INCLUDED
#define CIRCLETYPE_H_INCLUDED
#include "pointType.h"
#include <iostream>
class circleType: protected pointType {
public:
circleType (float=0);
circleType (int=0, int=0);
void setRadius (float);
float calculateArea (float);
float calculateCircumference (float);
friend std::ostream& operator << (std::ostream&, circleType);
private:
float radius;
int center_x;
int center_y;
};
#endif // CIRCLETYPE_H_INCLUDED
Here's the circle class implementation:
#include "pointType.h"
#include "circleType.h"
#include <math.h>
const float PI = 3.14;
circleType::circleType(float R): radius(R) {}
circleType::circleType(int center_X, int center_Y):
pointType(center_x, center_y) {}
void circleType::setRadius(float new_radius) {
radius = new_radius;
}
float circleType::calculateArea(float radius) {
float area;
area = PI * pow(radius, 2);
return area;
}
float circleType::calculateCircumference(float radius) {
float circumference;
circumference = PI * (radius * 2);
return circumference;
}
std::ostream& operator << (std::ostream& odata, circleType f) {
odata << "(" << f.center_x << ", " << f.center_y << ")";
return odata;
}
Here's the testing code:
#include "pointType.h"
#include "circleType.h"
#include <iostream>
#include <math.h>
using namespace std;
int main() {
pointType c, d(8, 9);
circleType f(4, 5);
cout << c << endl;
cout << d << endl;
c.setValues(12, 3);
cout << c << endl;
cout << c + d << endl;
cout << c - d << endl;
cout << f << endl;
return 0;
}

Answer 1

As far as I can see, the circleType int members center_x and center_y are never set. Your constructor CircleType::CircleType(int=0,int=0) calls the base constructor, which in turn set pointType.x and pointType.y, both private members of the base class (and hence not available to circleType).
My suggestion (or what I think you intended\expected): make int x and int y protected, not private, and remove center_x and center_y, then print odata << "(" << f.x << ", " << f.y << ")";

Answer 2

Its a typo.
circleType::circleType(int center_X, int center_Y):
pointType(center_x, center_y) {}
Notice the difference between center_X (uppercase) and center_x (lowercase).
You pass your uninitialized members to the parent constructor which can have any value lingering at the stack.
Therefor it is good practive to always preceed your members with m_ e.g: m_centerX. (In this particular case it isnt even neccessary to have them again in the child class, redundancy is bad!)
EDIT:
Sorry for the confusion, but please be more precisly next time, could have saved us all alot of time. I assumed that your problems occurs when adding a point with a circle, after running the code by my own I noticed that it happens when outputting f. The reason is the same as explained above: you dont initialize your members! They simply hold any value which were currently at the memory location the object becomes constructed.

Answer 3

In your circleType class, center_x and center_y aren't being initialised. The parameters are being passed directly to the pointType constructor and setting the private members. You can prove this by changing the operator<< function that takes a circleType argument:
std::ostream& operator << (std::ostream& odata, circleType f) {
odata << "(" << f.center_x << ", " << f.center_y << ")" << std::endl;
odata << "(" << f.getX() << ", " << f.getY() << ")"; //access superclass
return odata;
}
With protected inheritance, you also can't use the + and - overloads defined for the base class either, it won't compile.