bytes: shifting doubles?

[Allan Rydberg]

hi

i'm trying to shift a double, but i'm getting the
error message '>>' illegal, left operand double.

althought that the manpages say, '>>' and '<<' can
be applied for int's only, i was able to use the
shift operator on unsigned longs without any problems.
does anyone know how to do this properly?

i.e. individually copying bytes into a long array:
--------------------------------
int pointer;
char databuffer[100];

double uint64;
unsigned long uint32;

pointer =0;

// this works:
uint32 = 1111111; // anything
databuffer[pointer++] = uint32 >> 24;
databuffer[pointer++] = uint32 >> 16;
databuffer[pointer++] = uint32 >> 8;
databuffer[pointer++] = uint32 >> 0; // jup, i know..!

// this won't:
uint64 = 1111111; // anything
databuffer[pointer++] = uint64 >> 56;
databuffer[pointer++] = uint64 >> 48;
databuffer[pointer++] = uint64 >> 40;
databuffer[pointer++] = uint64 >> 32;
databuffer[pointer++] = uint64 >> 24;
databuffer[pointer++] = uint64 >> 16;
databuffer[pointer++] = uint64 >> 8;
databuffer[pointer++] = uint64 >> 0;



[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]

 

[Kyle]

hi

i'm trying to shift a double, but i'm getting the
error message '>>' illegal, left operand double.

althought that the manpages say, '>>' and '<<' can
be applied for int's only, i was able to use the
shift operator on unsigned longs without any problems.
does anyone know how to do this properly?

i.e. individually copying bytes into a long array:
--------------------------------
int pointer;
char databuffer[100];

double uint64;

double is floating point type, not integral type
shifting with these operators is allowed on integral types only
(you may want to look for a 64 bit integral type on your platform)

[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]

 

[Philippe Amarenco]

int pointer;
char databuffer[100];

double uint64;
unsigned long uint32;

double is a floating point type.

--
Philippe Amarenco, aka Phix
epita 2007 - LSE - EpX
"if new true friend not protected for explicit private union, break
case and try using this." -- Nathan Myers, longest c++ sentence.

[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]

 

[robertwessel2]

hi

i'm trying to shift a double, but i'm getting the
error message '>>' illegal, left operand double.

althought that the manpages say, '>>' and '<<' can
be applied for int's only, i was able to use the
shift operator on unsigned longs without any problems.
does anyone know how to do this properly?

Longs (and chars and shorts) are all integers. Doubles are floats, and
you cannot apply the shift operators to them. Just multiply or divide
by the appropriate power of two instead - instead of "a<<6" do "a*64".


[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]

 

[Johncarp]

hi

i'm trying to shift a double, but i'm getting the
error message '>>' illegal, left operand double.

althought that the manpages say, '>>' and '<<' can
be applied for int's only, i was able to use the
shift operator on unsigned longs without any problems.
does anyone know how to do this properly?

i.e. individually copying bytes into a long array:
--------------------------------
int pointer;
char databuffer[100];

double uint64;
unsigned long uint32;

pointer =0;

// this works:
uint32 = 1111111; // anything
databuffer[pointer++] = uint32 >> 24;
databuffer[pointer++] = uint32 >> 16;
databuffer[pointer++] = uint32 >> 8;
databuffer[pointer++] = uint32 >> 0; // jup, i know..!

// this won't:
uint64 = 1111111; // anything
databuffer[pointer++] = uint64 >> 56;
databuffer[pointer++] = uint64 >> 48;
databuffer[pointer++] = uint64 >> 40;
databuffer[pointer++] = uint64 >> 32;
databuffer[pointer++] = uint64 >> 24;
databuffer[pointer++] = uint64 >> 16;
databuffer[pointer++] = uint64 >> 8;
databuffer[pointer++] = uint64 >> 0;

unsigned long is usually the same as unsigned int, so it works. if you
want to shift 64bit value, you can use long long under gcc and __int64
(?) under msvc++.

[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]

 

[Greg Herlihy]

hi

i'm trying to shift a double, but i'm getting the
error message '>>' illegal, left operand double.

althought that the manpages say, '>>' and '<<' can
be applied for int's only, i was able to use the
shift operator on unsigned longs without any problems.
does anyone know how to do this properly?

i.e. individually copying bytes into a long array:
--------------------------------
int pointer;
char databuffer[100];

double uint64;
unsigned long uint32;

pointer =0;

// this works:
uint32 = 1111111; // anything
databuffer[pointer++] = uint32 >> 24;
databuffer[pointer++] = uint32 >> 16;
databuffer[pointer++] = uint32 >> 8;
databuffer[pointer++] = uint32 >> 0; // jup, i know..!

