multi-template parameter friend template functions

[rtalbot]

I've got a container that looks like this:

template <class T>
class Foo
{
 public:
  Foo() : _data(), _status(1) { }
  Foo(T) : _data(T), _status(0) { }
  ~Foo() { }

  template<class U>
  Foo<T>& operator=(const U& u) {_data=u; _status=0; return *this;}

 private:
  T _data;
  int _status;
};

...and would like to be able to do things like this:

Foo<float> fooF(3.5);
Foo<double> fooD1(4.7);
Foo<double> fooD2=fooF+fooD1;

"Easy," I think to myself, write a friend operator+:

[B]
//gcc typeof(T()+U()) results in an ICE... this is my work-around
template <class T, class U>
struct Promote
{
 static const T t;
 static const U u;
 typedef typeof(t+u) Result;
};
[/B]
[B]template <class T> Foo; //forward declaration of class Foo[/B] 
[B]template <class T, class U> Foo<typename Promote<T,U>::Result> operator+(const Foo<T>& lhs, const Foo<U>& rhs); //identify operator+ as template func[/B]

template <class T>
class Foo
{
 public:
  Foo() : _data(), _status(1) { }
  Foo(T) : _data(T), _status(0) { }
  ~Foo() { }

  template<class U>
  Foo<T> operator=(const U& u) {_data=u; _status=0;}
  [B]template <class U>
  Foo<typename Promote<T,U>::Result> operator+<>(const Foo<T>& lhs, const Foo<U>& rhs);[/B]

 private:
  T _data;
  int _status;
};

[B]
//operator+() definition
template <class T, class U> Foo<typename Promote<T,U>::Result> operator+(const Foo<T>& lhs, const Foo<U>& rhs)
{
 Foo<typeof(lhs._data+rhs._data)> result;
 result._data=lhs._data+rhs._data;
 result._status=lhs._status|rhs._status;
 return result;
}[/B]

One of the problems I'm running into may be compiler related: in the class declaration of the friend function (line 25 above), I get an error:

error: invalid use of template-id `operator+<>' in declaration of primary template

...which confuses me, because I thought this was the correct way to declare friend templates as per the C++ FAQ and the GCC FAQ. But, those examples didn't take multiple template parameters, so maybe something changes.

Another problem that I think I will run into is that I don't know if the friendship mechanism will allow Foo<T>._data and Foo<U>._data to be accessible in the operator+() function. That is my hope, even though Foo<float> and Foo<double> are distinct types. If not, how do I allow such a thing without using a public accessor?

Basically the purpose of this container is to couple a status with a POD. We need a way in our system to flag variables as invalid, and for that status to cascade to any variables that are results of calculations of that invalid variable. We'd still like to treat these variable containers like POD, though, except for special cases during comparisons and extraction of the actual data it contains (needs to be valid, or else it throws... hence public accessor can't be used in operators). The above class is a slight over-simplification, but illustrates the problem.

I'm not sure this is the best way to achieve what I want, or if it's even possible within C++, but I couldn't find any generic containers out there that would allow POD-style operators between containers of compatible PODs. I'm open to suggestions for alternate methods/containers/idioms!

My previous incarnation of this class basically had a byte array, an enumerated identifier that specified the POD type to emulate, a lot of hand-coded operators with switch() statements and conversion constructors. The run-time overhead started to get significant, so I'm trying to re-work as much of the type stuff into compile-time as possible.

OS: GNU/linux
Compiler: gcc 3.4.6

Thanks in advance for any insight!

[rtalbot]

I've got a container that looks like this:

template <class T>
class Foo
{
 public:
  Foo() : _data(), _status(1) { }
  Foo(T) : _data(T), _status(0) { }
  ~Foo() { }

  template<class U>
  Foo<T>& operator=(const U& u) {_data=u; _status=0; return *this;}

 private:
  T _data;
  int _status;
};

...and would like to be able to do things like this:

Foo<float> fooF(3.5);
Foo<double> fooD1(4.7);
Foo<double> fooD2=fooF+fooD1;

"Easy," I think to myself, write a friend operator+:

[B]
//gcc typeof(T()+U()) results in an ICE... this is my work-around
template <class T, class U>
struct Promote
{
 static const T t;
 static const U u;
 typedef typeof(t+u) Result;
};
[/B]
[B]template <class T> Foo; //forward declaration of class Foo[/B] 
[B]template <class T, class U> Foo<typename Promote<T,U>::Result> operator+(const Foo<T>& lhs, const Foo<U>& rhs); //identify operator+ as template func[/B]

template <class T>
class Foo
{
 public:
  Foo() : _data(), _status(1) { }
  Foo(T) : _data(T), _status(0) { }
  ~Foo() { }

  template<class U>
  Foo<T> operator=(const U& u) {_data=u; _status=0;}
  [B]template <class U>
  Foo<typename Promote<T,U>::Result> operator+<>(const Foo<T>& lhs, const Foo<U>& rhs);[/B]

 private:
  T _data;
  int _status;
};

[B]
//operator+() definition
template <class T, class U> Foo<typename Promote<T,U>::Result> operator+(const Foo<T>& lhs, const Foo<U>& rhs)
{
 Foo<typeof(lhs._data+rhs._data)> result;
 result._data=lhs._data+rhs._data;
 result._status=lhs._status|rhs._status;
 return result;
}[/B]

One of the problems I'm running into may be compiler related: in the class declaration of the friend function (line 25 above), I get an error:

error: invalid use of template-id `operator+<>' in declaration of primary template

