[c++] C ++中的变量数量是多少?



Answers

C ++ 11中,您有两个新选项,如Alternatives部分中Variadic函数参考页所述:

  • 变量模板也可以用来创建带有可变数量参数的函数。 它们通常是更好的选择,因为它们不会对参数的类型施加限制,不会执行整数和浮点升级,并且是类型安全的。 (自C ++ 11以来)
  • 如果所有变量参数共享一个公共类型,std :: initializer_list提供了一个访问变量参数的方便机制(虽然语法不同)。

下面是一个显示两个替代方案的例子( 看它现场 ):

#include <iostream>
#include <string>
#include <initializer_list>

template <typename T>
void func(T t) 
{
    std::cout << t << std::endl ;
}

template<typename T, typename... Args>
void func(T t, Args... args) // recursive variadic function
{
    std::cout << t <<std::endl ;

    func(args...) ;
}

template <class T>
void func2( std::initializer_list<T> list )
{
    for( auto elem : list )
    {
        std::cout << elem << std::endl ;
    }
}

int main()
{
    std::string
        str1( "Hello" ),
        str2( "world" );

    func(1,2.5,'a',str1);

    func2( {10, 20, 30, 40 }) ;
    func2( {str1, str2 } ) ;
} 

如果您使用的是gccclang我们可以使用PRETTY_FUNCTION 魔术变量来显示函数的类型签名,这有助于理解正在发生的事情。 例如使用:

std::cout << __PRETTY_FUNCTION__ << ": " << t <<std::endl ;

将会在结果int中跟随可变参数函数的例子( 见它现场 ):

void func(T, Args...) [T = int, Args = <double, char, std::basic_string<char>>]: 1
void func(T, Args...) [T = double, Args = <char, std::basic_string<char>>]: 2.5
void func(T, Args...) [T = char, Args = <std::basic_string<char>>]: a
void func(T) [T = std::basic_string<char>]: Hello

在Visual Studio中,您可以使用FUNCSIG

更新Pre C ++ 11

Pre C ++ 11 std::initializer_list的替代方案是std::vector或其他标准容器之一

#include <iostream>
#include <string>
#include <vector>

template <class T>
void func1( std::vector<T> vec )
{
    for( typename std::vector<T>::iterator iter = vec.begin();  iter != vec.end(); ++iter )
    {
        std::cout << *iter << std::endl ;
    }
}

int main()
{
    int arr1[] = {10, 20, 30, 40} ;
    std::string arr2[] = { "hello", "world" } ; 
    std::vector<int> v1( arr1, arr1+4 ) ;
    std::vector<std::string> v2( arr2, arr2+2 ) ;

    func1( v1 ) ;
    func1( v2 ) ;
}

可变参数模板的替代方案可能是可变参数函数,尽管它们不是类型安全的,并且通常容易出错并且可能不安全,但唯一可能的替代方案是使用默认参数 ,尽管这具有有限的用途。 以下示例是链接引用中示例代码的修改版本:

#include <iostream>
#include <string>
#include <cstdarg>

void simple_printf(const char *fmt, ...)
{
    va_list args;
    va_start(args, fmt);

    while (*fmt != '\0') {
        if (*fmt == 'd') {
            int i = va_arg(args, int);
            std::cout << i << '\n';
        } else if (*fmt == 's') {
            char * s = va_arg(args, char*);
            std::cout << s << '\n';
        }
        ++fmt;
    }

    va_end(args);
}


int main()
{
    std::string
        str1( "Hello" ),
        str2( "world" );

    simple_printf("dddd", 10, 20, 30, 40 );
    simple_printf("ss", str1.c_str(), str2.c_str() ); 

    return 0 ;
} 

使用可变参数函数的参数也有一些限制,您可以在第5.2.2函数调用7段中的C ++标准草案中详细说明这些参数:

当给定参数没有参数时,参数以这样一种方式传递,即接收函数可以通过调用va_arg(18.7)来获得参数的值。 在参数表达式上执行左值到右值(4.1),数组到指针(4.2)和函数到指针(4.3)的标准转换。 在这些转换之后,如果参数没有算术,枚举,指针,成员指针或类类型,则该程序不合格。 如果参数具有非POD类类型(第9节),则行为是未定义的。 [...]

Question

我如何编写一个接受可变数量参数的函数? 这是可能的,怎么样?




在C ++ 11中,有一种方法可以实现可变参数模板,这种模板导致了一种非常优雅且安全的方法来拥有可变参数函数。 Bjarne本人在C++11FAQ给出了一个使用可变参数模板printf的好例子。

就我个人而言,我认为这很优雅,我甚至不会在C ++中使用变量参数函数,直到该编译器支持C ++ 11变量参数模板。




如果所有参数都是常量并且类型相同,我们也可以使用initializer_list




在c ++ 11中,你可以这样做:

void foo(const std::list<std::string> & myArguments) {
   //do whatever you want, with all the convenience of lists
}

foo({"arg1","arg2"});

列表初始化程序FTW!




int fun(int n_args, ...) {
   int *p = &n_args; 
   int s = sizeof(int);
   p += s + s - 1;
   for(int i = 0; i < n_args; i++) {
     printf("A1 %d!\n", *p);
     p += 2;
   }
}

普通版




如此处所述,唯一的方法是通过使用C风格的变量参数。 请注意,这不是一个推荐的做法,因为它不具有类型安全性和容易出错的问题。




正如其他人所说,C型可变参数。 但你也可以用默认参数做类似的事情。




Related