va_start

 

C++

Compiler support

Freestanding and hosted

Language

Standard library

Standard library headers

Named requirements

Feature test macros (C++20)

Language support library

Concepts library (C++20)

Diagnostics library

Memory management library

Metaprogramming library (C++11)

General utilities library

Containers library

Iterators library

Ranges library (C++20)

Algorithms library

Strings library

Text processing library

Numerics library

Date and time library

Input/output library

Filesystem library (C++17)

Concurrency support library (C++11)

Execution control library (C++26)

Technical specifications

Symbols index

External libraries

 

Utilities library

Language support Type support (basic types, RTTI) Library feature-test macros (C++20) Program utilities Variadic functions initializer_list (C++11) is_constant_evaluated (C++20) is_within_lifetime (C++26) source_location (C++20) Coroutine support (C++20) Contract support (C++26) Three-way comparison three_way_comparablethree_way_comparable_with (C++20)(C++20) strong_ordering (C++20) weak_ordering (C++20) partial_ordering (C++20) common_comparison_category (C++20) compare_three_way_result (C++20) compare_three_way (C++20) strong_order (C++20) weak_order (C++20) partial_order (C++20) compare_strong_order_fallback (C++20) compare_weak_order_fallback (C++20) compare_partial_order_fallback (C++20)     type_order (C++26) is_eqis_ltis_lteq (C++20)(C++20)(C++20) is_neqis_gtis_gteq (C++20)(C++20)(C++20)

General utilities Function objects Bit manipulation (C++20) bitset hash (C++11) Relational operators (deprecated in C++20) rel_ops::operator!=rel_ops::operator>      rel_ops::operator<=rel_ops::operator>= Integer comparison functions cmp_equalcmp_lesscmp_less_than (C++20)(C++20)(C++20)     cmp_not_equalcmp_greatercmp_greater_than (C++20)(C++20)(C++20) in_range (C++20) Swap and type operations swap ranges::swap (C++20) exchange (C++14) declval (C++11) to_underlying (C++23) forward (C++11) forward_like (C++23) move (C++11) move_if_noexcept (C++11) as_const (C++17) Common vocabulary types pair tuple (C++11) optional (C++17) any (C++17) variant (C++17) tuple_size (C++11) tuple_element (C++11) apply (C++17) make_from_tuple (C++17) expected (C++23)

 

Variadic functions

va_start

va_arg

va_copy (C++11)

va_end

va_list

 

Defined in header <cstdarg>
void va_start( std::va_list ap, parmN );		(until C++26)
void va_start( std::va_list ap, ... );			(since C++26)

See More

The va_start macro enables access to the variable arguments of a variadic function.

va_start shall be invoked with an instance to a valid std::va_list object ap before any calls to va_arg.

The parameter parmN must name the rightmost parameter in the parameter list of the function definition (the one just before the ellipsis parameter). If parmN is of reference type, or of a type not compatible with the type that results from default argument promotions, the behavior is undefined. If parmN is a pack expansion or an entity resulting from a lambda capture, the program is ill-formed, no diagnostic required. (since C++11)

(until C++26)

If more than one argument is present for va_start, the preprocessing tokens comprising the second and subsequent arguments are discarded. If any of those arguments expands to include unbalanced parentheses, or a preprocessing token that does not convert to a token, the program is ill-formed, no diagnostic required.

(since C++26)

Parameters

ap	-	an object of the va_list type
parmN	-	the named parameter preceding the first variable parameter

Expanded value

(none)

Notes

va_start is required to work correctly even if its second parameter has overloaded operator&.

It is unspecified whether va_start can be evaluated in a constant expression.

(since C++11)

Example

Run this code

#include <cstdarg>
#include <iostream>

#if __cplusplus >= 202603L
int add_nums(int count, ...) // omission of ‘,’ before “...” is deprecated in C++26
#else
int add_nums(int count...) // OK until C++26
#endif
{
    int result = 0;
    std::va_list args;
    va_start(args, count); // “count” can be omitted since C++26
    for (int i = 0; i < count; ++i)
        result += va_arg(args, int);
    va_end(args);
    return result;
}

#if __cplusplus >= 202603L
int add_nums_cpp26(...) // since C++26 a named argument is no longer required
{
    int result = 0;
    std::va_list args;
    va_start(args);
    int count = va_arg(args, int);
    for (int i = 0; i < count; ++i)
        result += va_arg(args, int);
    va_end(args);
    return result;
}
#endif

int main()
{
    std::cout << add_nums(4, 25, 25, 50, 50) << '\n';
#if __cplusplus >= 202603L
    std::cout << add_nums_cpp26(4, 25, 25, 50, 50) << '\n';
#endif
}

Possible output:

150
150

Defect reports

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

DR	Applied to	Behavior as published	Correct behavior
CWG 273	C++98	it was unclear whether va_start is required to support parmNs with overloaded operator&	required
LWG 2099	C++98	the behavior was undefined if parmN is declared with a function, array, or reference type	the behavior is undefined if parmN is of reference type

See also

va_arg	accesses the next variadic function argument (function macro)
va_end	ends traversal of the variadic function arguments (function macro)
C documentation for va_start