C / C++ / MFC

// 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;
	
}

Point& operator = (Point const &p);

void getXYZ(float &X, float &Y, float &Z) const;
float getX() const;
float getY() const;
float getZ() const;

#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();
	
	void setXYZ(float X, float Y, float Z);
	void setX(float X);
	void setY(float Y);
	void setZ(float Z);

	// return by reference
	void getXYZ(float &X, float &Y, float &Z);
	float getX() const;
	float getY() const;
	float getZ() const;
	
	// overloading = operator to deal with pointers
	Point& operator =(Point const &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() const
{
	return x;
}

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

// public function to return private value of variable z
float Point::getZ() const
{
	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
Point& Point::operator =(Point const &p)
{
	setX(p.getX());
	setY(p.getY());
	setZ(p.getZ());
	// passing back value rather than address
	return *this;
}

// 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;
}

//------------------------------------------
// 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;
	
}

Aljaz111 wrote:

This "game" or program is very important for me and must be made fast.

CPallini wrote:

and what are the hurdles on your way.

Aljaz111 wrote:

I don't know how to start

Aljaz111 wrote:

i am thinking about making an array with all alphabetic chars(arrayAlpha[25]) and another array for numbers(arrayNum[10]). But i don't know how to randomly choose one of them..i know function for example rnd()%1+1

led mike wrote:

So you have a plan and have made some assumptions. The assumptions are without form and the Plan is completely without substance. The darkness is upon those that read your post. Verily we say unto you:

"It is a crock of sh*t, and it stinketh".

"It is a pail of dung and none may abide by the odor thereof."