#include "myInclude.h"
using namespace nmGeometric;

int main()
{
    // CONSTRUCTORS
    cl_3dPoint < double >   objPointB;
    cl_3dPoint < double >   objPointC(-2, 3, 8);

    // ASSIGNMENT OPERATOR
    objPointB = objPointC;

    system("PAUSE");
    return 0;
}

#ifndef __MY_INCLUDE_H__
#define __MY_INCLUDE_H__

#include <iostream>
using namespace std;

#include "cl_3dPoint.h"

#endif // __MY_INCLUDE_H__

#ifndef __CLASS_3D_POINT__
#define __CLASS_3D_POINT__

namespace nmGeometric
{
    template <typename tType>
    class cl_3dPoint
    {
private:

protected:

public:
    //
    // MEMBER VARIABLES
    //
    tType x, y, z;
    
    //
    // MEMBER FUNCTIONS
    //

    // DESTRUCTOR
    ~cl_3dPoint();

    // CONSTRUCTOR
    cl_3dPoint();

    // CONSTRUCTOR
    cl_3dPoint(const tType & X, const tType & Y, const tType & Z);

    // COPY CONSTRUCTOR
    cl_3dPoint(const cl_3dPoint < tType > & param);

    // =
    inline cl_3dPoint & operator = (const cl_3dPoint < tType > & point_1) const;

    }; // cl_3dPoint


    // *************************************************************************
    // DESTRUCTOR
    // *************************************************************************
    template < typename tType >
    cl_3dPoint < tType >::~cl_3dPoint()
    {
    }

    // *************************************************************************
    // CONSTRUCTOR FOR A 3D POINT AT THE ORIGIN
    // *************************************************************************
    template < typename tType >
    cl_3dPoint < tType >::cl_3dPoint(): x(static_cast < tType > (0)),
                                        y(static_cast < tType > (0)),
                                        z(static_cast < tType > (0)){}
                                        
    // *************************************************************************
    // CONSTRUCTOR FOR INITIALIZING A 3D POINT.
    // *************************************************************************
    template < typename tType >
    cl_3dPoint < tType >::cl_3dPoint(const tType & X, const tType & Y, const tType & Z)
    {
        this->x = X;
        this->y = Y;
        this->z = Z;
    }

    // *************************************************************************
    // COPY CONSTRUCTOR
    // *************************************************************************
    template < typename tType >
    cl_3dPoint < tType >::cl_3dPoint(const cl_3dPoint < tType > & param) : x(param.x),
                                                                           y(param.y),
                                                                           z(param.z){}

    // *************************************************************************
    // =
    // ASSIGNMENT OPERATOR. ASSIGNS ONE POINT TO ANOTHER
    // *************************************************************************
    template < typename tType >
    inline cl_3dPoint & cl_3dPoint < tType >::operator = (const cl_3dPoint < tType > & point_1) const
    {
        //  MAKE SURE THERE IS NO SELF ASSIGNMENT OF THE SAME POINT TO ITSELF
        if (this != &point_1)
        {
            this->x = point_1.x;
            this->y = point_1.y;
            this->z = point_1.z;
        }
        return *this;
    }
} // nm_geometric

#endif // __CLASS_3D_POINT__

inline cl_3dPoint & cl_3dPoint < tType >::operator = (const cl_3dPoint < tType > & point_1) const

    cl_3dPoint & operator = (cl_3dPoint < tType > point_1);

template < typename tType >    cl_3dPoint & cl_3dPoint < tType >::operator = (cl_3dPoint < tType > point_1)    {        //  MAKE SURE THERE IS NO SELF ASSIGNMENT OF THE SAME POINT TO ITSELF        if (this != &point_1)        {            this->x = point_1.x;            this->y = point_1.y;            this->z = point_1.z;        }        return *this;    }

cl_3dPoint & operator = (cl_3dPoint < tType > point_1)    {        //  MAKE SURE THERE IS NO SELF ASSIGNMENT OF THE SAME POINT TO ITSELF        if (this != &point_1)        {            this->x = point_1.x;            this->y = point_1.y;            this->z = point_1.z;        }        return *this;    }

template <typename tType> cl_3dPoint & operator = (cl_3dPoint < tType > point_1);

template < typename tType >class cl_3dPoint{	public:		// inside a template class definition the class name without a template parameter		// is synonomous with the class name templated on the template parameter, so the		// following four declarations have identical meaning:		inline cl_3dPoint & operator=(cl_3dPoint< tType > const & point_1);//		inline cl_3dPoint & operator=(cl_3dPoint const & point_1);//		inline cl_3dPoint< tType > & operator=(cl_3dPoint const & point_1);//		inline cl_3dPoint< tType > & operator=(cl_3dPoint< tType > const & point_1);};template < typename tType >// here cl_3dPoint is a generic template, not a type.  Each occurance of cl_3dPoint must// have a valid template parameter to resolve it as a type.  The following line is therefore// incorrect because of the return typecl_3dPoint & cl_3dPoint< tType >::operator=(cl_3dPoint< tType > const & point_1)// the following line is the corrected formcl_3dPoint< tType > & cl_3dPoint< tType >::operator=(cl_3dPoint< tType > const & point_1){	if (this != &point_1)	{		this->x = point_1.x;		this->y = point_1.y;		this->z = point_1.z;	}	return *this;}