compilation error using ofstream

[aaragon]

Hello, does anyone have a clue about this error? and how to solve it?
It seems to be trivial to me, but not for the compiler. I'm using g++
4.2 on an Ubuntu Linux system:

// main()
....
std::ofstream fout;
fout.open("hell o.out");
fout<<setfill('-')<<setw(20)<<"-"<<setfill( ' ')<<endl;
fout<<"hello "; // this is line 139
....

main.cxx:89: instantiated from here
main.cxx:139: error: ISO C++ says that these are ambiguous, even
though the worst conversion for the first is better than the worst
conversion for the second:
/usr/lib/gcc/i486-linux-gnu/4.1.2/../../../../include/c++/4.1.2/bits/
ostream.tcc:735 : note: candidate 1: std::basic_ostr eam<char, _Traits>&
std::operator<< (std::basic_ost ream<char, _Traits>&, const char*) [with
_Traits = std::char_trait s<char>]
Domain.h:507: note: candidate 2: o& operator<<(o&, const Domain&)
[with o = std::ofstream]
make: *** [main.o] Error 1

Thank you all!

a²

[Victor Bazarov]

aaragon wrote:

Hello, does anyone have a clue about this error? and how to solve it?
It seems to be trivial to me, but not for the compiler. I'm using g++
4.2 on an Ubuntu Linux system:

// main()
...
std::ofstream fout;
fout.open("hell o.out");
fout<<setfill('-')<<setw(20)<<"-"<<setfill( ' ')<<endl;
fout<<"hello "; // this is line 139
...

main.cxx:89: instantiated from here
main.cxx:139: error: ISO C++ says that these are ambiguous, even
though the worst conversion for the first is better than the worst
conversion for the second:
/usr/lib/gcc/i486-linux-gnu/4.1.2/../../../../include/c++/4.1.2/bits/
ostream.tcc:735 : note: candidate 1: std::basic_ostr eam<char, _Traits>&
std::operator<< (std::basic_ost ream<char, _Traits>&, const char*) [with
_Traits = std::char_trait s<char>]
Domain.h:507: note: candidate 2: o& operator<<(o&, const Domain&)
[with o = std::ofstream]
make: *** [main.o] Error 1

I don't see any "Domain.h" or types called 'Domain' in your code.

V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask

[aaragon]

On Sep 26, 2:41 pm, "Victor Bazarov" <v.Abaza...@com Acast.netwrote:

aaragon wrote:

Hello, does anyone have a clue about this error? and how to solve it?
It seems to be trivial to me, but not for the compiler. I'm using g++
4.2 on an Ubuntu Linux system:

// main()
...
std::ofstream fout;
fout.open("hell o.out");
fout<<setfill('-')<<setw(20)<<"-"<<setfill( ' ')<<endl;
fout<<"hello "; // this is line 139
...

main.cxx:89: instantiated from here
main.cxx:139: error: ISO C++ says that these are ambiguous, even
though the worst conversion for the first is better than the worst
conversion for the second:
/usr/lib/gcc/i486-linux-gnu/4.1.2/../../../../include/c++/4.1.2/bits/
ostream.tcc:735 : note: candidate 1: std::basic_ostr eam<char, _Traits>&
std::operator<< (std::basic_ost ream<char, _Traits>&, const char*) [with
_Traits = std::char_trait s<char>]
Domain.h:507: note: candidate 2: o& operator<<(o&, const Domain&)
[with o = std::ofstream]
make: *** [main.o] Error 1

I don't see any "Domain.h" or types called 'Domain' in your code.

V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask

Well, I overloaded operator<< to produce the output of a class that I
designed. But shouldn't the compiler deduct this from the type being
passed to operator<<???? Why is it the call ambiguous????

[martyw]

aaragon wrote:

Hello, does anyone have a clue about this error? and how to solve it?
It seems to be trivial to me, but not for the compiler. I'm using g++
4.2 on an Ubuntu Linux system:

