usage of friend operators

[curious2007]

Hello,

I have code for a vector template. However I am having problems with it.
Vector.hpp file starts like this:

template <class V, class I=int, class S=FullArray<V> >
class Vector: public Array<V, I, S>

{...

//Array and FullArray are some other templates that are already constructed.
//The goal of this Vector template is to simply create a template for vector
//classes with some numerical capabilities such as vector addition.

//This is not originally my code, however as far as I can understand + operator
//is overloaded to enable the Vector class some functionalities:
//Adding two vectors of same dimension. And also adding a vector and a scalar
//by adding the scalar to every dimension of the vector. This is beeing done in
//the following way:

// Return the sum of the elements
// Operators
Vector<V, I, S>& operator = (const Vector<V, I, S>& source);

Vector<V, I, S> operator - () const; // Unary minus

// Add v to every element
friend Vector<V, I, S> operator + (const Vector<V, I, S>& v, const V& a);

friend Vector<V, I, S> operator + (const V& a, const Vector<V, I, S>& v);

// Add the elements
Vector<V, I, S> operator + (const Vector<V, I, S>& v) const;

//However when I try to use this template in a main function I get the following:

[Warning] friend declaration `Vector<V, I, S> operator+(const Vector<V, I, S>&, const V&)' declares a non-template function

[Warning] (if this is not what you intended, make sure the function template has already been declared and add <> after the function name here) -Wno-non-template-friend disables this warning


I don't know what to do here. I would really appreciate help. Thanks.

[weaknessforcats]

This code:

// Add v to every element
friend Vector<V, I, S> operator + (const Vector<V, I, S>& v, const V& a);

isn't correct. Vector<V,I,S> is the class itself and it is the first argument meaning it is on the left of the + operator. When a Vector is on the left of the + operator, the compiler will supply the this pointer to the function so you don't need a Vector as the first argument.

This should not be a friend. It should be a member function:

Vector<V, I, S> operator + (const V& a); 
 

However, if you insist on a friend function, you need to tell the compiler to not use the template for an operator+ with a const Vector& on the left and a const V& on the right. You do this by declaring an explicit specialization just after the template:

template<> Vector<V, I, S> operator + (const Vector<V, I, S>& v, const V& a); 
 

that's what this warning is about:

[Warning] (if this is not what you intended, make sure the function template has already been declared and add <> after the function name here) -Wno-non-template-friend disables this warning

An explicit specialization means you have written a function for this that you want to use instead of the function template.

To be sure I'm clear here, a function template is the template code whereas a template function is the function created by the compiler from a copy of the function template with the placeholder types substituted.

[curious2007]

Hello,

I understand the idea behind replacing:

"friend Vector<V, I, S> operator + (const Vector<V, I, S>& v, const V& a);"

with Vector<V, I, S> operator + (const V& a);"

However, once I do this. I am still getting an error for:

friend Vector<V, I, S> operator + (const V& a, const Vector<V, I, S>& v);

[Warning] friend declaration `Vector<V, I, S> operator+(const V&, const Vector<V, I, S>&)' declares a non-template function

How can I take care of this? Are you suggesting to replace this with

Vector<V, I, S> operator + (const V& a);

Thanks

[weaknessforcats]

friend Vector<V, I, S> operator + (const V& a, const Vector<V, I, S>& v);

For this to be a friend, it has to be a function that is already written.

template <class V, class I=int, class S=FullArray<V> >
class Vector: public Array<V, I, S>
{
  public:
    friend Vector<V, I, S> operator + (const V& a, const Vector<V, I, S>& v);
};
 
 
template <class V, class I, class S >
Vector<V, I, S> operator + (const V& a, const Vector<V, I, S>& v)
{
    //etc
}
 

The code above compiles and links with Visual Studio.NET 2005.

The default types need to be removed as they apply only to class templates.

[curious2007]

is there a way to declare this template function in vector.h file. And then define it in vector.cpp file? Also, you are using Visual Studio.NET 2005. I am using Dev C++. Do you think is this a good compiler?

[weaknessforcats]

is there a way to declare this template function in vector.h file. And then define it in vector.cpp file? Also, you are using Visual Studio.NET 2005. I am using Dev C++. Do you think is this a good compiler?

Not unless your compiler supports export templates. Visual Studio.NET 2005 does not. Nor does any other compiler that I know of. If yours does, please let me know so I can update myself.

As it stands, your template must be at the global level (most likely in a header file).

I am curious why you are writing a Vector instead of using the one in the C++ Standard LIbrary??

[curious2007]

Because this vector class is going to be for numerical purposes only and will include some additional mathematical functionality.

I think we are getting closer to solving this. But I am still having some problems. So I understand that before referring to a friend function we must declare it globally. So I have done that. In vector.h file before the line

template <class V, class I=int, class S=FullArray<V> >
class Vector: public Array<V, I, S>

I have declared and implemented:
template <class V, class I, class S>
Vector<V, I, S> operator + (const V& a, const Vector<V, I, S>& v)
{
...
}


Then I get the following error for this line:

expected constructor, destructor, or type conversion before '<' token
expected `;' before '<' token


Thanks for your help so far.

[weaknessforcats]

Look at my reply #4. That works.

Your friend function uses a Vector argument. Therefore, the friend function must appear after the Vector class definition.

I am still confused abiout your Vector.h and Vector.cpp. Everything must be in Vector.h.

Templates are not code. They are patterns the compiler makes copies of and substitutes types.

[curious2007]

Hello,

I don't understand the problem but when I do it like you do that is first the vector template and then the template function as your #4 code. My dev c++ compiler seems to be ignoring the template function implementation. All of these are in vector.h. I get the same old errors:

[Warning] friend declaration `Vector<V, I, S> operator+(const V&, const Vector<V, I, S>&)' declares a non-template function

[Warning] (if this is not what you intended, make sure the function template has already been declared and add <> after the function name here) -Wno-non-template-friend disables this warning

[weaknessforcats]

OK. Time to see your vector.h. I will compile it with Visual Studio.NET 2005 and see what happens.

[curious2007]

Ok, from the following link:

http://web.mit.edu/~tulumbeg/www/

you can download vector.h and vector.cpp. Notice that these are the original code so function templates are defined in vector.cpp. Though as I have told you, moving those to vector.h did not help. Also, for your reference you can find all the files under this project at the above link. Thank you.

[phiefer3]

Ok, from the following link:

http://web.mit.edu/~tulumbeg/www/

you can download vector.h and vector.cpp. Notice that these are the original code so function templates are defined in vector.cpp. Though as I have told you, moving those to vector.h did not help. Also, for your reference you can find all the files under this project at the above link. Thank you.

I'm not sure if weaknessforcats realizes it, but he helped me out with a similar problem I had with a template that included a friend function, but he hasn't given the same answer here.

What he told me, and it worked, was that you need to mark the friend function as a template inside the class template itself.

so the code that he posted before:

template <class V, class I=int, class S=FullArray<V> >
class Vector: public Array<V, I, S>
{
public:
    friend Vector<V, I, S> operator + (const V& a, const Vector<V, I, S>& v);
}; 
 
 
template <class V, class I, class S >
Vector<V, I, S> operator + (const V& a, const Vector<V, I, S>& v)
{
    //etc
}

should be:

template <class V, class I=int, class S=FullArray<V> >
class Vector: public Array<V, I, S>
{
public:
    template<class V, class I, class S>
    friend Vector<V, I, S> operator + (const V& a, const Vector<V, I, S>& v);
}; 
 
 
template <class V, class I, class S >
Vector<V, I, S> operator + (const V& a, const Vector<V, I, S>& v)
{
    //etc
}

line 5 is the key line. Try that. I'm not entirely familiar with templates with more than one parameter, but I think it should work.

[curious2007]

OK, thanks this seems to work. Even though I still have some problems with the overall code. I will create another post for that.