Problem of C++ Template

[MADGE25]

I have a class fraction (part of a maths package) that I spend in the Template, it is called now FractionG. So I normally made all the changes but adequate unit testing of my overload =, ==,! = does not work (using the example on my MatriceG). I have no error except "template class has already been defined" to build

FractionG_2.cpp following code:

#ifndef _FractionG
#include "FractionG.h"
#endif
template <class G>
FractionG <G> &FractionG <G>::operator =(const FractionG& f) {
m_numerator= f.m_numerator;
m_denominator= f.m_denominator;
return *this ;
}
template <class G>
FractionG <G> &FractionG <G>::operator =(int op) {
m_numerator= op ;
m_denominator= 1 ;
return *this ;
}
template <class G>
bool FractionG <G>::operator ==(const FractionG& f) {
   return numerator()*f.denominator() == f.numerator()*denominator(); 
}
integer
template <class G>
bool FractionG <G>::operator ==(int op) {
   return numerator() == op*denominator();
}
template <class G>
bool FractionG <G>::operator !=(const FractionG& f) {
return numerator()*f.denominator() != f.numerator()*denominator();
}
integer
template <class G>
bool FractionG <G>::operator !=(int op) {
   return numerator() != op*denominator();
}

And here's my unit test:

#ifndef _FractionG_
#include "..\_SRC\FractionG.h"
#endif
#include "..\_SRC\FractionG.cpp"
#include "..\_SRC\FractionG_2.cpp"
#include "T:\_Tests\Tests\Tests.h"
void main () {
   Tests::Begin("_Maths.FractionG", "2.0.0" );
      Tests::Design("Control of operators (First part)", 3);
         /*Tests::Case("Operator == : comparison of two FractionG" ); {
         
     FractionG f1(3,3);
  Fraction f2(5), f3(-3), f4(6);
  int f5(2,1), f6(12,6), f7(3,1), f8(-3,1);
  int f9(10,5), f10(-10,-5);
            Tests::Unit(0,  f1==f2);
            Tests::Unit(1,  f3==f4);
            Tests::Unit(1,  f5==f6);
            Tests::Unit(0,  f7==f8);
            Tests::Unit(0,  f9==f10);
  Tests::Unit(1,  f2==f9);
         }*/
         Tests::Case("Operator == : comparison with an integer" ); {
  int f1(2),  f2(-2), f3(0), f4(0);
            Tests::Unit(1,  f1==2);
            Tests::Unit(1,  f2==-2);
            Tests::Unit(1,  f3==0);
            Tests::Unit(0,  f4==-1);
         }
         /*Tests::Case("Operator != : comparison of two FractionGs" ); {
  int f1(2),  f2(7), f3(-2), f4(2);
  int f5(2), f6(-4), f7(1), f8(1);
            Tests::Unit(1,  f1!=f2);
            Tests::Unit(1,  f3!=f4);
  Tests::Unit(0,  f4!=f5);
            Tests::Unit(1,  f5!=f6);
            Tests::Unit(0,  f7!=f8);
         }*/
     
         Tests::Case("Operator != : comparison with an integer" ); {
  int f1(2),  f2(4), f3(-1), f4(-1);
            Tests::Unit(0,  f1!=2);
            Tests::Unit(1,  f2!=-2);
            Tests::Unit(1,  f3!=0);
            Tests::Unit(0,  f4!=-1);
         }
      Tests::Design("Control of operators (Second part)", 3);
         /*Tests::Case("Operator = : case of two FractionGs" ); {
         FractionG& <FractionG> f1(2,3),  f2(5,4);
         FractionG& <FractionG> f(0);
            f=f1;  Tests::Unit(1, f==f1);
                   Tests::Unit(0, f==f2);
            f1=f2; Tests::Unit(0, f1==f);
                   Tests::Unit(1, f1==f2);
         }
         Tests::Case("Operator = : case of an integer" ); {
         FractionG& <FractionG> f(-1);
            f=0; Tests::Unit(0, f==1);
                 Tests::Unit(1, f==0);
                 Tests::Unit(1, f==-0);
            f=7; Tests::Unit(0, f==0);
                 Tests::Unit(1, f==7);
         }
*/
   Tests::End();
}

[Modifier]

Its normal the return <G> line 18? I have doubt if there is some problem over here. And we must not put the body of template in a .cpp but one .h.

[MADGE25]

Here in .H, overloading the constructor works.

#include <stdio.h>
#include <math.h>
#ifndef _Object_
#include "T:\_Archives\Object\Object.h"
#endif
#ifndef _Archive_
#include "T:\_Archives\Archive\Archive.h"
#endif
#ifndef _Archive_
#include "T:\_Archives\_Archives\_Archives.h"
#endif
#define _FractionG_
int PGCD (int, int);
int PPCM (int, int);
template <class G> class FractionG {
private :
int m_numerator;
int m_denominator;
void  reduce();
public :
FractionG () {m_numerator= 0; m_denominator=1;}
FractionG(int, int);
FractionG(int);
FractionG(const FractionG& );
inline bool ok()  const {return (m_denominator==0 ? false : true);}
inline bool nok() const {return !ok();}
inline int numerator()   const {return m_numerator;}
inline int denominator() const {return m_denominator;}
FractionG& operator =(const FractionG& );
FractionG& operator =(int);
FractionG* operator +(const FractionG& );
FractionG* operator +(int);
FractionG& operator +=(const FractionG& );
FractionG& operator +=(int);
FractionG* operator -(const FractionG& );
FractionG* operator -(int);
FractionG& operator -=(const FractionG& );
FractionG& operator -=(int);
FractionG* operator *(const FractionG& );
FractionG* operator *(int);
FractionG& operator *=(const FractionG& );
FractionG& operator *=(int);
FractionG* operator /(const FractionG& );
FractionG* operator /(int);
FractionG& operator /=(const FractionG& );
FractionG& operator /=(int);
bool operator ==(const FractionG& );
bool operator ==(int);
bool operator !=(const FractionG& );
bool operator !=(int);
bool operator <(const FractionG& );
bool operator <(int);
bool operator <=(const FractionG& );
bool operator <=(int);
bool operator >(const FractionG& );
bool operator >(int);
bool operator >=(const FractionG& );
bool operator >=(int);
char* toString() const;
};

[Modifier]

What I mean is that except in special cases, we see the power of definition templates when used. So we place the definition in the .hpp - directly or indirectly, I tend to put one .tpp is included in the .hpp, like my inline definitions are sometimes in one .ipp.

Second remark, using absolute paths in the includes is a bad idea. Use relative paths (and with/as separator, it works on Windows as on Unix) and shows the roots or find your compiler.

[MADGE25]

For paths it is normal, we all work on the same basis T: But it's true that you're right! Otherwise I do not see where there is a problem, do I emulate the MatriceG fraction that works very well (except the persistence).

[Modifier]

So there's going to go very slowly

Property:

// template.hpp
template<class T> struct foo
{
   void bar() { /* some code; */ }
};

Although NOT:

// template.hpp
template<class T> struct foo
{
   void bar();
};

//template.cpp
#include "template.hpp"
template<class T> void foo<T>::bar() { /* some code; */ }