Overloading << generates problems

[pmatos]

Hi all,

I have the following code:
class test {
public:
test(const std::string *n) : name(n) {}
virtual ~test() {}

const std::string * getName() { return name; }

protected:
const std::string * name; ///< Variable name.

private:
};

std::ostream& operator<<(std::ostream& s, const test& v) {
return s << v.getName();
}

And I get when I try to compile:
common/test.cc: In function `std::ostream& operator<<(std::ostream&,
const test&)':
common/test.cc:5: error: no matching function for call to `test
::getName() const'
common/test.h:14: error: candidates are: const std::string*
test::getName() <near match>
make: *** [test.o] Error 1

Any ideas on where the problem is?

Cheers,

Paulo Matos

[Malte Starostik]

pmatos schrieb:

Hi all,

I have the following code:
class test {
public:
test(const std::string *n) : name(n) {}
virtual ~test() {}

const std::string * getName() { return name; } const std::string * getName() const { return name; }
protected:
const std::string * name; ///< Variable name.

private:
};

std::ostream& operator<<(std::ostream& s, const test& v) {
return s << v.getName();
}

And I get when I try to compile:
common/test.cc: In function `std::ostream& operator<<(std::ostream&,
const test&)':
common/test.cc:5: error: no matching function for call to `test
::getName() const'
common/test.h:14: error: candidates are: const std::string*
test::getName() <near match>
make: *** [test.o] Error 1

Any ideas on where the problem is?

v is a const test&, so test::getName() needs to be const (should be
anyway, as it doesn't modify *this). Apart from that, are you sure
about the pointers? Shouldn't all those strings be references and
values where appropriate?

Cheers,
Malte

[shabbir]

The problem is you are calling a function getName() with const object
but the declaration of const does not happen to be const in that
fashion probably. Try putting the keyword at the last and that will
solve the current problem.

--
Thanks
Shabbir Bhimani
http://www.go4expert.com

[pmatos]

shabbir wrote:

The problem is you are calling a function getName() with const object
but the declaration of const does not happen to be const in that
fashion probably. Try putting the keyword at the last and that will
solve the current problem.

Thanks all,

However, this solution enforces that through the operator<< overloading
I cannot access the class private parts. Since I'm overloading
operator<< for debuggins purposes only I would like to be able to print
them without getters for all of them. What's the best solution in this
situation? Having a print() method and then calling print() from the
operator<< overloading?

Cheers,

Paulo Matos
--
Thanks
Shabbir Bhimani
http://www.go4expert.com

[Malte Starostik]

pmatos schrieb:

Thanks all,

However, this solution enforces that through the operator<< overloading
I cannot access the class private parts. Since I'm overloading
operator<< for debuggins purposes only I would like to be able to print
them without getters for all of them. What's the best solution in this
situation? Having a print() method and then calling print() from the
operator<< overloading?

Either that or the usual way employing friendship. (Below with an
inline operator for brevity. If it's more complex than that, the
definition should be elsewhere):

class Foo
{
public:
Foo( const std::string& name )
: m_name( name ) {}
const std::string& name() const
{ return m_name; }

private:
std::string m_name;
friend void operator <<( std::ostream& s, const Foo& v )
{
return s << v.m_name;
}
};

Cheers,
Malte

[Karl Heinz Buchegger]

pmatos wrote:

shabbir wrote:

The problem is you are calling a function getName() with const object
but the declaration of const does not happen to be const in that
fashion probably. Try putting the keyword at the last and that will
solve the current problem.

Thanks all,

However, this solution enforces that through the operator<< overloading
I cannot access the class private parts. Since I'm overloading
operator<< for debuggins purposes only I would like to be able to print
them without getters for all of them. What's the best solution in this
situation? Having a print() method and then calling print() from the
operator<< overloading?

make the operator<< a friend of the class:

class test {

friend std::ostream& operator<<(std::ostream& s, const test& v);

public:
test(const std::string *n) : name(n) {}
virtual ~test() {}

const std::string * getName() const { return name; }

protected:
const std::string * name; ///< Variable name.

private:
};

--
Karl Heinz Buchegger
kb******@gascad.at

[pmatos]

Malte Starostik wrote:

class Foo
{
public:
Foo( const std::string& name )
: m_name( name ) {}
const std::string& name() const
{ return m_name; }

private:
std::string m_name;
friend void operator <<( std::ostream& s, const Foo& v )
{
return s << v.m_name;
}
Should return std::ostream& instead of void, right?
Should it be declared private?

Paulo Matos
};

Cheers,
Malte

[Marek Vondrak]

I have the following code:
class test {
public:
test(const std::string *n) : name(n) {}
virtual ~test() {}

const std::string * getName() { return name; }

protected:
const std::string * name; ///< Variable name.

private:
};

std::ostream& operator<<(std::ostream& s, const test& v) {
return s << v.getName();
}

What about to make operator<< a friend of the test class:

class test {
....
friend std::ostream & operator<<( std::ostream & s, const test & v );
};

std::ostream& operator<<(std::ostream& s, const test& v) {
return s << v.name;
}

-- Marek

[Karl Heinz Buchegger]

pmatos wrote:

Malte Starostik wrote:

class Foo
{
public:
Foo( const std::string& name )
: m_name( name ) {}
const std::string& name() const
{ return m_name; }

private:
std::string m_name;
friend void operator <<( std::ostream& s, const Foo& v )
{
return s << v.m_name;
}
Should return std::ostream& instead of void, right?

right
Should it be declared private?

Why?
Don't you think it is a good idea if some code just can do:

int main()
{
Foo test;
cout << test << '\n';
}

No harm is done to the 'test' object by that. So if someone wants to
output it, well, let him do so!

--
Karl Heinz Buchegger
kb******@gascad.at

[Malte Starostik]

pmatos schrieb:

Malte Starostik wrote:

class Foo
{
public:
Foo( const std::string& name )
: m_name( name ) {}
const std::string& name() const
{ return m_name; }

private:
std::string m_name;
friend void operator <<( std::ostream& s, const Foo& v )
{
return s << v.m_name;
}

Should return std::ostream& instead of void, right?
Should it be declared private?

Sorry, of course it should return std::ostream&
It's not private, it's a free-standing inline friend function. More
verbose alternative, non-inline:

class Foo
{
//...
friend std::ostream& operator <<( std::ostream&, const Foo& );
};

std::ostream& operator <<( std::ostream& s, const Foo& v )
{
//...
}

Cheers,
Malte

[BigBrian]

I know this isn't what you were asking, but your code makes me
nervious. Where does the memory for test::name get created? Is it on
the stack? or on the heap? Is the test class responsible for deleting
it or not? What about the default copy constructor that the compiler
generates, it's a shallow copy, is that what you want?...

I realize that this class may be used only for illustration purposes,
but IMHO it has a lot of potential problems.