...which confuses me, because I thought this was the correct way to declare friend templates as per the C++ FAQ and the GCC FAQ. But, those examples didn't take multiple template parameters, so maybe something changes.

Another problem that I think I will run into is that I don't know if the friendship mechanism will allow Foo<T>._data and Foo<U>._data to be accessible in the operator+() function. That is my hope, even though Foo<float> and Foo<double> are distinct types. If not, how do I allow such a thing without using a public accessor?

Basically the purpose of this container is to couple a status with a POD. We need a way in our system to flag variables as invalid, and for that status to cascade to any variables that are results of calculations of that invalid variable. We'd still like to treat these variable containers like POD, though, except for special cases during comparisons and extraction of the actual data it contains (needs to be valid, or else it throws... hence public accessor can't be used in operators). The above class is a slight over-simplification, but illustrates the problem.

I'm not sure this is the best way to achieve what I want, or if it's even possible within C++, but I couldn't find any generic containers out there that would allow POD-style operators between containers of compatible PODs. I'm open to suggestions for alternate methods/containers/idioms!

My previous incarnation of this class basically had a byte array, an enumerated identifier that specified the POD type to emulate, a lot of hand-coded operators with switch() statements and conversion constructors. The run-time overhead started to get significant, so I'm trying to re-work as much of the type stuff into compile-time as possible.

OS: GNU/linux
Compiler: gcc 3.4.6

Thanks in advance for any insight!

OK, I found a way to skirt the friend function issue altogether. It's tricky, and I like it... ready :)?

Foo now looks like this:

template <class T>
class Foo
{
 public:
  Foo() : _data(), _status(1) { }
[B]  Foo(T) : _data(T, int status=0), _status(status) { } //skirts an issue accessing protected members in the result temp in operator+[/B]
  ~Foo() { }

  template<class U>
  Foo<T>& operator=(const U& u) {_data=u; _status=0; return *this;}

 [B]protected:[/B]
  T _data;
  int _status;
};

No friend declarations. Global operator+ overload looks like this:

template<class T, class U>
Foo<typename Promote<T,U>::Result> operator+(const Foo<T>& lhs, const Foo<U>& rhs)
{
 class FooSum : public Foo<T>, public Foo<U>
 {
  FooSum(const Foo<T>& t, const Foo<U>& u) : Foo<T>(t), Foo<U>(u) { }
  Foo<typename Promote<T,U>::Result> GetSum()
  {
   return Foo<typename Promote<T,U>::Result> (Foo<T>::_data+Foo<U>::_data, Foo<T>::_status|Foo<U>::_status);
  }
 };
 FooSum fs(lhs,rhs);
 return fs.GetSum();
}

