acrolinx

Author: TylerMSFT

docs/cpp/functions-with-variable-argument-lists-cpp.md

@@ -6,98 +6,102 @@ helpviewer_keywords: ["arguments [C++], variable number of", "variable argument
 ---
 # Functions with Variable Argument Lists  (C++)
 
-Function declarations in which the last member of  is the ellipsis (...) can take a variable number of arguments. In these cases, C++ provides type checking only for the explicitly declared arguments. You can use variable argument lists when you need to make a function so general that even the number and types of arguments can vary. The `printf` family of functions is an example of functions that use variable argument lists.
+Function declarations that have ellipsis (...) as the last argument take a variable number of arguments. C++ provides type checking only for the explicitly declared arguments. You can use variable argument lists when the number and types of arguments to the function can vary. The `printf` family of functions is an example of functions that have variable argument lists.
 
 ## Functions with variable arguments
 
-To access arguments after those declared, use the macros contained in the standard include file `<stdarg.h>` as described below.
+To access arguments after those declared, use the macros contained in the standard include file `<stdarg.h>` as explained in this article.
 
 **Microsoft Specific**
 
-Microsoft C++ allows the ellipsis to be specified as an argument if the ellipsis is the last argument and the ellipsis is preceded by a comma. Therefore, the declaration `int Func( int i, ... );` is legal, but `int Func( int i ... );` is not.
+Microsoft C++ allows the ellipsis to be specified as an argument if the ellipsis is the last argument and a comma comes before the ellipsis. Therefore, the declaration `int Func( int i, ... );` is legal, but `int Func( int i ... );` is not.
 
 **END Microsoft Specific**
 
 Declaration of a function that takes a variable number of arguments requires at least one placeholder argument, even if it is not used. If this placeholder argument is not supplied, there is no way to access the remaining arguments.
 
-When arguments of type **`char`** are passed as variable arguments, they are converted to type **`int`**. Similarly, when arguments of type **`float`** are passed as variable arguments, they are converted to type **`double`**. Arguments of other types are subject to the usual integral and floating-point promotions. See [Standard Conversions](standard-conversions.md) for more information.
+When arguments of type **`char`** are passed as variable arguments, they are converted to type **`int`**. Similarly, when arguments of type **`float`** are passed as variable arguments, they are converted to type **`double`**. Arguments of other types are subject to the usual integral and floating-point promotions. For more information, see [Standard Conversions](standard-conversions.md).
 
-Functions that require variable lists are declared by using the ellipsis (...) in the argument list. Use the types and macros that are described in the `<stdarg.h>` include file to access arguments that are passed by a variable list. For more information about these macros, see [va_arg, va_copy, va_end, va_start](../c-runtime-library/reference/va-arg-va-copy-va-end-va-start.md). in the documentation for the C Run-Time Library.
+Functions that require variable lists are declared by using the ellipsis (...) in the argument list. Use the types and macros that are described in the `<stdarg.h>` include file to access arguments that are passed by a variable list. For more information about these macros, see [va_arg, va_copy, va_end, va_start](../c-runtime-library/reference/va-arg-va-copy-va-end-va-start.md).
 
-The following example shows how the macros work together with the type (declared in `<stdarg.h>`):
+The following example shows how to use the macros to process a variable argument list:
 
 ```cpp
 // variable_argument_lists.cpp
+
 #include <stdio.h>
 #include <stdarg.h>
 
 //  Declaration, but not definition, of ShowVar.
 void ShowVar( char *szTypes, ... );
+
 int main() {
    ShowVar( "fcsi", 32.4f, 'a', "Test string", 4 );
 }
 
-//  ShowVar takes a format string of the form
-//   "ifcs", where each character specifies the
-//   type of the argument in that position.
+// ShowVar takes a format string of the form
+// "ifcs", where each character specifies the
+// type of the argument in that position.
 //
-//  i = int
-//  f = float
-//  c = char
-//  s = string (char *)
+// i = int
+// f = float
+// c = char
+// s = string (char *)
 //
-//  Following the format specification is a variable
-//  list of arguments. Each argument corresponds to
-//  a format character in the format string to which
+// Following the format specification is a variable
+// list of arguments. Each argument corresponds to
+// a format character in the format string to which
 // the szTypes parameter points
 void ShowVar( char *szTypes, ... ) {
    va_list vl;
    int i;
 
-   //  szTypes is the last argument specified; you must access
-   //  all others using the variable-argument macros.
+   // szTypes is the last argument specified; you must access
+   // all others using the variable-argument macros.
    va_start( vl, szTypes );
 
    // Step through the list.
    for( i = 0; szTypes[i] != '\0'; ++i ) {
+      
       union Printable_t {
          int     i;
          float   f;
          char    c;
          char   *s;
       } Printable;
 
-      switch( szTypes[i] ) {   // Type to expect.
+      switch( szTypes[i] ) {   // Type to expect
          case 'i':
             Printable.i = va_arg( vl, int );
             printf_s( "%i\n", Printable.i );
-         break;
+            break;
 
          case 'f':
              Printable.f = va_arg( vl, double );
              printf_s( "%f\n", Printable.f );
-         break;
+             break;
 
          case 'c':
              Printable.c = va_arg( vl, char );
              printf_s( "%c\n", Printable.c );
-         break;
+             break;
 
          case 's':
              Printable.s = va_arg( vl, char * );
              printf_s( "%s\n", Printable.s );
-         break;
+             break;
 
          default:
-         break;
+             break;
       }
    }
    va_end( vl );
 }
-//Output:
-// 32.400002
-// a
-// Test string
+
+```output
+32.400002
+a
+Test string
 ```
 
 The previous example illustrates these important concepts: