Format printing the 64bit integer -1 as hexadecimal deviates between golang and C [closed]

Answer 1

int64(math.MaxUint64) overflows the range of int64:

package main

import (
    "fmt"
    "math"
)

func main() {
    var x uint64 = 1<<64 - 1
    fmt.Printf("%v\n", math.MaxUint64 == x) // true

    var y int64 = 1<<63 - 1
    fmt.Printf("%v\n", math.MaxInt64 == y) // true

    var z int64 = int64(x) // -1
    fmt.Printf("%v\n", z)
}

Playground: https://play.golang.org/p/J6buiaaZcFt

see https://golang.org/pkg/math/#pkg-constants and https://play.golang.org/p/iul2dgRbK2E

Answer 2

The C Programming Language, Second Edition

x,X int ; unsigned hexadecimal number (without a leading 0x or 0X ), using abcdef or ABCDEF for 10, ...,15.

x,X unsigned int ; unsigned hexadecimal notation (without a leading 0x or 0X ), using abcdef for 0x or ABCDEF for 0X .

The GNU C Library Reference Manual, Version 2.27

‘%x’, ‘%X’ Print an integer as an unsigned hexadecimal number. ‘%x’ uses lower-case letters and ‘%X’ uses upper-case.

---

I am shocked- shocked- to find that integer conversions are going on here!

In C, implicit conversions abound. In Go, by design, conversions are explicit.

In C, printf implicitly converts a signed integer to unsigned for format %x. Go fmt.Printf does not.

By design, Go is not C. Go does have similarities to C, which may trap the unwary.

Answer 3

Go acts differently here than C for example. The %x verb for integers means to format the value of the number using the hexadecimal (base 16) representation, not its memory representation (which would be 2's complement). Same goes for %b for binary and %o for octal representation.

For a negative number like -255, its base16 representation is -ff.

Go is strict about types, you always have to be explicit. If you pass a signed integer, it will be formatted as a signed integer. If you want to print it as an unsigned value, you have to explicitly convert it to an unsigned value like in this example:

i := -1 // type int
fmt.Printf("%d %x %d %x", i, i, uint(i), uint(i))

Output (try it on the Go Playground):

-1 -1 4294967295 ffffffff

Note that when converting a signed value to its unsigned version (same size) it does not change the memory representation just its type, so the converted value (the unsigned result) will be the 2's complement of the signed value.

As to why this is the default for negative numbers, read the reasoning given by Rob Pike here:

Why is that not the default [the unsigned format]? Because if it were, there would be no way to print something as a negative number, which as you can see is a much shorter representation. Or to put it another way, %b %o %d %x all treat their arguments identically.

You can see how / where this is implemented in this related question: Golang: Two's complement and fmt.Printf