Similar for the case where T=U, only with a single inheritance accessor class to avoid inheriting off of the same base twice.

So, that fixes my Foo<float>+Foo< double> case. What it does not fix, however, is my Foo<T>+POD case. In fact, declaring something like this:

template <class T, class U>
Foo<typename Promote<T,U>::Result> operator+(const Foo<T>& lhs, const U rhs);

BREAKS the Foo<T>+Foo<U> case that I had just solved, because it tries to instantiate that function with U=Foo<U> instead of instantiating the one where Foo<U> is an explicit parameter. This is, perhaps, a problem for another thread, though, as it no longer concerns the title...

[weaknessforcats]

Skirting a problem doesn't solve it.

First: This is not how you declare a firend function:

template <class T>
class Foo
{

template <class T, class U>
Foo<typename Promote<T,U>::R esult> operator+<>(con st Foo<T>& lhs, const Foo<U>& rhs);

etc...

You want to overload operator+() so you use parentheses and not angle brackets. Plus you need to add the friend declaration. This is correct:
[code=cpp]
template <class T, U>
class Foo
{

template <class T, class U>
friend Foo<typename Promote<T,U>::R esult> operator+(const Foo<T>& lhs, const Foo<U>& rhs);

etc...
[/code]

Unfortunately, this is a template so you can't use a function prototype. So this won't compile.

Now you need to make a decision: Does this operator+() template work for all types or just one set of types? If the answer is yes, then you can use an expanded template:
[code=cpp]
template <class T,U>
class Foo
{

friend Foo<Promote<int ,double>::Resul t> operator+(const Foo<int>& lhs, const Foo<double>& rhs);
[/code]

This is called a bounded friend template.

If you decide that all types will work, then you need to define the friend inside the class template:
[code=cpp]
template <class T,U>
class Foo
{

template <class T, class U>
friend Foo<typename Promote<T,U>::R esult> operator+(const Foo<T>& lhs, const Foo<U>& rhs)
{
Foo<typeof(lhs. _data+rhs._data )> result;
result._data=lh s._data+rhs._da ta;
result._status= lhs._status|rhs ._status;
return result;
}

etc...
[/code]

This is called an unbounded friend template.

Check out C++ Primer Plus 5th ed. by Stephen Prata page pp 773-777.

[rtalbot]

Skirting a problem doesn't solve it.

First: This is not how you declare a firend function:


You want to overload operator+() so you use parentheses and not angle brackets. Plus you need to add the friend declaration. This is correct:
[code=cpp]
template <class T, U>
class Foo
{

template <class T, class U>
friend Foo<typename Promote<T,U>::R esult> operator+(const Foo<T>& lhs, const Foo<U>& rhs);

etc...
[/code]

Unfortunately, this is a template so you can't use a function prototype. So this won't compile.

Now you need to make a decision: Does this operator+() template work for all types or just one set of types? If the answer is yes, then you can use an expanded template:
[code=cpp]
template <class T,U>
class Foo
{

friend Foo<Promote<int ,double>::Resul t> operator+(const Foo<int>& lhs, const Foo<double>& rhs);
[/code]

This is called a bounded friend template.

If you decide that all types will work, then you need to define the friend inside the class template:
[code=cpp]
template <class T,U>
class Foo
{

template <class T, class U>
friend Foo<typename Promote<T,U>::R esult> operator+(const Foo<T>& lhs, const Foo<U>& rhs)
{
Foo<typeof(lhs. _data+rhs._data )> result;
result._data=lh s._data+rhs._da ta;
result._status= lhs._status|rhs ._status;
return result;
}

etc...
[/code]

This is called an unbounded friend template.

Check out C++ Primer Plus 5th ed. by Stephen Prata page pp 773-777.

Whoops, I knew I should have cut&pasted the code, but it's sitting on an embedded target... I actually did have the friend keyword in the declaration. Thanks for pointing that out.

As far as the empty <> goes, I was following the directions found here for making template friend functions:

http://www.parashift.com/c++-faq-lite/templates.html#faq-35.16

...since I was getting the linker errors mentioned therein.

I originally tried the unbounded friend example that you wrote above, but was informed by my compiler that Foo<U>'s members were private in that context. I'm assuming this is because the compiler assumed friend operator+ was declared a friend of Foo<T>, and not Foo<U>. If I invoked that operator with T=U, all was well, but instantions of Foo with different types would result in error. Is this incorrect behavior on my compiler's part? Is there a way to generalize a friend so that it can access two different class instantiations within the same function body?

Thanks for your response!

[weaknessforcats]

Is there a way to generalize a friend so that it can access two different class instantiations within the same function body?

Yes. But these are the bounded friends. You must know the types of the instantiations:

[code=cpp]
template <class T,U>
class Foo
{

friend Foo<Promote<int ,double>::Resul t> operator+(const Foo<int>& lhs,
friend Foo<Promote<str ing,int>::Resul t> operator+(const Foo<string>& lhs, const Foo<int>& rhs);
etc...

[/code]

I'm just making up types, so please excuse me.

The tempate<> syntax is for explicit specialization.

This syntax tells the compiler to not use the template for the types shown because you have already written the function explicitly.

[rtalbot]

Yes. But these are the bounded friends. You must know the types of the instantiations:

[code=cpp]
template <class T,U>
class Foo
{

friend Foo<Promote<int ,double>::Resul t> operator+(const Foo<int>& lhs,
friend Foo<Promote<str ing,int>::Resul t> operator+(const Foo<string>& lhs, const Foo<int>& rhs);
etc...

[/code]

That certainly works, although it seems rather tedious, and sort of defeats the purpose of templating Foo. I guess what I meant was, is there a way here to indicate to the compiler that given template parameters T and U, operator+ is friend to both Foo<T> and Foo<U>, in a single declaration? I think the answer is no, and as I further ponder how the compiler architects would accomplish such a thing (since a specialization of Foo might not even have the same data members), I become more convinced that this is so.

The tempate<> syntax is for explicit specialization.

This syntax tells the compiler to not use the template for the types shown because you have already written the function explicitly.

I understand the use of the empty angle brackets in that context. I was surprised to see them used this way, myself, but according to the C++ FAQ, the GCC FAQ, and GCC's handy (and specific!) compiler warnings, that is the correct syntax for declaring a friend function to a template class, that is itself a template function. Otherwise, the compiler won't generate the code for the friend function (because it doesn't think it is a template), and you are stuck with a linker error. Seems a bit backwards from the normal use of the <> with templates. Note, however, that defining the friend function inside the class gets rid of the problem, as you showed above in the unbounded template example. Although, I still received an error about the right-hand-side's data members being private, so I'm still out of luck there.

[weaknessforcats]

I finally tried to compile your code and got various errors. The big one is that Foo requires two types so Foo<T> won't compile.

I had to:
[code=cpp]
template <class T,class U>
class Foo
{
public:

template <class T, class U>
friend Foo<Promote<T, U>, T > operator+(const Foo<T,U>& lhs,
const Foo<T,U>& rhs)
{

}
};
[/code]

What am I missing?

[rtalbot]

I finally tried to compile your code and got various errors. The big one is that Foo requires two types so Foo<T> won't compile.

I had to:
[code=cpp]
template <class T,class U>
class Foo
{
public:

template <class T, class U>
friend Foo<Promote<T, U>, T > operator+(const Foo<T,U>& lhs,
const Foo<T,U>& rhs)
{

}
};
[/code]

What am I missing?

Ah! Check back to my original post. Foo actually only takes one template parameter, T, being the type contained. The operator+, however, will have two template parameters when adding two Foos templated on different types.

This compiles and works for me (gcc 3.4.6):
[code=cpp]
#include <iostream>
#include <string>
using namespace std;

template <class T, class U>
struct Promote
{
const static T t;
const static U u;
typedef typeof(t+u) Result;
};

template <class T>
class Foo
{
public:
typedef T PODType;

Foo() : _data(), _status(1) { }
Foo(T data, int status) : _data(data), _status(status) { }
Foo(T data) : _data(data), _status(0) { }
~Foo() { }

T GetData() {if(_status) throw; return _data;}

protected:
T _data;
int _status;
};

template <class T, class U>
Foo<typename Promote<T,U>::R esult> operator+ (const Foo<T>& lhs, const Foo<U>& rhs)
{
class FooSum : public Foo<T>, public Foo<U>
{
public:
FooSum(const Foo<T>& t, const Foo<U>& u)
: Foo<T>(t), Foo<U>(u)
{ }
Foo<typename Promote<T,U>::R esult> GetSum()
{
return Foo<typename Promote<T,U>::R esult>
(Foo<T>::_data+ Foo<U>::_data,
Foo<T>::_status |Foo<U>::_statu s);
}
};

FooSum fs(lhs,rhs);
return fs.GetSum();
}

template <class T>
Foo<T> operator+ (const Foo<T>& lhs, const Foo<T>& rhs)
{
class FooAccessor : public Foo<T>
{
public:
FooAccessor(con st Foo<T>& t)
: Foo<T>(t)
{ }
T GetData() {return Foo<T>::_data;}
int GetStatus() {return Foo<T>::_status ;}
};

FooAccessor faLHS(lhs);
FooAccessor faRHS(rhs);

return Foo<T>(faLHS.Ge tData()+faRHS.G etData(),faLHS. GetStatus()|faR HS.GetStatus()) ;
}

int main()
{
Foo<float> fooFloat1(10.3) ;
Foo<float> fooFloat2(27.4) ;
Foo<double> fooDouble1(43.2 );

float f = (fooFloat1+fooF loat2).GetData( );

cout << "f is:" << f << endl;

f = (fooFloat1 + fooDouble1 + fooFloat2).GetD ata();
cout << "f is:" << f << endl;

return EXIT_SUCCESS;
}
[/code]

Obvious things I don't like are having to construct extra objects inside operator+, but I could not get the friend functions to work. I am sure there is a better way, but my template kung-fu just isn't that strong yet :).

I really appreciate your time and patience exploring this problem; I've exhausted the human resources here as well as the books Modern C++ Design by Andrei Alexandrescu and C++ Common Knowledge by Stephen Dewhurst looking for a way to implement what I thought would be a simple container. I have either way underestimated the problem or way overestimated my intelligence :).

[weaknessforcats]

Ah! Check back to my original post. Foo actually only takes one template parameter, T,

I missed that. Obviously, I introduced an error and confused myself. Sorry.

[rtalbot]

Just in case anybody has a similar situation or was curious, this can be done with friend functions.

With Foo declared as above, add the friend declaration:

[CODE=cpp]template <class T>
class Foo
{
public:
...
typedef T ContainedType
...
template <class U, class V>
friend
Foo<typename Promote<typenam e U::ContainedTyp e,typename V::ContainedTyp e>::Result>
operator+(const U& lhs, const V& rhs);
...
};

template <class U, class V>
Foo<typename Promote<typenam e U::ContainedTyp e,typename V::ContainedTyp e>::Result>
operator+(const U& lhs, const V& rhs)
{
return Foo<typename Promote<typenam e U::ContainedTyp e,typename V::ContainedTyp e>::Result>(lhs ._data+rhs._dat a,lhs._status|r hs._status);
}[/CODE]


That seems to work fine for adding Foo<T> to Foo<U>.

The trick was to use template parameters to represent whole containers themselves, not the types contained, I suppose. Note that summing intrinsics with containers will require overloads of operator+ and some manipulation of the overload set to work properly (I used boost::lazy_ena ble_if to help the compiler along, otherwise Promote busts).