// main()
...
std::ofstream fout;
fout.open("hell o.out");
fout<<setfill('-')<<setw(20)<<"-"<<setfill( ' ')<<endl;
fout<<"hello "; // this is line 139
...

main.cxx:89: instantiated from here
main.cxx:139: error: ISO C++ says that these are ambiguous, even
though the worst conversion for the first is better than the worst
conversion for the second:
/usr/lib/gcc/i486-linux-gnu/4.1.2/../../../../include/c++/4.1.2/bits/
ostream.tcc:735 : note: candidate 1: std::basic_ostr eam<char, _Traits>&
std::operator<< (std::basic_ost ream<char, _Traits>&, const char*) [with
_Traits = std::char_trait s<char>]
Domain.h:507: note: candidate 2: o& operator<<(o&, const Domain&)
[with o = std::ofstream]
make: *** [main.o] Error 1

Thank you all!

a²

a minimal version of your program compiles and creates a file contianing
'hello ' after running:

#include <fstream>

int main()
{
std::ofstream fout;
fout.open("hell o.out");
fout<<"hello ";
fout.close();
return 0;
}

did you include the first line in your code?

[Kai-Uwe Bux]

aaragon wrote:

On Sep 26, 2:41 pm, "Victor Bazarov" <v.Abaza...@com Acast.netwrote:

>aaragon wrote:

Hello, does anyone have a clue about this error? and how to solve it?
It seems to be trivial to me, but not for the compiler. I'm using g++
4.2 on an Ubuntu Linux system:

// main()
...
std::ofstream fout;
fout.open("hell o.out");
fout<<setfill('-')<<setw(20)<<"-"<<setfill( ' ')<<endl;
fout<<"hello "; // this is line 139
...

main.cxx:89: instantiated from here
main.cxx:139: error: ISO C++ says that these are ambiguous, even
though the worst conversion for the first is better than the worst
conversion for the second:
/usr/lib/gcc/i486-linux-gnu/4.1.2/../../../../include/c++/4.1.2/bits/
ostream.tcc:735 : note: candidate 1: std::basic_ostr eam<char, _Traits>&
std::operator<< (std::basic_ost ream<char, _Traits>&, const char*) [with
_Traits = std::char_trait s<char>]
Domain.h:507: note: candidate 2: o& operator<<(o&, const Domain&)
[with o = std::ofstream]
make: *** [main.o] Error 1

I don't see any "Domain.h" or types called 'Domain' in your code.

V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask

Well, I overloaded operator<< to produce the output of a class that I
designed. But shouldn't the compiler deduct this from the type being
passed to operator<<???? Why is it the call ambiguous????

How are we supposed to know? Please, post a _complete_ (but minimal) program
that exhibits the problem (see the FAQ on how-to-post).
Best

Kai-Uwe Bux

[Jim Langston]

"aaragon" <al************ **@gmail.comwro te in message
news:11******** **************@ 22g2000hsm.goog legroups.com...

On Sep 26, 2:41 pm, "Victor Bazarov" <v.Abaza...@com Acast.netwrote:

>aaragon wrote:

Hello, does anyone have a clue about this error? and how to solve it?
It seems to be trivial to me, but not for the compiler. I'm using g++
4.2 on an Ubuntu Linux system:

// main()
...
std::ofstream fout;
fout.open("hell o.out");
fout<<setfill('-')<<setw(20)<<"-"<<setfill( ' ')<<endl;
fout<<"hello "; // this is line 139
...

main.cxx:89: instantiated from here
main.cxx:139: error: ISO C++ says that these are ambiguous, even
though the worst conversion for the first is better than the worst
conversion for the second:
/usr/lib/gcc/i486-linux-gnu/4.1.2/../../../../include/c++/4.1.2/bits/
ostream.tcc:735 : note: candidate 1: std::basic_ostr eam<char, _Traits>&
std::operator<< (std::basic_ost ream<char, _Traits>&, const char*) [with
_Traits = std::char_trait s<char>]
Domain.h:507: note: candidate 2: o& operator<<(o&, const Domain&)
[with o = std::ofstream]
make: *** [main.o] Error 1

