1
0
mirror of https://github.com/golang/go synced 2024-11-12 06:40:22 -07:00

tutorial: update discussion of variadic functions

R=rsc
CC=golang-dev
https://golang.org/cl/1677042
This commit is contained in:
Rob Pike 2010-06-14 12:27:22 -07:00
parent d5a80d0ba4
commit b9055629c1
2 changed files with 22 additions and 12 deletions

View File

@ -938,14 +938,19 @@ implements <code>Printf</code>, <code>Fprintf</code>, and so on.
Within the <code>fmt</code> package, <code>Printf</code> is declared with this signature:
<p>
<pre>
Printf(format string, v ...) (n int, errno os.Error)
Printf(format string, v ...interface{}) (n int, errno os.Error)
</pre>
<p>
That <code>...</code> represents the variadic argument list that in C would
be handled using the <code>stdarg.h</code> macros but in Go is passed using
an empty interface variable (<code>interface {}</code>) and then unpacked
using the reflection library. It's off topic here but the use of
reflection helps explain some of the nice properties of Go's <code>Printf</code>,
The token <code>...</code> introduces a variable-length argument list that in C would
be handled using the <code>stdarg.h</code> macros.
In Go, variadic functions are passed a slice of the arguments of the
specified type. In <code>Printf</code>'s case, the declaration says <code>...interface{}</code>
so the actual type is a slice of empty interface values, <code>[]interface{}</code>.
<code>Printf</code> can examine the arguments by iterating over the slice
and, for each element, using a type switch or the reflection library
to interpret the value.
It's off topic here but such run-time type analysis
helps explain some of the nice properties of Go's <code>Printf</code>,
due to the ability of <code>Printf</code> to discover the type of its arguments
dynamically.
<p>

View File

@ -622,13 +622,18 @@ We've seen simple uses of the package "fmt", which
implements "Printf", "Fprintf", and so on.
Within the "fmt" package, "Printf" is declared with this signature:
Printf(format string, v ...) (n int, errno os.Error)
Printf(format string, v ...interface{}) (n int, errno os.Error)
That "..." represents the variadic argument list that in C would
be handled using the "stdarg.h" macros but in Go is passed using
an empty interface variable ("interface {}") and then unpacked
using the reflection library. It's off topic here but the use of
reflection helps explain some of the nice properties of Go's "Printf",
The token "..." introduces a variable-length argument list that in C would
be handled using the "stdarg.h" macros.
In Go, variadic functions are passed a slice of the arguments of the
specified type. In "Printf"'s case, the declaration says "...interface{}"
so the actual type is a slice of empty interface values, "[]interface{}".
"Printf" can examine the arguments by iterating over the slice
and, for each element, using a type switch or the reflection library
to interpret the value.
It's off topic here but such run-time type analysis
helps explain some of the nice properties of Go's "Printf",
due to the ability of "Printf" to discover the type of its arguments
dynamically.