<html lang="en">
<head>
<title>How Variadic - The GNU C Library</title>
<meta http-equiv="Content-Type" content="text/html">
<meta name="description" content="The GNU C Library">
<meta name="generator" content="makeinfo 4.13">
<link title="Top" rel="start" href="index.html#Top">
<link rel="up" href="Variadic-Functions.html#Variadic-Functions" title="Variadic Functions">
<link rel="prev" href="Why-Variadic.html#Why-Variadic" title="Why Variadic">
<link rel="next" href="Variadic-Example.html#Variadic-Example" title="Variadic Example">
<link href="http://www.gnu.org/software/texinfo/" rel="generator-home" title="Texinfo Homepage">
<!--
This file documents the GNU C library.

This is Edition 0.12, last updated 2007-10-27,
of `The GNU C Library Reference Manual', for version
2.8 (Sourcery G++ Lite 2011.03-41).

Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2001, 2002,
2003, 2007, 2008, 2010 Free Software Foundation, Inc.

Permission is granted to copy, distribute and/or modify this document
under the terms of the GNU Free Documentation License, Version 1.3 or
any later version published by the Free Software Foundation; with the
Invariant Sections being ``Free Software Needs Free Documentation''
and ``GNU Lesser General Public License'', the Front-Cover texts being
``A GNU Manual'', and with the Back-Cover Texts as in (a) below.  A
copy of the license is included in the section entitled "GNU Free
Documentation License".

(a) The FSF's Back-Cover Text is: ``You have the freedom to
copy and modify this GNU manual.  Buying copies from the FSF
supports it in developing GNU and promoting software freedom.''-->
<meta http-equiv="Content-Style-Type" content="text/css">
<style type="text/css"><!--
  pre.display { font-family:inherit }
  pre.format  { font-family:inherit }
  pre.smalldisplay { font-family:inherit; font-size:smaller }
  pre.smallformat  { font-family:inherit; font-size:smaller }
  pre.smallexample { font-size:smaller }
  pre.smalllisp    { font-size:smaller }
  span.sc    { font-variant:small-caps }
  span.roman { font-family:serif; font-weight:normal; } 
  span.sansserif { font-family:sans-serif; font-weight:normal; } 
--></style>
<link rel="stylesheet" type="text/css" href="../cs.css">
</head>
<body>
<div class="node">
<a name="How-Variadic"></a>
<p>
Next:&nbsp;<a rel="next" accesskey="n" href="Variadic-Example.html#Variadic-Example">Variadic Example</a>,
Previous:&nbsp;<a rel="previous" accesskey="p" href="Why-Variadic.html#Why-Variadic">Why Variadic</a>,
Up:&nbsp;<a rel="up" accesskey="u" href="Variadic-Functions.html#Variadic-Functions">Variadic Functions</a>
<hr>
</div>

<h4 class="subsection">A.2.2 How Variadic Functions are Defined and Used</h4>

<p>Defining and using a variadic function involves three steps:

     <ul>
<li><em>Define</em> the function as variadic, using an ellipsis
(&lsquo;<samp><span class="samp">...</span></samp>&rsquo;) in the argument list, and using special macros to
access the variable arguments.  See <a href="Receiving-Arguments.html#Receiving-Arguments">Receiving Arguments</a>.

     <li><em>Declare</em> the function as variadic, using a prototype with an
ellipsis (&lsquo;<samp><span class="samp">...</span></samp>&rsquo;), in all the files which call it. 
See <a href="Variadic-Prototypes.html#Variadic-Prototypes">Variadic Prototypes</a>.

     <li><em>Call</em> the function by writing the fixed arguments followed by the
additional variable arguments.  See <a href="Calling-Variadics.html#Calling-Variadics">Calling Variadics</a>. 
</ul>

<ul class="menu">
<li><a accesskey="1" href="Variadic-Prototypes.html#Variadic-Prototypes">Variadic Prototypes</a>:   How to make a prototype for a function
			  with variable arguments. 
<li><a accesskey="2" href="Receiving-Arguments.html#Receiving-Arguments">Receiving Arguments</a>:   Steps you must follow to access the
			  optional argument values. 
<li><a accesskey="3" href="How-Many-Arguments.html#How-Many-Arguments">How Many Arguments</a>:    How to decide whether there are more arguments. 
<li><a accesskey="4" href="Calling-Variadics.html#Calling-Variadics">Calling Variadics</a>:     Things you need to know about calling
			  variable arguments functions. 
<li><a accesskey="5" href="Argument-Macros.html#Argument-Macros">Argument Macros</a>:       Detailed specification of the macros
        		  for accessing variable arguments. 
<li><a accesskey="6" href="Old-Varargs.html#Old-Varargs">Old Varargs</a>: 		 The pre-ISO way of defining variadic functions. 
</ul>

   </body></html>