I don't see any "Domain.h" or types called 'Domain' in your code.

V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask

Well, I overloaded operator<< to produce the output of a class that I
designed. But shouldn't the compiler deduct this from the type being
passed to operator<<???? Why is it the call ambiguous????

Does Domain perhaps accept a char* as a constructor?

[aaragon]

On Sep 26, 3:14 pm, "Jim Langston" <tazmas...@rock etmail.comwrote :

"aaragon" <alejandro.ara. [e-mail] te in message

news:11******** **************@ 22g2000hsm.goog legroups.com...

On Sep 26, 2:41 pm, "Victor Bazarov" <v.Abaza...@com Acast.netwrote:

aaragon wrote:
Hello, does anyone have a clue about this error? and how to solve it?
It seems to be trivial to me, but not for the compiler. I'm using g++
4.2 on an Ubuntu Linux system:

// main()
...
std::ofstream fout;
fout.open("hell o.out");
fout<<setfill('-')<<setw(20)<<"-"<<setfill( ' ')<<endl;
fout<<"hello "; // this is line 139
...

main.cxx:89: instantiated from here
main.cxx:139: error: ISO C++ says that these are ambiguous, even
though the worst conversion for the first is better than the worst
conversion for the second:
/usr/lib/gcc/i486-linux-gnu/4.1.2/../../../../include/c++/4.1.2/bits/
ostream.tcc:735 : note: candidate 1: std::basic_ostr eam<char, _Traits>&
std::operator<< (std::basic_ost ream<char, _Traits>&, const char*) [with
_Traits = std::char_trait s<char>]
Domain.h:507: note: candidate 2: o& operator<<(o&, const Domain&)
[with o = std::ofstream]
make: *** [main.o] Error 1

I don't see any "Domain.h" or types called 'Domain' in your code.

V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask

Well, I overloaded operator<< to produce the output of a class that I
designed. But shouldn't the compiler deduct this from the type being
passed to operator<<???? Why is it the call ambiguous????

Does Domain perhaps accept a char* as a constructor?

Yes it does!!! The domain class can be created with a char* that I
pass (the name of a file). Why is this happening then?

[Jim Langston]

"aaragon" <al************ **@gmail.comwro te in message
news:11******** *************@2 2g2000hsm.googl egroups.com...

On Sep 26, 3:14 pm, "Jim Langston" <tazmas...@rock etmail.comwrote :

>"aaragon" <alejandro.ara. [e-mail] te in message

news:11******* *************** @22g2000hsm.goo glegroups.com.. .

On Sep 26, 2:41 pm, "Victor Bazarov" <v.Abaza...@com Acast.netwrote:
aaragon wrote:
Hello, does anyone have a clue about this error? and how to solve
it?
It seems to be trivial to me, but not for the compiler. I'm using
g++
4.2 on an Ubuntu Linux system:

// main()
...
std::ofstream fout;
fout.open("hell o.out");
fout<<setfill('-')<<setw(20)<<"-"<<setfill( ' ')<<endl;
fout<<"hello "; // this is line 139
...

main.cxx:89: instantiated from here
main.cxx:139: error: ISO C++ says that these are ambiguous, even
though the worst conversion for the first is better than the worst
conversion for the second:
/usr/lib/gcc/i486-linux-gnu/4.1.2/../../../../include/c++/4.1.2/bits/
ostream.tcc:735 : note: candidate 1: std::basic_ostr eam<char,
_Traits>&
std::operator<< (std::basic_ost ream<char, _Traits>&, const char*)
[with
_Traits = std::char_trait s<char>]
Domain.h:507: note: candidate 2: o& operator<<(o&, const Domain&)
[with o = std::ofstream]
make: *** [main.o] Error 1