// this won't:
uint64 = 1111111; // anything
databuffer[pointer++] = uint64 >> 56;
databuffer[pointer++] = uint64 >> 48;

A double is a double float. It is not an integer type, so it cannot be
bit shifted. (It can be divided by a power of 2, of course, but
presumably the bit patterns and not the values stored in dataBuffer are
of interest here).

A long long is an integer type and can be bit shifted.

So I recommend declaring uint64 like this:

typedef unsigned long long uint64;

for the code to compile as written. I would also recommend renaming
"pointer" since it is not a pointer, but an index.

Greg


[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]

 

[CodeCracker]

A simple way to do that is to use a union and put both your double and
a char pointer variable or a char array of size double. Thats it. write
data in double and read the value from double but when to stream data
in and out of the char buffer get the data from char poiinter.


[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]

 

[Nick Keighley]

i'm trying to shift a double, but i'm getting the
error message '>>' illegal, left operand double.

althought that the manpages say, '>>' and '<<' can
be applied for int's only, i was able to use the
shift operator on unsigned longs without any problems.
does anyone know how to do this properly?

actually the phrase is "...shift operators ... operands shall be
of integral or enumeration type". unsigned long is integral,
double is. You can't do this.

i.e. individually copying bytes into a long array:

unsigned char databuffer[100];

double uint64;
unsigned long uint32;

pointer =0;

well you could try this:

unsigned char *p;
p = (unsigned char*)&uint64; /* that's an odd name for a double...
*/
for (i = 0; i < sizeof(double); i++)
databuffer = *p++;

this trick of copying one type to another via a cast pointer only
works for unsigned char. Anything else yields undefined behaviour.
Also note that different implementations may represent doubles
differently and hence the above code won't put the same thing in
databuffer.

// this works:
uint32 = 1111111; // anything
databuffer[pointer++] = uint32 >> 24;
databuffer[pointer++] = uint32 >> 16;
databuffer[pointer++] = uint32 >> 8;
databuffer[pointer++] = uint32 >> 0; // jup, i know..!

Undefined Behaviour

// this won't:
uint64 = 1111111; // anything
databuffer[pointer++] = uint64 >> 56;
databuffer[pointer++] = uint64 >> 48;
databuffer[pointer++] = uint64 >> 40;
databuffer[pointer++] = uint64 >> 32;
databuffer[pointer++] = uint64 >> 24;
databuffer[pointer++] = uint64 >> 16;
databuffer[pointer++] = uint64 >> 8;
databuffer[pointer++] = uint64 >> 0;

--
Nick Keighley

"There are 10 types of people in this world.
Those that understand Binary, and those that don't".


[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]

 

[James Kanze]

i'm trying to shift a double, but i'm getting the error
message '>>' illegal, left operand double.

althought that the manpages say, '>>' and '<<' can be applied
for int's only, i was able to use the shift operator on
unsigned longs without any problems.

The operators are defined for all integral types, not just int.
But becareful with >> on a signed integral type; I tend to only
use it with unsigned types, just to be on the safe side.

does anyone know how to do this properly?

i.e. individually copying bytes into a long array:

double uint64;

Now that's a confusing name.

unsigned long uint32;

pointer =0;

// this works:
uint32 = 1111111; // anything
databuffer[pointer++] = uint32 >> 24;
databuffer[pointer++] = uint32 >> 16;
databuffer[pointer++] = uint32 >> 8;
databuffer[pointer++] = uint32 >> 0; // jup, i know..!

// this won't:
uint64 = 1111111; // anything
databuffer[pointer++] = uint64 >> 56;
databuffer[pointer++] = uint64 >> 48;
databuffer[pointer++] = uint64 >> 40;
databuffer[pointer++] = uint64 >> 32;
databuffer[pointer++] = uint64 >> 24;
databuffer[pointer++] = uint64 >> 16;
databuffer[pointer++] = uint64 >> 8;
databuffer[pointer++] = uint64 >> 0;

I suppose that you are formatting binary data for output. And
that the specification requires IEEE double, high byte first,
and that you accept the fact that your code will not be portable
to a machine which doesn't use IEEE floating point (IBM or
Unisys mainframe, for example). Given that you don't really
have absolute portability anyway, the obvious answer here is to
use a reinterpret_cast, e.g.:

double d = 111111 ;
unsigned int const& ui
= reinterpret_cast< unsigned int const& >( d ) ;
databuffer[ pointer ++ ] = ui >> 56 ;
// ...

