Three new books, Go Optimizations 101, Go Details & Tips 101 and Go Generics 101 are published now. It is most cost-effective to buy all of them through this book bundle in the Leanpub book store.

# Values of two different named pointer types may be indirectly converted to each other's type if the base types of the two types shares the same underlying type

Generally, the values of two pointer types may not be converted to each other if the underlying types of the two pointer types are different. For example, the 4 conversions in the following code are all illegal.

``````package main

type MyInt int
type IntPtr *int     // underlying type is *int
type MyIntPtr *MyInt // underlying type is *MyInt

func main() {
var x IntPtr
var y MyIntPtr
x = IntPtr(y)       // error
y = MyIntPtr(x)     // error
var _ = (*int)(y)   // error
var _ = (*MyInt)(x) // error
}
``````

Although the above 4 conversions may not achieved directly, they may be achieved indirectly. This benefits from the fact that the following conversions are legal.

``````package main

type MyInt int

func main() {
var x *int
var y *MyInt
x = (*int)(y)   // okay
y = (*MyInt)(x) // okay
}
``````

The reason why the above two conversions are legal is values of two unnamed pointers types may be converted to each other's type if the base types of the two types shares the same underlying type. In the above example, the base types of the types of `x` and `y` are `int` and `MyInt`, which share the same underlying type `int`, so `x` and `y` may be converted to each other's type.

Benefiting from the just mentioned fact, values of `IntPtr` and `MyIntPtr` may be also converted to each other's type, though such conversions must be indirectly, as shown in the following code.

``````package main

type MyInt int
type IntPtr *int
type MyIntPtr *MyInt

func main() {
var x IntPtr
var y MyIntPtr
x = IntPtr((*int)((*MyInt)(y)))     // okay
y = MyIntPtr(((*MyInt))((*int)(x))) // okay
var _ = (*int)((*MyInt)(y))         // okay
var _ = (*MyInt)((*int)(x))         // okay
}
``````

Index↡

The Go 101 project is hosted on Github. Welcome to improve Go 101 articles by submitting corrections for all kinds of mistakes, such as typos, grammar errors, wording inaccuracies, description flaws, code bugs and broken links.

If you would like to learn some Go details and facts every serveral days, please follow Go 101's official Twitter account @go100and1 or join Go 101 slack channels.

The digital versions of this book are available at the following places:
Tapir, the author of Go 101, has been on writing the Go 101 series books and maintaining the go101.org website since 2016 July. New contents will be continually added to the book and the website from time to time. Tapir is also an indie game developer. You can also support Go 101 by playing Tapir's games (made for both Android and iPhone/iPad):
Individual donations via PayPal are also welcome.

Index:
• Conversions Related
• Values of two different defined pointer types may be indirectly converted to each other's type if the base types of the two types shares the same underlying type
• more 4 details are available in the paid ebooks.