>I don't see any "Domain.h" or types called 'Domain' in your code.

>V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask

Well, I overloaded operator<< to produce the output of a class that I
designed. But shouldn't the compiler deduct this from the type being
passed to operator<<???? Why is it the call ambiguous????

Does Domain perhaps accept a char* as a constructor?

Yes it does!!! The domain class can be created with a char* that I
pass (the name of a file). Why is this happening then?

I'm not actually positive, because I can't reproduce it in test, but what it
seems is that the compiler sees you are sending a char* to an ofstream. It
looks at sees that you have a Domain constructor that accepts a char* and
has an output to an ofstream. I wouldn't think that the compiler would pick
that, but it depends on how Domain is set up. Can you post the appropriate
Domain class? At least anything having to do with the constructor and any
operator<< overrides and such.

[James Kanze]

On Sep 26, 9:36 pm, aaragon <alejandro.ara. [e-mail] te:

Hello, does anyone have a clue about this error? and how to solve it?
It seems to be trivial to me, but not for the compiler. I'm using g++
4.2 on an Ubuntu Linux system:

// main()
...
std::ofstream fout;
fout.open("hell o.out");
fout<<setfill('-')<<setw(20)<<"-"<<setfill( ' ')<<endl;
fout<<"hello "; // this is line 139
...

main.cxx:89: instantiated from here
main.cxx:139: error: ISO C++ says that these are ambiguous, even
though the worst conversion for the first is better than the worst
conversion for the second:
/usr/lib/gcc/i486-linux-gnu/4.1.2/../../../../include/c++/4.1.2/bits/
ostream.tcc:735 : note: candidate 1: std::basic_ostr eam<char, _Traits>&
std::operator<< (std::basic_ost ream<char, _Traits>&, const char*) [with
_Traits = std::char_trait s<char>]
Domain.h:507: note: candidate 2: o& operator<<(o&, const Domain&)
[with o = std::ofstream]
make: *** [main.o] Error 1

Apparently, you have defined function operator<<( ofstream&,
....), and Domain has a constructor which can be called with a
char const*. So the first argument of this function is an exact
match, and thus a better than the operator<<( ostream&, char
const*). The second argument, of course, is a better match for
the first function, so the call is ambiguous.

The obvious question is: why on earth would you define an
operator<< which takes an ofstream, rather than an ostream? If
you define the operator to take an ostream, then both functions
are equally good matches for the first argument, and the fact
that the char const* is a better match for the second means that
it will be chosen.

--
James Kanze (GABI Software) email:ja******* **@gmail.com
Conseils en informatique orientée objet/
Beratung in objektorientier ter Datenverarbeitu ng
9 place Sémard, 78210 St.-Cyr-l'École, France, [phone]

[Joe Greer]

aaragon <al************ **@gmail.comwro te in
news:11******** *************@2 2g2000hsm.googl egroups.com:

>>
Does Domain perhaps accept a char* as a constructor?

Yes it does!!! The domain class can be created with a char* that I
pass (the name of a file). Why is this happening then?

A literal string like "Hello" is actually of type char const [6] and
requires an implicit cast to become a char const * for operator<<.
Unless you have your domain class constructor marked as explicit, the compiler
sees that as an additional way to convert your literal string into something
that operator<< knows how to handle. In other words, both

fout << static_cast<cha r *>("Hello");

and

fout << static_cast<Dom ain>("Hello");

are viable choices and the compiler doesn't know which one you want. Of course,
you would never write like the above, but I was trying to represent it in a way
that would show that to the compiler, both are equally viable, though to your
eyes and mine, the first is the obvious choice. To tell the compiler that the
first is the obvious choice, you should mark the constructor for the Domain as explicit.

Interestingly enough VC8 doesn't see an ambiguity, though it should.

joe