Class has no member of a friend method - c++

Question

im having trouble with this friend method upon calling the Union method an error of "class Set has no member named 'Union'. The program keep throwing an error regarding that Union function. I have no clue why does this friend declaration not work.
This is my Set class it uses a custom vector class, which is not relevant.
ifndef SET_H
#define SET_H
#include "myvector.h"
template <class T>
class Set
{
public:
Set();
virtual ~Set();
MyVector<T> & GetData();
void Push_back(const T & element);
void print();
friend void Union(const Set<T> &set1, const Set<T> &set2, Set<T> &set3);
private:
MyVector<T> data;
};
template <class T>
Set<T>::Set()
{
}
template <class T>
Set<T>::~Set()
{
}
template <class T>
MyVector<T> & Set<T>::GetData()
{
return data;
}
template <class T>
void Set<T>::Push_back(const T & element)
{
data.push_back(element);
}
template <class T>
void Set<T>::print()
{
data.print();
}
template <class T>
void Union(const Set<T> &set1, const Set<T> &set2, Set<T> &set3)
{
int i = 0, j = 0;
while(i<set1.data.count && j<set2.data.count)
{
if(set1.data[i] == set2.data[j])
{
set3.Push_back(set1.data[i]);
i++;
j++;
}
else if(set1.data[i] < set2.data[j])
{
set3.Push_back(set1.data[i]);
i++;
}
else
{
set3.Push_back(set2.data[j]);
j++;
}
}
while(i<set1.data.count)
{
set3.Push_back(set1.data[i]);
i++;
}
while(i<set2.data.count)
{
set3.Push_back(set2.data[j]);
j++;
}
}
This is my main
#include <iostream>
#include "set.h"
int main()
{
Set<int> set1;
Set<int> set2;
Set<int> set3;
set1.Push_back(1);
set1.Push_back(2);
set1.Push_back(4);
set1.Push_back(1);
set2.Push_back(3);
set2.Push_back(5);
cout << "printing set 1\n";
set1.print();
cout << "printing set 2\n";
set2.print();
set3.Union(set1,set2,set3);
cout << "printing set 3 (union)\n";
set3.print();
return 0;
}

Answer 1

A free union function would normally take two arguments and return the union instead of having to instantiate the container that is supposed to receive the result and pass that as a parameter to the function.
You can still do it that way, but you'll need to declare the friend function as a function template.
In these examples, I'm returning the resulting Set<T> instead. Rewriting it to take set3 as an argument instead is left as an exercice:
template <class T>
class Set
{
public:
template<typename U> // make this a declaration of a function template
friend Set<U> Union(const Set<U>& set1, const Set<U>& set2);
};
template<typename T> // define it:
Set<T> Union(const Set<T>& set1, const Set<T>& set2) {
Set<T> set3;
// fill set3
return set3;
}
Or easier: Define the friend function in your class definition directly:
template <class T>
class Set
{
public:
// Set will here be Set<T> automatically:
friend Set Union(const Set& set1, const Set& set2) {
Set set3;
// fill set3
return set3;
}
};
In main:
Set<int> set3 = Union(set1, set2);