Inheritance from ostream

[syang8]

Any one can specify the problem of the following code? The compiling
error is on the friend function. If the base class is not inherited
from ostream, or I just remove the friend function from the base
class, the code will compile.

-------------------------------------------------------------------------
#include <iostream>

template<class T> class base;
template<class T> std:stream& operator<< (std:stream&, base<T>&);

template<class T>
class base : public std:stream // Note that if I remove ": public
std:stream" here, the code is fine
{
public:
base(T a):value(a){};
friend std:stream& operator<< <T>(std:stream&, base<T>&); //or I
remove this line, the code is fine
protected:
T value;
};

template<class T>
std:stream& operator<< (std:stream& os, base<T>& b)
{
os << b.value << std::endl;
};
--------------------------------------------------------------------------------------
The compiling errors are:
: error C2143: syntax error : missing ';' before '<'
: see reference to class template instantiation 'base<T>' being
compiled
: error C2433: '<<' : 'friend' not permitted on data declarations
: error C2365: 'operator <<' : redefinition; previous definition was
'function'
: see declaration of 'operator <<'
: error C2530: '<<' : references must be initialized
: error C2238: unexpected token(s) preceding ';'


Thanks for any response!

 

[Cagdas Ozgenc]

friend std:stream& operator<< <T>(std:stream&, base<T>&);

<T> after << is redundant remove it.

 

[John Harrison]

<T> after << is redundant remove it.

No it's not. It's necesary to tell the compiler that the friend function
is a template function.

The error seems to be that the operator<< in the friend declaration is
somehow getting confused with the operator<< in std:stream. Rename
operator<< to some other name and the code compiles.

The posted code fails on at least two different compilers so it doesn't
seem to be a compiler bug. Unfortunately I'm not expert enough to
diagnose the problem, let alone offer a solution.

john

 

[John Harrison]

No it's not. It's necesary to tell the compiler that the friend function
is a template function.

If you remove '<T>' g++ even tells you to put it back in with a warning
message.

john

 

[Charles Bailey]

Any one can specify the problem of the following code? The compiling
error is on the friend function. If the base class is not inherited
from ostream, or I just remove the friend function from the base
class, the code will compile.

-------------------------------------------------------------------------
#include <iostream>

template<class T> class base;
template<class T> std:stream& operator<< (std:stream&, base<T>&);

template<class T>
class base : public std:stream // Note that if I remove ": public
std:stream" here, the code is fine
{
public:
base(T a):value(a){};
friend std:stream& operator<< <T>(std:stream&, base<T>&); //or I
remove this line, the code is fine
protected:
T value;
};

template<class T>
std:stream& operator<< (std:stream& os, base<T>& b)
{
os << b.value << std::endl;
};
--------------------------------------------------------------------------------------

There are many operator<< defined in std:stream which is a base of
this class, but you are trying to befriend a global operator. Try
this:

friend std:stream& :perator<< <T>(std:stream&, base<T>&);

Also, this function needs to return something. Try this:

template<class T>
std:stream& operator<< (std:stream& os, base<T>& b)
{
os << b.value << std::endl;
return os;
}

I removed the [currently incorrect but possibly in the future just]
redundant trailing ';'.

I don't know why you are deriving from std:stream in this case, but
without further evidence to the contrary I wouldn't have thought that
it would be a useful thing to do.

 

[John Harrison]

There are many operator<< defined in std:stream which is a base of
this class, but you are trying to befriend a global operator. Try
this:

friend std:stream& :perator<< <T>(std:stream&, base<T>&);

That is so obvious! Why didn't I think of that.

john

 

[BobR]

Any one can specify the problem of the following code? The compiling
error is on the friend function. If the base class is not inherited
from ostream, or I just remove the friend function from the base
class, the code will compile.
-------------------------------------------------------------------
#include <iostream>
template<class T> class base;
template<class T> std:stream& operator<< (std:stream&, base<T>&);

template<class T>
// Note that if I remove ": public std:stream" here, the code is fine
class base : public std:stream {
public:
base(T a):value(a){};
// or I remove this line, the code is fine
friend std:stream& operator<< <T>(std:stream&, base<T>&);
protected:
T value;
};

template<class T>
std:stream& operator<< (std:stream& os, base<T>& b){
os << b.value << std::endl;
};

----------------------------------------------------------------
There are many operator<< defined in std:stream which is a base of
this class, but you are trying to befriend a global operator. Try
this:

friend std:stream& :perator<< <T>(std:stream&, base<T>&);

Also, this function needs to return something. Try this:

template<class T>
std:stream& operator<< (std:stream& os, base<T>& b){
os << b.value << std::endl;
return os;
}

I removed the [currently incorrect but possibly in the future just]
redundant trailing ';'.

I don't know why you are deriving from std:stream in this case, but
without further evidence to the contrary I wouldn't have thought that
it would be a useful thing to do.

Did you try to instantiate the template?

int main(){
base<int> B1( 777444 );
std::cout<<"base<int> B1( 777444 ); ="<< B1 <<std::endl;
return 0;
}

Did it work?

Try this:

#include <iostream>

class baseSos : public std:stream { public:
baseSos() : value( 0 ){};
protected:
int value;
};

int main(){
baseSos B1;
return 0;
}

Did it compile for you?