To get rid of the leading FFFFFF's, you need to define the buffer as unsigned:

unsigned char buffer[sizeof(a)];

using System;

class Test
{
    unsafe static void Main()
    {

       double a = 123.45678;
       byte* pb = (byte*)&a;
       for(int i = 0; i < sizeof(double); i++)
       {
          Console.WriteLine("buffer = {0:X}", *pb++);
       }
       Console.ReadKey();
    }
}

I actually try both of this, and they produce the same output.

///////////////
#include <stdio.h>
int main()
{
int i;
double a = 123.45678;
//typedef unsigned char byte;
unsigned char buffer[sizeof(a)];
*(double*)buffer = a;
//byte* pb = (byte*)&a;
for (i=0;i<sizeof(a);i++)
{
printf("buffer = %X\n", buffer[i]);
}
return 0;
}

////////
#include <stdio.h>
int main()
{
int i;
double a = 123.45678;
typedef unsigned char byte;
unsigned char buffer[sizeof(a)];
//*(double*)buffer = a;
byte* pb = (byte*)&a;
for (i=0;i<sizeof(a);i++)
{
// printf("buffer = %X\n", buffer[i]);
printf("buffer = %X\n", *pb++);
}
return 0;
}
////////
output
buffer = E1
buffer = 5D
buffer = 2E
buffer = E2
buffer = 3B
buffer = DD
buffer = 5E
buffer = 40

But I do not understand how about output is derived from double a = 123.45678
Could you elaborate?
I know HEX representation is using base of 16, but how do the decimal dot being represented? if the double is a negative value, it would have different consideration too.
http://www.learn-c.com/data_lines.htm


Say if my a = 1.2994745, representing them in 8-bytes character, would there be some truncation error? For 8-bytes character representation, what is the maximum number of decimal places to be no truncation error?

Doubles in both C and C# are stored in what's known as IEEE 754-1985 format (also known as IEC 60559).

The details of this format are complex (see here for full details) but what it boils down to is that any real number with an absolute value between (approx) 5.0 * 10 ^ -324 and 1.7 * 10 ^ 308 can be stored with up to 15 or 16 digit precision as well as the special values: Infinity, Minus Infinity, Minus Zero and NaN ('not a number'). The special values ensure that double arittmetic never overflows or underflows.

In practice, double arithmetic is done internally to 10 bytes of precision and the result rounded off to 8 bytes.

In C you actually have a 'long double' type (10 bytes, 19 digits of precision) but this isn't supported in C#.