精华内容
下载资源
问答
  • C语言可变参数函数_初探

    千次阅读 2019-11-10 20:27:47
    一、什么是可变参数函数 C语言允许定义参数数量可变的函数,这称为可变参数函数(variadic function)。这种函数需要固定数量的强制参数,后面是数量可变的可选参数。 其中,强制参数必须至少一个,可选参数数量可变...

    一、什么是可变参数函数

    C语言允许定义参数数量可变的函数,这称为可变参数函数(variadic function)。这种函数需要固定数量的强制参数,后面是数量可变的可选参数。

    其中,强制参数必须至少一个,可选参数数量可变,类型可变,可选参数的数量由强制参数的值决定,或由用来定义可选参数列表的特殊值决定。

    其实我们早就接触过可变参数函数了,C 语言中最常用的可变参数函数例子是 printf()和 scanf()。这两个函数都有一个强制参数,即格式化字符串。格式化字符串中的转换修饰符决定了可选参数的数量和类型。(是吧,printf中可以有自定义个%d,没毛病)

    可变参数函数的参数列表的格式是,强制性参数在前,后面跟着一个逗号和省略号(…),这个省略号代表可选参数。比如:int fun(int, …) (我随便举的例子啊)
    .
    .

    二、可变参数函数的实现

    1、问题引入

    我们先来思考这样一个问题,作为本节的引入:
    如果我们要预先写一个可变参数的累加求和函数,其强制参数类型为int,用它来表示我们一共要传入多少个可变参数。于是我们大概可以有这么一个框架:

    double getSum(int NumofPara, ...)
    {
    	int i = 0;
    	double sum = 0.0;
    	
    	for( i = 0; i < NumofPara; i++ )
    	{
    		sum += ??		
    	}
    }
    

    发现什么问题没有?

    由于已经知道要传入多少个可变参数,所以求和思路就是,for循环遍历NumofPara次,每次都把sum加上一个可变参数。

    思路很清晰,没毛病。但是,问题来了。由于是可变参数,我们无法提前得知可变参量的名字,也就没法访问这些可变参数。(你参数列表里都是一串省略号了,你怎么可能提前知道变量名,所以自然而然也无法表示、无法访问这些变量了)

    2、实现思路

    为了解决上述问题,C语言规定:

    当编写可变参数函数时,必须用 va_list 类型定义参数指针,以获取可选参数。可变参数函数要获取可选参数时,必须通过一个类型为 va_list 的对象来进行访问,它包含了参数信息。

    这种类型的对象也称为参数指针(argument pointer),它包含了栈中至少一个参数的位置。可以使用这个参数指针从一个可选参数移动到下一个可选参数,由此,函数就可以获取所有的可选参数。va_list 类型被定义在头文件 stdarg.h 中。

    这么说可能太过官方,太抽象了。我们来举个例子。

    假设我们有一个可变参数函数getSum(int NumofPara, …),然后现在我们代入具体值,比如getSum(3, 7, 8, 9),通过上面的介绍我们知道,第一个3是强制参数,表明后面跟了3个可变参量,而后面的7、8、9则为具体的可变参量。

    根据C语言的要求,我们需要在getSum(int NumofPara, …)函数中定义一个va_list类型的指针。

    然后它是怎么实现“访问、获取可选参数”的呢?
    图片讲解va_list
    C语言里是这样实现的:通过某种机制(等会儿会讲)让强制参数和可选参数在内存中以连续的方式存放(强制参数在前),同时让va_list指针指向最后一个强制参数,即第一个可选参数前的强制参数。然后,通过另一种机制,每次访问va_list所指的参量之后,指针自动向后移位。进而当下一次再访问va_list的时候,访问的就是下一位的值。这样就可以访问各个可变参数了。大概就是这样了,讲得太接地气了。

    3、具体实现函数

    那么,C语言又是怎么实现上面提到的这些机制的呢?

    由此引入两个函数。

    void va_start(va_list argptr, lastparam);
    是va_list指针的初始化函数,用来初始化指针,也就是实现让其“先指向最后一个强制参数”的功能。

    于是自然而然的,该函数的第一个参数是一个va_list 类型的指针,第二个参数是可变参数函数中最后一个强制参数,即第一个可选参数前的强制参数。

    va_start函数中,va_list进行初始化,指针指向末尾的强制参数。va_start结束后,初始化完成,指针自动移位到下一个参数,即第一个可变参数。(虽然感觉有点奇怪)

    那么怎么访问va_list指针当前指向的可变参数呢?引出第二个函数:

    type va_arg(va_list argptr, type);
    其第一个参数是已经初始化完成的va_list指针,第二个参数则为可变参数的类型,返回的参数就是当前va_list指针所指的可变参数,所以类型也跟传入的可变参数类型相同。

    每一次通过va_arg函数访问完一次参数后,va_list指针会自动移位到下一位。

    C语言还规定,当不再需要使用参数指针时,必须调用宏 va_end来终结该指针,其实说白了就是释放内存。(如果想使用宏 va_start 或者宏 va_copy 来重新初始化一个之前用过的参数指针,也必须先调用宏 va_end)

    4、具体实现示例

    好了,说了这么多,我们通过完善之前写了一半的getSum函数来具体了解一下,可能就会豁然开朗明明白白了:

    double getSum(int NumofPara, ...)
    {
    	int i = 0;							//用于for循环 
    	double sum = 0.0;					//用于求和 
    
    	va_list pointer;					//新建一个va_list类型的指针 
    
    	va_start(pointer, NumofPara);		//初始化指针,指针指向确定 
    	
    	for( i = 0; i < NumofPara; i++ )
    	{
    		sum += va_arg(pointer, double);	//通过va_arg函数来访问可变参数,返回类型为double 
    	}									//同时,每次va_arg函数结束后,va_list指针指向下一位 
    	
    	va_end(pointer);					//终结指针,释放内存 
    	
    	return sum;
    
    	//P.S. 有个问题要注意一下,在main函数里调用的时候,应该写成getSum(3, 7.0, 8.0, 9.0),否则得到的可能是0。
    }
    

    接下来简单补充一下上面提到的所谓“机制”:

    它的实现原理利用了内存的压栈技术,将参数压入(push)栈内,使用时,再逐个从栈里pop出来
    需要注意的是,压栈的顺序是从最右边参数开始的,再向左逐个压入,根据栈的原理,在取参数时,就从第一个可变参数开始了。
    在进程中,堆栈地址是从高到低分配的.当执行一个函数的时候,将参数列表入栈,压入堆栈的高地址部分,然后入栈函数的返回地址,接着入栈函数的执行代码,这个入栈过程,堆栈地址不断递减。
    (所以取的时候就是从低到高,也就是上面草图中从左到右从3到7到8到9)

    三、不小心写多了一个标题

    上面说得比较粗糙,可能有一些地方说错了。里面具体原理我也还没去深究。以后吧。

    参考资料:
    C语言可变参数函数
    【干货】C语言可变参数
    C语言可变参数列表知识总结
    C语言中可变参数的使用方法
    基于本文知识点,下一次再来追补一些关于vsprintf函数的知识点。

    展开全文
  • C语言可变参数详解

    千次阅读 多人点赞 2018-12-31 22:46:06
    C语言可变参数详解 什么是可变参数函数 在C语言编程中有时会遇到一些参数可变的函数,例如printf()、scanf(),其函数原型为: int printf(const char* format,…) int scanf(const char *format,…) 就拿 printf 来...

    C语言可变参数详解

    什么是可变参数函数

    在C语言编程中有时会遇到一些参数可变的函数,例如printf()、scanf(),其函数原型为:

    int printf(const char* format,)
    int scanf(const char *format,)
    

    就拿 printf 来说吧,它除了有一个参数 format 固定以外,后面的参数其个数和类型都是可变的,用三个点“…”作为参数占位符。

    参数列表的构成

    任何一个可变参数的函数都可以分为两部分:固定参数和可选参数。至少要有一个固定参数,其声明与普通函数参数声明相同;可选参数由于数目不定(0个或以上),声明时用"…"表示。固定参数和可选参数共同构成可变参数函数的参数列表。

    实现原理

    C语言中使用 va_list 系列变参宏实现变参函数,此处va意为variable-argument(可变参数)。

    x86平台VC6.0编译器中,stdarg.h头文件内变参宏定义如下:

    typedef char * va_list;
    
    // 把 n 圆整到 sizeof(int) 的倍数
    #define _INTSIZEOF(n)       ( (sizeof(n)+sizeof(int)-1) & ~(sizeof(int)-1) )
    
    // 初始化 ap 指针,使其指向第一个可变参数。v 是变参列表的前一个参数
    #define va_start(ap,v)      ( ap = (va_list)&v + _INTSIZEOF(v) )
    
    // 该宏返回当前变参值,并使 ap 指向列表中的下个变参
    #define va_arg(ap, type)    ( *(type *)((ap += _INTSIZEOF(type)) - _INTSIZEOF(type)) )
    
    // /将指针 ap 置为无效,结束变参的获取
    #define va_end(ap)             ( ap = (va_list)0 )
    

    _INTSIZEOF(n)

    _INTSIZEOF宏考虑到某些系统需要内存地址对齐。从宏名看应按照sizeof(int)即栈粒度对齐,参数在内存中的地址均为sizeof(int)=4的倍数。

    例如,若1≤sizeof(n)≤4,则_INTSIZEOF(n)=4;若5≤sizeof(n)≤8,则_INTSIZEOF(n)=8

    va_start(ap,v)

    va_start宏首先根据(va_list)&v得到参数 v 在栈中的内存地址,加上_INTSIZEOF(v)即v所占内存大小后,使 ap 指向 v 的下一个参数。在使用的时候,一般用这个宏初始化 ap 指针,v 是变参列表的前一个参数,即最后一个固定参数,初始化的结果是 ap 指向第一个变参。

    va_arg(ap, type)

    这个宏取得 type 类型的可变参数值。首先ap += _INTSIZEOF(type),即 ap 跳过当前可变参数而指向下个变参的地址;然后ap-_INTSIZEOF(type)得到当前变参的内存地址,类型转换后解引用,最后返回当前变参值。

    va_end(ap)

    va_end 宏使 ap 不再指向有效的内存地址。该宏的某些实现定义为((void*)0),编译时不会为其产生代码,调用与否并无区别。但某些实现中 va_end 宏用于在函数返回前完成一些必要的清理工作:如 va_start 宏可能以某种方式修改栈,导致返回操作无法完成,va_end 宏可将有关修改复原;又如 va_start 宏可能为参数列表动态分配内存以便于遍历,va_end 宏可释放此内存。因此,从使用 va_start 宏的函数中退出之前,必须调用一次 va_end 宏。

    代码示例

    变参宏无法智能识别可变参数的数目和类型,因此实现变参函数时需自行判断可变参数的数目和类型。所以我们就要想一些办法,比如

    1. 显式提供变参数目或设定遍历结束条件
    2. 显式提供变参类型枚举值,或在固定参数中包含足够的类型信息(如printf函数通过分析format字符串即可确定各变参类型)
    3. 主调函数和被调函数可约定变参的数目和类型

    例1:函数通过固定参数指定可变参数个数,打印所有变参值。

    #include <stdarg.h>
    #include <stdio.h>
    
    void parse_valist_by_num(int arg_cnt, ...);
    
    int main(void)
    {
        parse_valist_by_num(4,1,2,3,4);
        parse_valist_by_num(4,1,2,3); 
        parse_valist_by_num(4,1,2,3,4,5); //多余的变参被忽略
    }
    
    
    //第一个参数定义可变参数的个数
    void parse_valist_by_num(int arg_cnt, ...)
    {
        
        va_list p_args;
        va_start(p_args, arg_cnt);
        
        int idx;
        int val;
        
        for(idx = 1; idx <= arg_cnt; ++idx){
            val = va_arg(p_args, int);
            printf("第 %d 个参数: %d\n", idx, val);
        }
        printf("---------------\n");
        va_end(p_args);
    }
    

    运行结果如下:

    在这里插入图片描述

    注意第2个结果,第4个参数是一个魔数,这是因为打印出了栈中参数3上方的参数值。

    例2:函数定义一个结束标记(-1),调用时通过最后一个参数传递该标记,打印标记前所有变参值。

    #include <stdarg.h>
    #include <stdio.h>
    
    void parse_valist_by_flag(int num_1, ...);
    
    int main(void)
    {
        parse_valist_by_flag(1,-1);
        parse_valist_by_flag(1,2,3,5,-1);
        parse_valist_by_flag(-1);
        
    }
    
    //函数定义一个结束标记(-1),调用时通过最后一个参数传递该标记,以结束变参的遍历打印。
    //最后一个参数作为变参结束符(-1),用于循环获取变参内容
    void parse_valist_by_flag(int num_1, ...)
    {
        va_list p_args;
        va_start(p_args, num_1);
        int idx = 0;
        int val = num_1;
        while(val != -1){
            ++idx;
            printf("第 %d 个参数: %d\n", idx, val);
            val = va_arg(p_args, int); //得到下个变参值
        }
        va_end(p_args);
        printf("---------------\n");
    }
    

    运行结果是:
    在这里插入图片描述

    需要注意

    va_arg(ap, type)宏中的 type 不可指定为以下类型:

    • char
    • short
    • float

    在C语言中,调用不带原型声明或声明为变参的函数时,主调函数会在传递未显式声明的参数前对其执行缺省参数提升(default argument promotions),将提升后的参数值传递给被调函数。

    ​ 提升操作如下:

    • float 类型的参数提升为 double 类型
    • char、short 和相应的 signed、unsigned 类型参数提升为 int 类型
    • 若 int 类型不能容纳原值,则提升为 unsigned int 类型

    最后来一张图,帮助大家理解前文讲的宏。

    在这里插入图片描述

    【完】

    参考资料

    https://www.cnblogs.com/clover-toeic/p/3736748.html

    展开全文
  • C++11增强了模板功能,允许模板定义中包含0到任意个模板参数,这就是可变参数模板。可变参数模板的加入使得C++11的功能变得更加强大,而由此也带来了许多神奇的用法。 本文实例源码github地址:...

    在C++11之前,类模板和函数模板只能含有固定数量的模板参数。C++11增强了模板功能,允许模板定义中包含0到任意个模板参数,这就是可变参数模板。可变参数模板的加入使得C++11的功能变得更加强大,而由此也带来了许多神奇的用法。

    本文实例源码github地址https://github.com/yngzMiao/yngzmiao-blogs/tree/master/2020Q2/20200401


    可变参数模板

    可变参数模板和普通模板的语义是一样的,只是写法上稍有区别,声明可变参数模板时需要在typenameclass后面带上省略号...

    template<typename... Types>
    

    其中,...可接纳的模板参数个数是0个及以上的任意数量,需要注意包括0个

    若不希望产生模板参数个数为0的变长参数模板,则可以采用以下的定义:

    template<typename Head, typename... Tail>
    

    本质上,...可接纳的模板参数个数仍然是0个及以上的任意数量,但由于多了一个Head类型,由此该模板可以接纳1个及其以上的模板参数


    函数模板的使用

    在函数模板中,可变参数模板最常见的使用场景是以递归的方法取出可用参数

    void print() {}
    
    template<typename T, typename... Types>
    void print(const T& firstArg, const Types&... args) {
    	std::cout << firstArg << " " << sizeof...(args) << std::endl;
    	print(args...);
    }
    

    通过设置...,可以向print函数传递任意个数的参数,并且各个参数的类型也是任意。也就是说,可以允许模板参数接受任意多个不同类型的不同参数。这就是不定参数的模板,格外需要关注的是,...三次出现的位置

    如果如下调用print函数:

    print(2, "hello", 1);
    

    如此调用会递归将3个参数全部打印。细心的话会发现定义了一个空的print函数,这是因为当使用可变参数的模板,需要定义一个处理最后情况的函数,如果不写,会编译错误。这种递归的方式,是不是觉得很惊艳!

    在不定参数的模板函数中,还可以通过如下方式获得args的参数个数:

    sizeof...(args)
    

    假设,在上面代码的基础上再加上一个模板函数如下,那么运行的结果是什么呢?

    #include <iostream>
    
    void print() {}
    
    template<typename T, typename... Types>
    void print(const T& firstArg, const Types&... args) {
    	std::cout << firstArg << " " << sizeof...(args) << std::endl;
    	print(args...);
    }
    
    template <typename... Types>
    void print(const Types&... args) {
      std::cout << "print(...)" << std::endl;
    }
    
    int main(int argc, char *argv[]) {
    	print(2, "hello", 1);
    
    	return 0;
    }
    

    现在有一个模板函数接纳一个参数加上可变参数,还有一个模板函数直接接纳可变参数,如果调用print(2, “hello”, 1),会发现这两个模板函数的参数格式都符合。是否会出现冲突、不冲突的话会执行哪一个呢?

    运行代码后的结果为:

    yngzmiao@yngzmiao-virtual-machine:~/test/$ ./main 
    2 2
    hello 1
    1 0
    

    从结果上可以看出,程序最终选择了一个参数加上不定参数的模板函数。也就是说,当较泛化和较特化的模板函数同时存在的时候,最终程序会执行较特化的那一个

    再比如一个例子,std::max函数只可以返回两个数的较大者,如果多个数,就可以通过不定参数的模板来实现:

    #include <iostream>
    
    template <typename T>
    T my_max(T value) {
      return value;
    }
    
    template <typename T, typename... Types>
    T my_max(T value, Types... args) {
      return std::max(value, my_max(args...));
    }
    
    int main(int argc, char *argv[]) {
      std::cout << my_max(1, 5, 8, 4, 6) << std::endl;
    
    	return 0;
    }
    

    类模板的使用

    除了函数模板的使用外,类模板也可以使用不定参数的模板参数,最典型的就是tuple类了。其大致代码如下:

    #include <iostream>
    
    template<typename... Values> class tuple;
    template<> class tuple<> {};
    
    template<typename Head, typename... Tail>
    class tuple<Head, Tail...>
      : private tuple<Tail...>
    {
      typedef tuple<Tail...> inherited;
      public:
        tuple() {}
        tuple(Head v, Tail... vtail) : m_head(v), inherited(vtail...) {}
        Head& head() {return m_head;}
        inherited& tail() {return *this;}
      protected:
        Head m_head;
    };
    
    int main(int argc, char *argv[]) {
    	tuple<int, float, std::string> t(1, 2.3, "hello");
    	std::cout << t.head() << " " << t.tail().head() << " " << t.tail().tail().head() << std::endl;
    
    	return 0;
    }
    

    根据代码可以知道,tuple类继承除首之外的其他参数的子tuple类,以此类推,最终继承空参数的tuple类。继承关系可以表述为:

    tuple<>
          ↑
    tuple<std::string>
      string "hello"
          ↑
    tuple<float, std::string>
      float 2.3
          ↑
    tuple<int, float, std::string>
      int 1
    

    接下来考虑在内存中的分布,内存中先存储父类的变量成员,再保存子类的变量成员,也就是说,对象t按照内存分布来说;

    ┌─────────┐<---- 对象指针
    |  hello  |
    |─────────|
    |  2.3    |
    |─────────|
    |  1      |
    └─────────┘
    

    这时候就可以知道下一句代码的含义了:

    inherited& tail() {return *this;}
    

    tail()函数返回的是父类对象,父类对象和子类对象的内存起始地址其实是一样的,因此返回*this,再强行转化为inherited类型。

    当然,上面采用的是递归继承的方式,除此之外,还可以采用递归复合的方式:

    template<typename... Values> class tup;
    template<> class tup<> {};
    
    template<typename Head, typename... Tail>
    class tup<Head, Tail...>
    {
      typedef tup<Tail...> composited;
      public:
        tup() {}
        tup(Head v, Tail... vtail) : m_head(v), m_tail(vtail...) {}
        Head& head() {return m_head;}
        composited& tail() {return m_tail;}
      protected:
        Head m_head;
        composited m_tail;
    };
    

    两种方式在使用的过程中没有什么区别,但C++11中采用的是第一种方式(递归继承)。

    在上面的例子中,取出tuple中的元素是一个比较复杂的操作,需要不断地取tail,最终取head才能获得。标准库的std::tuple,对此进行简化,还提供了一些其他的函数来进行对tuple的访问。例如:

    #include <iostream>
    #include <tuple>
    
    int main(int argc, char *argv[]) {
      std::tuple<int, float, std::string> t2(1, 2.3, "hello");
      std::get<0>(t2) = 4;                      // 修改tuple内的元素
      std::cout << std::get<0>(t2) << " " << std::get<1>(t2) << " " << std::get<2>(t2) << std::endl;    // 获取tuple内的元素
    
      auto t3 = std::make_tuple(2, 3.4, "World");         // make方法生成tuple对象
      
      std::cout << std::tuple_size<decltype(t3)>::value << std::endl;    // 获取tuple对象元素的个数
      std::tuple_element<1, decltype(t3)>::type f = 1.2;          // 获取tuple对象某元素的类型
    
    	return 0;
    }
    

    相关阅读

    展开全文
  • Java数组传递及可变参数

    万次阅读 多人点赞 2018-09-02 11:39:20
    方法可以操作传递和返回基本数据类型,但是方法中也用来传递和返回数组。如果要向方法中传递一个数组,则方法的接收参数处必须是符合其类型的数组。而且数组属于引用数据类型,所以在把数组传递进方法之后,如果...

    方法可以操作传递和返回基本数据类型,但是方法中也可用来传递和返回数组。如果要向方法中传递一个数组,则方法的接收参数处必须是符合其类型的数组。而且数组属于引用数据类型,所以在把数组传递进方法之后,如果方法对数组本身做了任何修改,修改结果都是会保存下来的。

     

    向方法中传递数组

    在java中,所有对象都是通过引用进行操作的。而数组也是一种对象,当把数组作为参数传递给方法时,传递的实际上就是数组对象的引用。在方法中对数组的所有操作,都会映射到原数组中。而所谓的"引用",就是java对象在堆内存的地址赋给了多个"栈内存"的变量。

    public class Test {
        public static void main(String[] args) {
            int[] array = { 1, 3, 5 }; // 使用静态初始化定义数组
            method(array); // 传递数组引用
            for (int i = 0; i < array.length; i++) { // 循环输出
                System.out.print(array[i] + "\t");
            }
        }
        public static void method(int[] x) { // 接收整型数组引用
            x[0] = 6; // 修改第一个元素的内容
        }
    }

    执行结果:

    6	3	5	

    我们来看一下其执行时的内存状态:

     

    使用方法返回一个数组

    既然方法可以接收一个数组,那么方法也就可以返回一个数组,则此时,只需要在返回值类型声明处明确的写出返回的数组类型即可。

    public class Test {
        public static void main(String[] args) {
            int[] array = method(); // 通过方法实例化数组
            print(array); // 向print()方法中传递数组
        }
        public static void print(int x[]) { // 接收数组
            for (int i = 0; i < x.length; i++) { // 循环输出
                System.out.print(x[i] + "");
            }
        }
        public static int[] method() { // 此方法返回一个数组引用
            int ss[] = { 1, 3, 5, 7, 9 }; // 定义一个数组
            return ss; // 返回数组
        }
    }
    

    执行结果:

    1 3 5 7 9 

     

    可变参数(JDK 1.5)

    JDK 1.5 开始,Java支持传递同类型的可变参数给一个方法。一个方法中只能指定一个可变参数,它必须是方法的最后一个参数。任何普通的参数必须在它之前声明。

    声明方式:

    返回值类型 方法名称(类型…参数名称){ // 在方法声明中,在指定参数类型后加一个省略号(...) 
        // 方法体
    }

    可变参数方法的使用与方法参数部分使用数组是一致的,例如可以循环输出所有的参数值。

    public static void print(String...names) { // 接收数组
        for(String name : names) {
            System.out.print(name + " "); 
        }
        System.out.println();
    }

    调用的时候可以给出任意多个参数也可不给参数,例如:

    public static void main(String[] args) {
        String[] names = {"jerry", "tom", "rose"};
        print(); // 不传递参数
        print("jerry", "tom"); // 传递多个参数
        print(names); // 传递数组
    }

    从以上代码可知,调用使用了可变参数的方法时:

    1)可以不写参数,即传入空参;

    2)可以直接在里边写入参数,参数间用逗号隔开;

    3)可以传入一个数组;

     

     

     

    可变参数的使用规则

    1) 拥有可变参数的方法可以被重载,在调用方法的时候,如果能够和固定参数的方法匹配,也能够与可变长参数的方法匹配,则选择固定参数的方法。

    public class Test {
        public static void main(String[] args) {
            print();
            print("jerry");
            print("jerry", "tom");
        }
        public static void print(String...names) { // 接收数组
            System.out.print("可变参数方法: ");
            for(String name : names) {
                System.out.print(name + " "); 
            }
            System.out.print("\n");
        }
        public static void print(String name) { // 接收一个String类型参数
            System.out.println("固定参数方法: " + name);
        }
    }

    执行结果如下:

    可变参数方法: 
    固定参数方法: jerry
    可变参数方法: jerry tom 

    2)如果要调用的方法可以和两个可变参数匹配,则出现错误。

    public class Test {
        public static void main(String[] args) {
            print();
            print("jerry");  // 编译错误
            print("jerry", "tom"); // 编译错误
        }
        public static void print(String...names) {
            System.out.println("------1------");
        }
        public static void print(String name, String...names) { 
            System.out.println("------2------ ");
        }
    }
    

    main方法中的两个传参的调用都不能编译通过,因为编译器不知道该选哪个方法调用,如下所示:

    3)一个方法只能有一个可变长参数,并且这个可变长参数必须是该方法的最后一个参数

    public class Test {
        public static void print(String name, String...names) {
            System.out.println("------1------");
        }
        public static void print(int[] Ids, String...names) { 
            System.out.println("------2------ ");
        }
    }

    以下的方法定义都是错误的:

    4)可变参数可以兼容数组参数,但数组参数无法兼容可变参数。

    public class Test {
        public static void main(String[] args) {
        }
        public void print(String... names){
            System.out.println("-----1-----");
        } 
        public void print(String[] names){ 
            System.out.println("-----2-----");
        }
    }

    当试图使用数组作为参数去实现重载时,会报错,说明可变参数与数组冲突(两者应该是一方能兼容另一方)。

    public class Test {
        public static void main(String[] args) {
            Test test = new Test();
            test.print("jerry","tom");
        }
        public  void print(String[] namse){ 
            System.out.println("----------");
        }
    }

    如果定义一个参数为数组的方法,像调用可变参数的方法一样调用它是会报错,说明可变参数并不是一个数组。

     

    可变长参数的使用规范

    1) 避免带有可变长参数的方法重载

    例如上面使用规则的第一个例子,编译器虽然知道怎么调用,但人容易陷入调用的陷阱及误区。

    2) 别让null值和空值威胁到变长方法

    public class Test {
        public static void main(String[] args) {
            print("人事部");
            print("jerry", null);
        }
        public static void print(String dept, Integer...Ids) {
        }
        public static void print(String name, String...names ){
        }
    }

    以上main方法里的两个调用编译都不通过:

    因为两个方法都匹配,编译器不知道选哪个,于是报错了,这里同时还有个非常不好的编码习惯,即调用者隐藏了实参类型,这是非常危险的,不仅仅调用者需要“猜测”该调用哪个方法,而且被调用者也可能产生内部逻辑混乱的情况。对于本例来说应该做如下修改:

    public static void main(String[] args) {
        String[] names = null;
        print("jerry", names);
    }

    3)重写(覆写)可变参数方法也要循规蹈矩

    public class Test {
        public static void main(String[] args) {
            // 向上转型
            Base base = new Sub();
            base.print("hello");
            // 不转型
            Sub sub = new Sub();
            sub.print("hello");
        }
    }
    //基类
    class Base {
        void print(String... args) {
            System.out.println("Base......test");
        }
    }
    //子类,覆写父类方法
    class Sub extends Base {
        @Override
        void print(String[] args) {
            System.out.println("Sub......test");
        }
    }

    以上main方法中第二个调用编译不通过:

    第一个能编译通过,这是为什么呢?事实上,base对象把子类对象sub做了向上转型,形参列表是由父类决定的,当然能通过。再看看子类直接调用的情况,这时编译器看到子类覆写了父类的print方法,因此肯定使用子类重新定义的print方法,尽管参数列表不匹配也不会跑到父类再去匹配下,因为找到了就不再找了,因此有了类型不匹配的错误。

    这是个特例,重写的方法参数列表与父类不相同,这违背了重写的定义,并且会引发莫名其妙的错误。在这里,我们再复习下重写必须满足的条件:

    1)重写方法不能缩小访问权限;

    2)参数列表必须与被重写方法相同(包括显示形式);

    3)返回类型必须与被重写方法的相同或是其子类;

    4)重写方法不能抛出新的异常,或者超过了父类范围的异常,但是可以抛出更少、更有限的异常,或者不抛出异常。

     

    最后,我们看下面一个有陷阱的例子:

    public class Test {
        public static void main(String[] args) {
            print("");
            print("jerry");
            print("jerry", "tom");
        }
        public static void print(String name, String... names) {
            for (int i = 0; i < names.length; i++) {
                System.out.println(names[i]);
            }
        }
    }

    以上代码是能够正常编译执行的,它的执行结果如下:

    tom

     

     

    展开全文
  • 可变参数函数详解

    千次阅读 2019-04-08 13:00:39
    可变参数函数又称参数个数可变函数(本文也简称变参函数),即函数参数数目可变。原型声明格式为: type VarArgFunc(type FixedArg1, type FixedArg2, …); 其中,参数可分为两部分:数目确定的固定参数...
  • C++可变参数模板

    千次阅读 2019-06-11 21:53:06
    可变参数模板是一个接受可变数目参数的模板函数或模板类,在模板参数列表中,typename…指出接下来的参数表示0个或多个类型的列表,一个类型名后面跟省略号表示0个或多个给定类型的非类型参数的列表。在函数参数列表...
  • Java可变参数

    万次阅读 多人点赞 2016-10-24 13:28:31
    什么是可变参数 在 Java 5 中提供了变长参数,允许在调用方法时传入不定长度的参数。变长参数是Java的一个语法糖,本质上还是基于数组的实现 void foo(String... args); void foo(String[] args); //方法签名 (...
  • Java中的可变参数

    千次阅读 多人点赞 2019-04-18 11:21:22
      在学习Java的过程中,我发现了Java有一种方法可以传递数量可变的参数列表,于是就仔细的去了解一下关于可变参数的相关知识。下面我将对可变参数做出我的理解。   首先说一下定义可变参数的方法:   只要在...
  • C++可变参数模板函数基本用法

    千次阅读 2019-07-17 23:08:32
    可变参数模板可以创建任意个参数的模板函数和模板类,本文主要介绍可变参数模板函数。 1.1可变参数模板函数声明和定义 template<typename... Args> //Args是一个模板参数包 void Show(Args... args) //args...
  • Java中的可变参数方法

    千次阅读 2019-04-13 11:22:53
    为了比较直观地说明Java的可变参数方法,我们举个例子: //求若干个整型数中的最大值 public int getMax(int... items){ //定义可变参数items int max = Integer.MIN_VALUE; //次数为int能表示的最小值,值为-...
  • Java可变参数以及一个简单应用

    万次阅读 多人点赞 2019-06-13 22:46:42
    一、背景 写代码的时候接触到了Java可变... 可变参数:适用于参数个数不确定,类型确定的情况,java把可变参数当做数组处理。 注意:可变参数必须位于最后一项。 2.2 特点 只能出现在参数列表的最后; ...位...
  • 在开始讨论python各种类型的参数前,先介绍一个新知识inspect模块, 这个模块可以很好的展示出一个函数的参数信息,如下例: from inspect import signature def func(a,b,*var, c, d, e=3, **kw): pass sig = ...
  • C++11:可变参数的模板

    万次阅读 多人点赞 2017-08-19 00:14:02
    可变参数模板和普通模板的语义是一样的,只是写法上稍有区别,声明可变参数模板时需要在typename或class后面带上省略号“…”:template<class ... T> void func(T ... args)//T叫模板参数包,args叫函数
  • 【Java】Java反射调用可变参数的方法

    千次阅读 2020-08-28 23:00:46
    但是测试过程中,有一点我不明白,就是反射调用可变参数的方法时,为什么一定要保证传入的参数数组长度为1, 然后如下 package com.java.reflect.demo; public class BaseObject { public void getObjectName() ...
  • ES5和ES6可变参数

    千次阅读 2018-08-17 08:42:07
    在ES5中,可变参数依靠arguments,代码如下: &amp;lt;!DOCTYPE html&amp;gt; &amp;lt;html&amp;gt; &amp;lt;head&amp;gt; &amp;lt;meta charset=&quot;utf-8&quot;&...
  • 1、定义了一个需要两个参数的函数 def print_str(first, second): print first print second if __name__ == "__main__": print_str("hello", "world") 如果传一个参数调用,print_str("hello"),那么一定会...
  • C语言之传递可变参数

    万次阅读 2017-05-24 22:18:39
    C语言之传递可变参数文章链接:知识点 传递int可变参数个数; 传递char类型可变参数个数; 传递logn类型可变参数个数; 传递可变参数个数特例; 新名词记录{stdarg.h, va_list, va _start(), va _arg(), va _end()} ...
  • c++如何实现可变参数

    千次阅读 2019-08-05 23:02:32
    除了用可变参数宏外,还可以用initializer_list int initializerSum(initializer_list<int> il) { int sum = 0; for (auto ptr = il.begin(); ptr != il.end(); ptr++) //类似于容器的操作 { sum += ...
  • 定义Java可变参数方法package com.tcl.john.studymvvm.utils;/** * 调用Java方法的工具类 * Created by ZhangJun on 2017/10/25. */public class CallJavaUtils { public static int addNumbers(String name, int...
  • C语言中可变参数的使用方法

    千次阅读 2018-03-14 22:45:51
    其实,可变参数这个东东自从入门C语言开始就一直在使用,最经典的就是printf打印输出。不论是从事嵌入式开发,还是搞Android的NDK开发,经常会用到可变参数输出log,但是很多时候是用别人封装好的API,而忽略了事情...
  • C++中传递可变参数

    千次阅读 2018-11-28 12:06:18
    std::string &amp; getFormattedStr(std::string &amp;strFormatted, const char *strFormat, va_list arglist) { const int MAX_FORMATTED_STR_LEN = 2048; char strResult[MAX_FORMATTED_STR_LEN] = { 0...
  • Python中必选参数、默认参数、可变参数、命名关键字参数、关键字参数的区别:
  • Java方法传参之可变参数

    千次阅读 2020-06-05 16:55:42
    * [可变参数] * 方法传参之可变参数 * 在JDK1.5后,若方法内需要传递多个相同类型的参数,可以使用简化形式; * 语法:访问修饰符 返回值类型 方法名(参数类型 ... 参数名){}; * 等价于:访问修饰符 返回值类型 方法...
  • C#之方法的可变参数(params)

    千次阅读 2018-01-27 11:17:47
    今天笔者看了网上的很多关于基础的可变参数的用法,说实话,以我的感觉很多人都没有把这个问题说清楚。有一些所谓大神更是将数组作为实参传递给一个可变参数作为可变参数的使用案例来讲。虽然这也是可以的,但是遇到...
  • java 可变参数--传数组(转)

    千次阅读 2019-05-21 14:28:11
    m.out.println(); • } • • public static void main...可以看出来这个可变参数既可以是没有参数(空参数),也可以是不定长的。看到这里估计都能明白,这个不定长的参数其实和数组参数挺像的。事实上,也确
  • C++可变参数函数

    万次阅读 多人点赞 2016-06-11 20:26:45
    C++可变参数函数的三种实现方法:C风格实现,基于initializer_list,和基于模板。三种实现方法的比较和优缺点总结。
  • 揭密X86架构C可变参数函数实现原理

    千次阅读 多人点赞 2018-04-01 00:48:13
    前两天公司论坛有同事在问C语言可变参数函数中的va_start,va_arg 和 va_end 这些接口怎么实现的?我毫不犹豫翻开箱底,将多年前前(算算有十年了)写的文章「亲密接触C可变参数函数」发给他,然后开始了深入的技术...
  • 可变参数:适用于参数个数不确定,类型确定的情况,java把可变参数当做数组处理。注意:可变参数必须位于最后一项。当可变参数个数多于一个时,必将有一个不是最后一项,所以只支持有一个可变参数。因为参数个数不定...
  • 深度解析Java可变参数类型以及与数组的区别

    万次阅读 多人点赞 2017-09-19 19:22:46
    深度解析Java可变参数类型以及它与数组的区别
  • C++中可变参数宏定义用法实践

    千次阅读 2019-09-07 14:44:39
    本博文的目的是记录在C++中使用可变参数宏定义的过程,通过一些实际编写的代码和查看效果,来熟悉可变参数宏定义的使用方法和注意事项。 由于查询的资料来看,这种可变参数宏定义实际表现效果与所用的语言和编译器...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,124,601
精华内容 449,840
关键字:

可变参数