C / C++ / MFC

class Base
{
protected:
   int i;
};

class Child : public Base
{
};

void main()
{
   Child* ptr = new Child;
   ptr->i;
}

Purish Dwivedi wrote:

Some more clarification is needed...

// create instance of class
Point myLocation(23, 54, 32);

Michael Randolph wrote:

I thought once you instantiate the object it sets the variables that I have for parameters in the function? Where am I forgetting something? This should work as far as I can see.

Michael Randolph wrote:

I thought once you instantiate the object it sets the variables that I have for parameters in the function?

Point::Point(float f_x, float f_y, float f_z) : x(f_x), y(f_y), z(f_z)
{
   cout << "We're in the constructor with arguments " << (int)this /*unique identifier*/ << endl;
}<pre>

or explicit assignments

<pre>Point::Point(float f_x, float f_y, float f_z)
{
   x = f_x;
   y = f_y;
   z = f_z;
   cout << "We're in the constructor with arguments " << (int)this /*unique identifier*/ << endl;
}

g++ -o inheritance inheritance.cpp
inheritance.cpp: In function ‘int main()’:
inheritance.cpp:165: error: no match for ‘operator=’ in ‘vect3 = Vector::operator+(Vector&)(((Vector&)(& vect2)))’
inheritance.cpp:135: note: candidates are: Vector& Vector::operator=(Vector&)

#include <iostream>

using namespace std;

class Point
{
public:
	Point(float f_x = 1.0, float f_y = 1.0, float f_z = 1.0);
	~Point();

	// return by reference
	void getXYZ(float &X, float &Y, float &Z);
	float getX();
	float getY();
	float getZ();
	
	void setXYZ(float X, float Y, float Z);
	void setX(float X);
	void setY(float Y);
	void setZ(float Z);	
	
	// overloading = operator to deal with pointers
	Point operator = (Point &p);

private: 
	float x, y, z;

protected:

};

// define constructor with args
Point::Point(float f_x, float f_y, float f_z)
{
	cout << "We're in the constructor with arguments " << (int)this /*unique identifier*/ << endl;
	x = f_x;
	y = f_y;
	z = f_z;
}

// define destructor
Point::~Point()
{
	cout << "Destructing now!!! " << (int)this /*unique identifier*/ << endl;
}

// public function to return private value of variable x
float Point::getX()
{
	return x;
}

// public function to return private value of variable y
float Point::getY()
{
	return y;
}

// public function to return private value of variable z
float Point::getZ()
{
	return z;
}

// public function to change value of private variable x
void Point::setX(float X)
{
	x = X;
}

// public function to change value of private variable y
void Point::setY(float Y)
{
	y = Y;
}

// public function to change value of private variable z
void Point::setZ(float Z)
{
	z = Z;
}

// public function to change value of all three private variables
void Point::setXYZ(float X, float Y, float Z)
{
	/* slower
	setX(X);
	setY(Y);
	setZ(Z);*/
	// faster
	x = X;
	y = Y;
	z = Z;
	
}

// public function to return values of x,y,z by reference
void Point::getXYZ(float &X, float &Y, float &Z)
{
	X = getX();
	Y = getY();
	Z = getZ();
}

// overloading operator << (output stream)
ostream &operator <<(ostream &stream, Point &p)
{
	stream << p.getX() << " " << p.getY() << " " << p.getZ();
	return stream;
}

// overloading operator >> (input stream)
istream &operator >>(istream &stream, Point &p)
{
	float x, y, z;
	stream >> x >> y >> z;
	p.setXYZ(x, y, z);
	return stream;
}

// overloading = operator
Point Point::operator =(Point &p)
{
	setX(p.getX());
	setY(p.getY());
	setZ(p.getZ());
	// passing back value rather than address
	return *this;
}
//------------------------------------------
// Point Class End
//------------------------------------------

class Vector : public Point
{
public:
	Vector(float X=0, float Y=0, float Z=0);
	Vector operator +(Vector &p);
};

// initiate X, Y, Z from Point Class with : operator
Vector::Vector(float X, float Y, float Z) : Point(X, Y, Z)
{
//anything extra can go here
}

Vector Vector::operator +(Vector &p)
{
	Vector outV;
	outV.setX(getX() + p.getX());
	outV.setY(getY() + p.getY());
	outV.setZ(getZ() + p.getZ());
	return outV;
}

int main()
{
	// instance of the Vector Class
	Vector vect1(1, 2, 3);

	Vector vect2(5, 4, 2);

	Vector vect3;

	vect3 = vect1 + vect2;

	cout << vect3 << endl;
	
}