If you require absolute portability, so that the code will run
as is even on a Unisys mainframe, you've got your work cut out
for you -- you have to functions like frexp to extract the
necessary information from the floating point format and create
your own IEEE format. But portability to this degree typically
isn't necessary.

--
James Kanze mailto: (e-mail address removed)
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
9 pl. Pierre Sémard, 78210 St.-Cyr-l'École, France +33 (0)1 30 23 00 34

[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]

 

[Thomas Maeder]

i'm trying to shift a double, but i'm getting the
error message '>>' illegal, left operand double.

What would you expect as a result of shifting a double?

althought that the manpages say, '>>' and '<<' can
be applied for int's only, i was able to use the
shift operator on unsigned longs without any problems.
does anyone know how to do this properly?

If the man page says that >> and << apply to int only, it's wrong. You
can apply them to objects of integral and enumeration types; that
includes unsigned long, but not double.

i.e. individually copying bytes into a long array:
--------------------------------
int pointer;
char databuffer[100];

double uint64;

A very misleading variable name ...

unsigned long uint32;

.... and a platform-dependant variable name.

pointer =0;

// this works:
uint32 = 1111111; // anything
databuffer[pointer++] = uint32 >> 24;
databuffer[pointer++] = uint32 >> 16;
databuffer[pointer++] = uint32 >> 8;
databuffer[pointer++] = uint32 >> 0; // jup, i know..!

// this won't:
uint64 = 1111111; // anything
databuffer[pointer++] = uint64 >> 56;

Again: what should the result of evaluating the expression

uint64 >> 56

be?

[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]

 

[Rob]

hi

i'm trying to shift a double, but i'm getting the
error message '>>' illegal, left operand double.

althought that the manpages say, '>>' and '<<' can
be applied for int's only, i was able to use the
shift operator on unsigned longs without any problems.
does anyone know how to do this properly?

You've answered your own question. The basic >> and << operators are
only defined to work with integral types.

i.e. individually copying bytes into a long array:
--------------------------------
int pointer;
char databuffer[100];

double uint64;
unsigned long uint32;

pointer =0;

// this works:
uint32 = 1111111; // anything
databuffer[pointer++] = uint32 >> 24;
databuffer[pointer++] = uint32 >> 16;
databuffer[pointer++] = uint32 >> 8;
databuffer[pointer++] = uint32 >> 0; // jup, i know..!

// this won't:
uint64 = 1111111; // anything
databuffer[pointer++] = uint64 >> 56;
databuffer[pointer++] = uint64 >> 48;
databuffer[pointer++] = uint64 >> 40;
databuffer[pointer++] = uint64 >> 32;
databuffer[pointer++] = uint64 >> 24;
databuffer[pointer++] = uint64 >> 16;
databuffer[pointer++] = uint64 >> 8;
databuffer[pointer++] = uint64 >> 0;

If you want access to the bits in the double you might try doing a bit
of wizardry with casting of pointers;

unsigned long long *address; // double is (typically) longer than a
long

address = (unsigned long long)(&uint64);

databuffer[pointer++] = (*address) >> 56;

That will give you access to the bits that (internally) make up the
double variable.

The value of doing this is .... questionable. You might try
specifying what you're *really* trying to achieve by doing this: there
is almost certainly a better way to do it.

[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]

 

[John Whorfin]

althought that the manpages say, '>>' and '<<' can
be applied for int's only, i was able to use the
shift operator on unsigned longs without any problems.

They mean "integral types" of which u.long is one.
You can't shift floating point types.

does anyone know how to do this properly?

Does your compiler provide a real 64-bit int type?
Many do. If so use that. Using double just because
it has the right size (and it may not) is wrong.
Otherwise create your own uint64.

[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]

 

[Keyser Soze]

hi

i'm trying to shift a double, but i'm getting the
error message '>>' illegal, left operand double.

althought that the manpages say, '>>' and '<<' can
be applied for int's only, i was able to use the
shift operator on unsigned longs without any problems.
does anyone know how to do this properly?

i.e. individually copying bytes into a long array:
--------------------------------
int pointer;
char databuffer[100];

double uint64;
unsigned long uint32;

pointer =0;

// this works:
uint32 = 1111111; // anything
databuffer[pointer++] = uint32 >> 24;
databuffer[pointer++] = uint32 >> 16;
databuffer[pointer++] = uint32 >> 8;
databuffer[pointer++] = uint32 >> 0; // jup, i know..!

// this won't:
uint64 = 1111111; // anything
databuffer[pointer++] = uint64 >> 56;
databuffer[pointer++] = uint64 >> 48;
databuffer[pointer++] = uint64 >> 40;
databuffer[pointer++] = uint64 >> 32;
databuffer[pointer++] = uint64 >> 24;
databuffer[pointer++] = uint64 >> 16;
databuffer[pointer++] = uint64 >> 8;
databuffer[pointer++] = uint64 >> 0;

Just because you name it "uint64" does not make it an integer data type.

The declaration of: "double uint64;" still define a floating point data
type.

If you're using gcc try: "unsigned long long uint64;"

If it's a VC compiler try: "unsigned _int64 uint64;"


[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]

 

[Jack Klein]

hi

i'm trying to shift a double, but i'm getting the
error message '>>' illegal, left operand double.

Why do you think you want to shift a double?

althought that the manpages say, '>>' and '<<' can
be applied for int's only, i was able to use the

Either your man pages are incorrect, or more likely you are quoting
them incorrectly. The bitwise right and left shift operators may be
applied to all of the integer types, of which int is one. The others
are char, short, long, and long long.

shift operator on unsigned longs without any problems.
does anyone know how to do this properly?

How to shift a double properly? No, because it makes no sense either
mathematically or in terms of C or C++. What are you really trying to
do?

i.e. individually copying bytes into a long array:

Actually, the code in your snippet below attempts to copy bytes into
an array of char. Unsigned char would be a better choice.

--------------------------------
int pointer;
char databuffer[100];

double uint64;
unsigned long uint32;

pointer =0;

// this works:
uint32 = 1111111; // anything
databuffer[pointer++] = uint32 >> 24;
databuffer[pointer++] = uint32 >> 16;
databuffer[pointer++] = uint32 >> 8;
databuffer[pointer++] = uint32 >> 0; // jup, i know..!

// this won't:
uint64 = 1111111; // anything
databuffer[pointer++] = uint64 >> 56;
databuffer[pointer++] = uint64 >> 48;
databuffer[pointer++] = uint64 >> 40;
databuffer[pointer++] = uint64 >> 32;
databuffer[pointer++] = uint64 >> 24;
databuffer[pointer++] = uint64 >> 16;
databuffer[pointer++] = uint64 >> 8;
databuffer[pointer++] = uint64 >> 0;

You could include <string.h> and use memcpy().

memcpy(databuffer, &uint64, sizeof(double));



[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]

 

[Keith Thompson]

i'm trying to shift a double, but i'm getting the
error message '>>' illegal, left operand double.

althought that the manpages say, '>>' and '<<' can
be applied for int's only, i was able to use the
shift operator on unsigned longs without any problems.
does anyone know how to do this properly?

The "<<" and ">>" operators can be applied to any integer type (the
left operand should usually be unsigned).

They cannot be applied to any floating-point type, including double.

i.e. individually copying bytes into a long array:
--------------------------------
int pointer;
char databuffer[100];

double uint64;
unsigned long uint32;

pointer =0;

Your variable names are misleading. The name "pointer" implies that
it's a pointer; "index" would be clearer. "uint64" and "uint32" look
like type names rather than variable names. And finally, "uint64" is
misleading for a variable of type double, which is not an integer
type.

// this works:
uint32 = 1111111; // anything
databuffer[pointer++] = uint32 >> 24;
databuffer[pointer++] = uint32 >> 16;
databuffer[pointer++] = uint32 >> 8;
databuffer[pointer++] = uint32 >> 0; // jup, i know..!
Ok.

// this won't:
uint64 = 1111111; // anything
databuffer[pointer++] = uint64 >> 56;
databuffer[pointer++] = uint64 >> 48;
databuffer[pointer++] = uint64 >> 40;
databuffer[pointer++] = uint64 >> 32;
databuffer[pointer++] = uint64 >> 24;
databuffer[pointer++] = uint64 >> 16;
databuffer[pointer++] = uint64 >> 8;
databuffer[pointer++] = uint64 >> 0;

What are you trying to accomplish?

--
Keith Thompson (The_Other_Keith) (e-mail address removed) <http://www.ghoti.net/~kst>
San Diego Supercomputer Center <*> <http://users.sdsc.edu/~kst>
We must do something. This is something. Therefore, we must do this.

[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]

 

[=?ISO-8859-15?Q?Andr=E9_Kempe?=]

hi

i'm trying to shift a double, but i'm getting the
error message '>>' illegal, left operand double.

althought that the manpages say, '>>' and '<<' can
be applied for int's only, i was able to use the
shift operator on unsigned longs without any problems.
does anyone know how to do this properly?

i.e. individually copying bytes into a long array:
--------------------------------
int pointer;
char databuffer[100];

double uint64;
unsigned long uint32;

// this won't:
uint64 = 1111111; // anything
databuffer[pointer++] = uint64 >> 56;

