cast of ostream& to and from void*

[Matt]

I am trying to cast an ostream reference to void* and back again. The
code below shows the problem isolated from a more complex program. It
compiles quietly but seg faults upon execution.

// ================================================== =================
#include <iostream>
using namespace std;

void myprint(void *s) {
(ostream&)s << "hello, world" << endl;
}

int main(int argc, char *argv[]){
myprint((void *)cerr);
}
// ================================================== =================

Why can't I cast the ostream reference to and from void*?

[TB]

Matt sade:

I am trying to cast an ostream reference to void* and back again. The
code below shows the problem isolated from a more complex program. It
compiles quietly but seg faults upon execution.

// ================================================== =================
#include <iostream>
using namespace std;

void myprint(void *s) {
(ostream&)s << "hello, world" << endl;
}

int main(int argc, char *argv[]){
myprint((void *)cerr);
}
// ================================================== =================

Why can't I cast the ostream reference to and from void*?

You should stop and think if your design requires casting to void*.

#include <iostream>
using namespace std;

void myprint(void *s) {
*((ostream*)s) << "hello, world" << endl;
}

int main(int argc, char *argv[]){
myprint((void *)&cerr);
}

A _much better_ solution is:

void myprint(ostream& s) {
s << "hello, world" << endl;
}

int main(int argc, char *argv[]){
myprint(cerr);
}

--
TB @ SWEDEN

[roberts.noah]

Matt wrote:

I am trying to cast an ostream reference to void* and back again. The
code below shows the problem isolated from a more complex program. It
compiles quietly but seg faults upon execution.

// ================================================== =================
#include <iostream>
using namespace std;

void myprint(void *s) {
(ostream&)s << "hello, world" << endl;
}

int main(int argc, char *argv[]){
myprint((void *)cerr);
}
// ================================================== =================

Why can't I cast the ostream reference to and from void*?

I can't imagine that being a valid cast but I don't know for sure. One
thing that could help you a lot in figuring out what is going on is to
use C++ casts instead of C casts. C casts just do whatever but C++
casts only do the specified type of cast and some things that you
shouldn't be doing just are not possible with them where the C cast
will just silently compile and then explode on runtime.

[Jim Langston]

"Matt" <th**********@xxyyyzzzz.com> wrote in message
news:Id*****************@news01.roc.ny...

I am trying to cast an ostream reference to void* and back again. The code
below shows the problem isolated from a more complex program. It compiles
quietly but seg faults upon execution.

// ================================================== =================
#include <iostream>
using namespace std;

void myprint(void *s) {
(ostream&)s << "hello, world" << endl;
}

int main(int argc, char *argv[]){
myprint((void *)cerr);
}
// ================================================== =================

Why can't I cast the ostream reference to and from void*?

That's because cerr isn't a pointer in the first place. You're taking an
instance, converting it to a pointer, then trying to convert it to a
reference. As soon as you convert it to a pointer you loose everything. So
try taking the pointer to cerr instead.

This works for me (although I wouldn't do this, this just shows you how to
do what you're trying to do)

#include <iostream>
void myprint(void *s)
{
*((std::ostream*) s) << "hello, world" << std::endl;
}

int main(int argc, char *argv[])
{
myprint((void *)&std::cerr);
}

[Daniel T.]

In article <Id*****************@news01.roc.ny>,
Matt <th**********@xxyyyzzzz.com> wrote:

I am trying to cast an ostream reference to void* and back again. The
code below shows the problem isolated from a more complex program. It
compiles quietly but seg faults upon execution.

// ================================================== =================
#include <iostream>
using namespace std;

void myprint(void *s) {
(ostream&)s << "hello, world" << endl;
}

int main(int argc, char *argv[]){
myprint((void *)cerr);
}
// ================================================== =================

Why can't I cast the ostream reference to and from void*?

The problem is that casting a basic_ios to a void* calls the operator
void* member-function who's only guaranteed to return 0 if the stream is
not good. There is no guarantee that it's return value is actually a
pointer to the cerr object.

If you want a pointer to the cerr object, then you have to do as others
have said and take the address of it.

--
Magic depends on tradition and belief. It does not welcome observation,
nor does it profit by experiment. On the other hand, science is based
on experience; it is open to correction by observation and experiment.

[Matt]

TB wrote:

Matt sade:

I am trying to cast an ostream reference to void* and back again. The
code below shows the problem isolated from a more complex program. It
compiles quietly but seg faults upon execution.

// ================================================== =================
#include <iostream>
using namespace std;

void myprint(void *s) {
(ostream&)s << "hello, world" << endl;
}

int main(int argc, char *argv[]){
myprint((void *)cerr);
}
// ================================================== =================

Why can't I cast the ostream reference to and from void*?

You should stop and think if your design requires casting to void*.

#include <iostream>
using namespace std;

void myprint(void *s) {
*((ostream*)s) << "hello, world" << endl;
}

int main(int argc, char *argv[]){
myprint((void *)&cerr);
}

Thanks for that fix, TB. That gets me going for now. Yes, I plan to
redesign so as to obviate that usage.

Thanks to all for the useful comments.