qbit/go
1
0
Fork 0
mirror of https://github.com/golang/go synced 2024-11-21 14:24:44 -07:00
Code Releases Activity

tutorial: update discussion of variadic functions

Browse Source 
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
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
doc/go_tutorial.html
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: Within the <code>fmt</code> package, <code>Printf</code> is declared with this signature:
<p> <p>
<pre> <pre>
Printf(format string, v ...) (n int, errno os.Error) Printf(format string, v ...interface{}) (n int, errno os.Error)
</pre> </pre>
<p> <p>
That <code>...</code> represents the variadic argument list that in C would The token <code>...</code> introduces a variable-length argument list that in C would
be handled using the <code>stdarg.h</code> macros but in Go is passed using be handled using the <code>stdarg.h</code> macros.
an empty interface variable (<code>interface {}</code>) and then unpacked In Go, variadic functions are passed a slice of the arguments of the
using the reflection library. It's off topic here but the use of specified type. In <code>Printf</code>'s case, the declaration says <code>...interface{}</code>
reflection helps explain some of the nice properties of Go's <code>Printf</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 due to the ability of <code>Printf</code> to discover the type of its arguments
dynamically. dynamically.
<p> <p>

17
doc/go_tutorial.txt
View File

@ -622,13 +622,18 @@ We've seen simple uses of the package "fmt", which
implements "Printf", "Fprintf", and so on. implements "Printf", "Fprintf", and so on.
Within the "fmt" package, "Printf" is declared with this signature: 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 The token "..." introduces a variable-length argument list that in C would
be handled using the "stdarg.h" macros but in Go is passed using be handled using the "stdarg.h" macros.
an empty interface variable ("interface {}") and then unpacked In Go, variadic functions are passed a slice of the arguments of the
using the reflection library. It's off topic here but the use of specified type. In "Printf"'s case, the declaration says "...interface{}"
reflection helps explain some of the nice properties of Go's "Printf", 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 due to the ability of "Printf" to discover the type of its arguments
dynamically. dynamically.