it does not work since bit-shifts are defined for integer-constants
only, not for floating-point numbers.

these have a defined structure, defined as an ieee-standard (don't know
which one though), shifting it might destroy this structure. only way is
to cast to integer-type of the same size (float->integer, both size
4-byte on x86 ), and shift this one.

[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]

 

[Alexei A. Frounze]

i'm trying to shift a double, but i'm getting the
error message '>>' illegal, left operand double.

althought that the manpages say, '>>' and '<<' can
be applied for int's only, i was able to use the
shift operator on unsigned longs without any problems.

Either you misread the manpages or they're misleading.
The shift operators work with integer values, not just ints (chars, shorts
and longs (including long longs) are OK too).

But floats, doubles and long doubles can't be shifted with << and >>...
Well, they can be "shifted" out to the stdout in C++, but C++ isn't C
With the floating point types you have to use * and / to multiply and divide
by 2.

HTH,
Alex



[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]

 

[Barry Schwarz]

hi

i'm trying to shift a double, but i'm getting the
error message '>>' illegal, left operand double.

What do you expect the result to represent? The odds on it being a
valid double are pretty remote.

althought that the manpages say, '>>' and '<<' can
be applied for int's only, i was able to use the
shift operator on unsigned longs without any problems.
does anyone know how to do this properly?

Your man page should have said the shift operators can be used on
integers, not int's. unsigned long is an integer type.

i.e. individually copying bytes into a long array:
--------------------------------
int pointer;
char databuffer[100];

double uint64;
unsigned long uint32;

pointer =0;

// this works:
uint32 = 1111111; // anything
databuffer[pointer++] = uint32 >> 24;
databuffer[pointer++] = uint32 >> 16;
databuffer[pointer++] = uint32 >> 8;
databuffer[pointer++] = uint32 >> 0; // jup, i know..!

Since databuffer is not unsigned, you have invoked undefined (or maybe
its only implementation defined) behavior several times.

// this won't:
uint64 = 1111111; // anything
databuffer[pointer++] = uint64 >> 56;
databuffer[pointer++] = uint64 >> 48;
databuffer[pointer++] = uint64 >> 40;
databuffer[pointer++] = uint64 >> 32;
databuffer[pointer++] = uint64 >> 24;
databuffer[pointer++] = uint64 >> 16;
databuffer[pointer++] = uint64 >> 8;
databuffer[pointer++] = uint64 >> 0;

Why not make life easy on yourself.

unsigned char uchar[sizeof(double)];
double dbl = 1111111;
memcpy(uchar,&dbl,sizeof dbl);


<<Remove the del for email>>

[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]

 

[Meador Inge]

althought that the manpages say, '>>' and '<<' can
be applied for int's only, i was able to use the
shift operator on unsigned longs without any problems.
does anyone know how to do this properly?

That is because an 'unsigned long' is an integer: an 'unsigned' and
'long' integer. You are using 'unsigned long' which is just short-hand
for 'unsigned long int' (C and C++ allow you to leave the 'int' part
out). The 'long' applied to an 'int' or 'unsigned' just says that its
size is at least as big as an the corresponding 'int' or 'unsigned
int'. So, 'sizoef(int) <= sizeof(long int) and sizeof(unsigned int) <=
sizeof(unsigned long int).' If 'long' actually makes the integer type
bigger is implementation defined.

"double", however, along with "float" and "long double" are floating
point types. C and C++ disallow shift operations (and all other bit
manipulation operations, for that matter) with floating point types.

If you actually need a 64-bit integer many compilers offer a language
extension for representing them. For instance, MSVC++ offers '__int64'
for x86 and g++ offers 'long long int' for x86.


[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]

 

[Keith Thompson]

On 17 Sep 2005 10:00:36 -0400, Allan Rydberg <[email protected]>
wrote in comp.lang.c: [...]

althought that the manpages say, '>>' and '<<' can
be applied for int's only, i was able to use the

Either your man pages are incorrect, or more likely you are quoting
them incorrectly. The bitwise right and left shift operators may be
applied to all of the integer types, of which int is one. The others
are char, short, long, and long long.

Also signed char, unsigned char, unsigned short, unsigned long, and
unsigned long long. Since this is cross-posted to
comp.lang.c++.moderated (not a good idea), I'll mention that long long
and unsigned long long are new in C99. Many pre-C99 compilers, and
probably many C++ compilers, provide it as an extension.

--
Keith Thompson (The_Other_Keith) (e-mail address removed) <http://www.ghoti.net/~kst>
San Diego Supercomputer Center <*> <http://users.sdsc.edu/~kst>
We must do something. This is something. Therefore, we must do this.

[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]