Hi,

I have a template class and I want to define an operator << as a friend
function. For each instantiation of the class I want a corresponding
instantiation of operator <<.
The following example fails to compile with g++ version 4.1.2.
I would appreciate it if you could me fix it or point me to a suitable
reference.

Thank you,
Joe Hesse

********************************************
#include <iostream>

// forward declaration
template <typename T>
class Foo;

// forward declaration
template <typename T>
std:stream & operator << (std:stream &, const Foo<T> &);

template <typename T>
class Foo {
private:
T value;
public:
Foo(const T & v) : value(v) {}
friend std:stream & operator << <> (std:stream &, const Foo<T> &);
};

// implement operator <<
template <typename T>
std:stream & operator << (std:stream &o, const Foo<T> &f) {
return o << f.value ;
}

int main() {
Foo<int> fi;
std::cout << fi;

return 0;
}

/* Here are the compiler error messages
Test.cpp: In function int main():
Test.cpp:26: error: no matching function for call to Foo<int>::Foo()
Test.cpp:16: note: candidates are: Foo<T>::Foo(const T&) [with T = int]
Test.cpp:12: note: Foo<int>::Foo(const Foo<int>&)
*/

********************************************

Please forgive me, I have an obvious error. No response is needed from the
newsgroup.

"Joe Hesse" <joe_hesse@actcx.com> wrote in message
news:13lgau67k1b9c6c@corp.supernews.com...
> Hi,
>
> I have a template class and I want to define an operator << as a friend
> function. For each instantiation of the class I want a corresponding
> instantiation of operator <<.
> The following example fails to compile with g++ version 4.1.2.
> I would appreciate it if you could me fix it or point me to a
> suitable reference.
>
> Thank you,
> Joe Hesse
>
> ********************************************
> #include <iostream>
>
> // forward declaration
> template <typename T>
> class Foo;
>
> // forward declaration
> template <typename T>
> std:stream & operator << (std:stream &, const Foo<T> &);
>
> template <typename T>
> class Foo {
> private:
> T value;
> public:
> Foo(const T & v) : value(v) {}
> friend std:stream & operator << <> (std:stream &, const Foo<T> &);
> };
>
> // implement operator <<
> template <typename T>
> std:stream & operator << (std:stream &o, const Foo<T> &f) {
> return o << f.value ;
> }
>
> int main() {
> Foo<int> fi;
> std::cout << fi;
>
> return 0;
> }
>
> /* Here are the compiler error messages
> Test.cpp: In function int main():
> Test.cpp:26: error: no matching function for call to Foo<int>::Foo()
> Test.cpp:16: note: candidates are: Foo<T>::Foo(const T&) [with T = int]
> Test.cpp:12: note: Foo<int>::Foo(const Foo<int>&)
> */
>
> ********************************************
>

On Dec 6, 8:05 pm, "Joe Hesse" <joe_he...@actcx.com> wrote:
> Hi,
>
> I have a template class and I want to define an operator << as a friend
> function. For each instantiation of the class I want a corresponding
> instantiation of operator <<.
> The following example fails to compile with g++ version 4.1.2.
> I would appreciate it if you could me fix it or point me to a suitable
> reference.
>
> Thank you,
> Joe Hesse
>
> ********************************************
> #include <iostream>
>
> // forward declaration
> template <typename T>
> class Foo;
>
> // forward declaration
> template <typename T>
> std:stream & operator << (std:stream &, const Foo<T> &);
>
> template <typename T>
> class Foo {
> private:
> T value;
> public:
> Foo(const T & v) : value(v) {}
> friend std:stream & operator << <> (std:stream &, const Foo<T> &);
>
> };
>
> // implement operator <<
> template <typename T>
> std:stream & operator << (std:stream &o, const Foo<T> &f) {
> return o << f.value ;
>
> }
>
> int main() {
> Foo<int> fi;
> std::cout << fi;
>
> return 0;
>
> }
>
> /* Here are the compiler error messages
> Test.cpp: In function int main():
> Test.cpp:26: error: no matching function for call to Foo<int>::Foo()
> Test.cpp:16: note: candidates are: Foo<T>::Foo(const T&) [with T = int]
> Test.cpp:12: note: Foo<int>::Foo(const Foo<int>&)
> */
>
> ********************************************

Instein says "take it simple, as simple as posible but not simpler".
Why did you not use the simplest imaginable syntax?
I would write:

friend std:stream & operator << (std:stream &, const Foo &);

but this is not what the compiler complaigns about;Please learn to
read:

> Test.cpp:26: error: no matching function for call to Foo<int>::Foo()
> Test.cpp:16: note: candidates are: Foo<T>::Foo(const T&) [with T = int]
> Test.cpp:12: note: Foo<int>::Foo(const Foo<int>&)

Since you have defined a constructor ,C++ will no more automatically
generate a default constructor. this is the errorneous line:

Foo<int> fi;

In order to resolve this add the following inside the braces for
declaration of your template class:

Foo(){};

regards,
FM.

Once you not provide a constructor ,There will be a default
constructor;
When you provide, There will be your provided constructor only;