Qustion on templates

[Ioannis Vranos]

I am experimenting with a template class:


#include <iostream>




template <class Value_type>
class only
{
Value_type m_value;

template<class U> only(U);


public:

typedef Value_type value_type;

typedef Value_type& reference;

only(value_type value): m_value( value ) { }

value_type value() const { return m_value; }

std:stream & operator<<(std:stream &);
};




template <class Value_type>
std:stream & only<Value_type>:perator<<(std:stream &objOstream)
{
objOstream<< m_value;

return objOstream;
}


int main()
{
using namespace std;

only<int> obj= 10;

obj.operator<<(cout); // This works
}


Why cout<< obj; doesn't work? Is it a compiler issue?

 

[Vladyslav Lazarenko]

I am experimenting with a template class:

#include <iostream>

template <class Value_type>
class only
{
        Value_type m_value;

         template<class U> only(U);

        public:

        typedef Value_type value_type;

        typedef Value_type& reference;

        only(value_type value): m_value( value ) { }

        value_type value() const { return m_value; }

         std:stream & operator<<(std:stream &);

};

template <class Value_type>
std:stream & only<Value_type>:perator<<(std:stream &objOstream)
{
        objOstream<< m_value;

        return objOstream;

}

int main()
{
     using namespace std;

     only<int> obj= 10;

     obj.operator<<(cout);  // This works

}

Why cout<< obj; doesn't work? Is it a compiler issue?

Not at all, it is an issue of understanding what and how is being
called.

1) Using "class" in template parameter definition is deprecated.
2) Main function should always return a value.
3) Operator << is std:stream's operator and not an only's template.
Therefore it should be defined as "free" function and not a member of
"only" template.

I am impressed. How can you propose to add something to the C++
standard without understanding of basic features of that language?

 

[Ioannis Vranos]

Not at all, it is an issue of understanding what and how is being
called.

1) Using "class" in template parameter definition is deprecated.

Since when?

2) Main function should always return a value.

Not true in C++98/03.

3) Operator << is std:stream's operator and not an only's template.
Therefore it should be defined as "free" function and not a member of
"only" template.

The truth is that any binary operator, can be defined both as a member function of a class and as a regular
function.

I am impressed. How can you propose to add something to the C++
standard without understanding of basic features of that language?

All people make mistakes, so I will not criticise you for this.

 

[Thomas J. Gritzan]

I am experimenting with a template class:


#include <iostream> [...]
template <class Value_type>
std:stream & only<Value_type>:perator<<(std:stream &objOstream)
{
objOstream<< m_value;

return objOstream;
}


int main()
{
using namespace std;

only<int> obj= 10;

obj.operator<<(cout); // This works
}


Why cout<< obj; doesn't work? Is it a compiler issue?

You have defined the operator to be callable as

obj.operator<<(cout); or as
obj << cout;

If you define a binary member operator, the class, the operator is
defined in, will always be on the left side.

You'ld have to define
std:stream:perator<<(only<Value_type>),
but since you can't redefine std:stream, the only way is to define the
operator<< as free function.

You can define it as friend function inside the class definition, though:

class example
{
// ...

friend std:stream& operator<<(std:stream& os, example const& e)
{
// op<< implementation
}
};

 

[Ioannis Vranos]

Since when?




Not true in C++98/03.





The truth is that any binary operator, can be defined both as a member
function of a class and as a regular function.





All people make mistakes, so I will not criticise you for this.

Check my public transcript here: http://www.brainbench.com

Transcript ID: 2414700

 

[Ioannis Vranos]

Why cout<< obj; doesn't work? Is it a compiler issue?

OK, I had some time to implement templates and had gotten a bit rusty. The mistake is obvious, and yes indeed
obviously this operator<< must be defined as a regular function (friend or not).


The code corrected:


#include <iostream>


template <class Value_type>
class only;


// Implemented as non-friend, because it was not needed.
template <class Value_type>
inline std:stream & operator<<(std:stream &objOstream, const only<Value_type> &obj)
{
using namespace std;

return objOstream<< obj.value();
}


template <class Value_type>
class only
{
Value_type m_value;

template<class U> only(U);


public:

typedef Value_type value_type;

typedef Value_type& reference;

only(value_type value): m_value( value ) { }

value_type value() const { return m_value; }

};



int main()
{
using namespace std;

only<int> obj= 10;

cout<< obj<< endl;
}

 

[red floyd]

OK, I had some time to implement templates and had gotten a bit rusty.
The mistake is obvious, and yes indeed obviously this operator<< must be
defined as a regular function (friend or not).


The code corrected:


#include <iostream>


template <class Value_type>
class only;


// Implemented as non-friend, because it was not needed.
template <class Value_type>
inline std:stream & operator<<(std:stream &objOstream, const
only<Value_type> &obj)
{
using namespace std;

unnecessary. you use nothing from std in this function.