函数参数_函数参数类型 - CSDN
精华内容
参与话题
  • 函数参数(形参与实参)的理解

    千次阅读 2019-09-08 10:34:28
    函数参数 实际参数(实参) 真实传给函数参数,叫实参。实参可以是:常量、变量、表达式、函数等。无论实参是何种类型的量,在进行函数调用时,它们必须有确定的值,以便把这些值传送给形参。 形式参数(形参...

    函数的参数

    实际参数(实参)

    真实传给函数的参数,叫实参。实参可以是:常量、变量、表达式、函数等。无论实参是何种类型的量,在进行函数调用时,它们必须有确定的值,以便把这些值传送给形参。

    形式参数(形参)

    形式参数是指函数名后括号中的变量。因为形式参数只有在函数被调用的过程中才实例化(分配内存单元),所以叫形式参数。形式参数当函数调用完成之后就自动销毁了。因此形式参数只在函数中有效。

    我们写一段代码感受一下:

    #include<stdio.h>
    #include<stdlib.h>
    void Swap1(int x, int y)
    {
    	int tmp = 0;
    	tmp = x;
    	x = y;
    	y = tmp;
    }
    void Swap2(int *px, int *py)
    {
    	int tmp = 0;
    	tmp = *px;
    	*px = *py;
    	*py = tmp;
    }
    int main()
    {
    	int num1 = 1;
    	int num2 = 2;
    	Swap1(num1, num2);
    	printf("%d %d\n", num1, num2);
    	Swap2(&num1, &num2);
    	printf("%d %d\n", num1, num2);
    	system("pause");
    	return 0;
    }
    

    输出结果:
    在这里插入图片描述
    上面Swap1和Swap2函数中的参数想x,y,px,py都是形式参数。在main函数中传给Swap1的num1和num2和传 给Swap2函数的&num1,&num2是实际参数。

    让我们对函数的形参与实参进行分析:
    在这里插入图片描述
    代码对应的内存分配:
    在这里插入图片描述
    这里可以看到Swap1函数在调用的时候,x,y拥有自己的空间,同时拥有了和实参一模一样的内容。所以我们可以 简单的认为:形参实例化之后其实相当于实参的一份临时拷贝。

    展开全文
  • 函数参数 实际参数(实参): 真实传给函数参数,叫实参。实参可以是:常量、变量、表达式、函数等。无论实参是何种类型的量,在进行函数调用时,它们都必须有确定的值,以便把这些值传送给形参。 形式参数...

    函数的参数
    实际参数(实参):
    真实传给函数的参数,叫实参。实参可以是:常量、变量、表达式、函数等。无论实参是何种类型的量,在进行函数调用时,它们都必须有确定的值,以便把这些值传送给形参。
    形式参数(形参)
    形式参数是指函数名后括号中的变量,因为形式参数只有在函数被调用的过程中才实例化(分配内存单元),所以叫形式参数。形式参数当函数调用完成之后就自动销毁了。因此形式参数只在函数中有效。
    void Swap1(int x, int y)
    {
    int temp = 0;
    tmp = x;
    x = y;
    y = temp;
    }
    void Swap2(int *px, int *py)
    {
    int temp = 0;
    tmp = *px;
    *px = *py;
    *py = temp;
    }
    上面Swap1和Swap2函数中的参数 x,y,px,py 都是形式参数
    在main函数中调用这两个函数传的参数是实际参数

    展开全文
  • 引用与引用作为函数参数

    千次阅读 2018-08-11 22:48:31
    int InitStack(SqStack &amp;S)与int InitStack(SqStack *S)有区别: 1、&amp;S是引用,S和传入的形参变量共用同一个存储空间,相当于别名。 2、*S是指针,S是指针变量,它是有自己的存储空间的,只是它的...

    int InitStack(SqStack &S)与int InitStack(SqStack *S)有区别:

    1、&S是引用,S和传入的形参变量共用同一个存储空间,相当于别名。
    2、*S是指针,S是指针变量,它是有自己的存储空间的,只是它的存储空间存的是形参变量的地址。

     

    对一个数据建立一个“引用”,他的作用是为一个变量起一个别名。这是C++对C语言的一个重要补充。

    如何建立一个引用

        int a = 5;
        int &b = a;
        cout<<a<<endl;
        cout<<b<<endl;
        cout<<&a<<endl;
        cout<<&b<<endl;

    上声明了b是a的引用,并把a,b的值和它们的地址打印出来。经过声明后b是a别名,b与a代表的是同一个变量,占内存中同一个存储单元,具有同一地址。

    注意&符号作为取地址符合作为引用声明符的区别,在上述程序中的第2行,&在数据类型后,为引用声明符。而第5、6行,&为取地址符。可以用这个方法作区分:只有在数据类型后&才是引用声明符。

    打印结果: 
    这里写图片描述

    从上述结果可以看到,a与b地址是相同的。

    使用引用的一些注意事项: 
    (1)声明一个引用时,必须同时使之初始化,及声明它代表哪一个变量。(有一个例外,引用作为函数参数时,不需要初始化) 
    (2)在声明一个引用后,不能再使之作为另一变量的引用。 
    (3)不能建立引用数组。

    引用的作用:

    C++加入了在C语言的基础加入了引用机制,那么引用到底有什么用呢?不会只是为了给函数起一个小名吧?显然不是,引用最用要的意义在于作为函数的参数,以扩充函数传递参数的能力。它是如何实现的?这要从C语言参数传递开始说起:

    我们知道,C语言在调用函数时,传参主要有两种形式: 
    (1)变量名作为实参和形参 
    这种方式传给形参的是变量的值,传递是单向的。如果在执行函数器件形参的值变了,不会回传给实参。也就是说如果想要实现一个这样的功能:调用函数后实参的值随之改变。显然此方式无法实现。

    举个例子: 
    执行swap函数后,想要主函数内的变量值变化,用上述方式写出代码:

    #include <iostream>
    using namespace std;
    int main()
    {
          void swap(int ,int);
          int i =3,j = 5;
          swap(i,j);
          cout<<"i="<<i<<endl<<"j="<<j<<endl;
          getchar();
          return 0;
    }
    
    void swap(int a,int b)
    {
        int temp;
        temp = a;
        a =b;
        b= temp;
    }
    

    行结果: 
    i = 3 
    j = 5

    显然值没有带回,i和j的值在执行后没有发生变化。

    (2)传递变量的地址

    该方式形参是指针变量,实参是一个变量的地址,调用函数时,形参得到的实参变量的地址,因此指向实参的变量单元。 
    然后我们修改下上面的程序:

    #include <iostream>
    using namespace std;
    int main()
    {
          void swap(int * ,int*);
          int i =3,j = 5;
          swap(&i,&j);
         cout<<"i="<<i<<endl<<"j="<<j<<endl;
          getchar();
          return 0;
    }
    
    void swap(int *a,int *b)
    {
        int temp;
        temp = *a;
        *a =*b;
        *b= temp;
    }

    行结果: 
    i = 5 
    j = 3

    在程序的第13行,定义的函数的形参是指针,在第6行,调用的函数是传入的函数实参是变量的地址,实现了i和j的交换,但是这种方法不够直观,而且依旧是“值传递”的方式,只不过传递的是变量的地址而已。

    然后,如果我们使用引用功能,可以很简单的实现这个功能,而且很容易理解: 
    (3)引用作为函数参数

    #include <iostream>
    using namespace std;
    int main()
    {
          void swap(int & ,int&);
          int i =3,j = 5;
          swap(i,j);
         cout<<"i="<<i<<endl<<"j="<<j<<endl;
          getchar();
          return 0;
    }
    
    void swap(int &a,int &b)
    {
        int temp;
        temp = a;
        a =b;
        b= temp;
    }
    

    行结果: 
    i = 5 
    j = 3

    第13行,形参是声明的引用,注意这个引用并没有初始化,这就是上面提到的特例。而在第7行调用函数的过程中,实现了引用的初始化,这是传入的实参就是变量,而不是数值,所以做到了真正意义上的“变量传递”。

    展开全文
  • 函数参数

    2020-06-21 19:26:00
    类似于局部变量,函数的形参为函数提供了已命名的局部存储空间 函数不能返回另一个函数或者内置数组类型,但可以返回指向函数的指针,或指向数组元素的指针的指针 每次调用函数时,都会重新创建该函数所有的形参,...
    • 类似于局部变量,函数的形参为函数提供了已命名的局部存储空间
    • 函数不能返回另一个函数或者内置数组类型,但可以返回指向函数的指针,或指向数组元素的指针的指针
    • 每次调用函数时,都会重新创建该函数所有的形参,此时所传递的实参将会初始化对应的形参。
      形参的初始化与变量的初始化一样:如果形参具有非引用类型,则复制实参的值,如果形参为引用类型(第 2.5 节),则它只是实参的别名
    • 在 C 语言中,具有 const 形参或非 const 形参的函数并无区别
    • 利用 const 引用避免复制
    • 不需要在函数内改变实参的值时,不应将形参定义为引用,否则可能错误修改实参的值
    • 应该将不修改相应实参的形参定义为 const 引用。如果将这样的形参定义为非 const 引用,则毫无必要地限制了该函数的使用
      1 string func(const string &s)
      2 {
      3     return s;
      4 }
      5 int main()
      6 {
      7     cout << func("ddd");
      8     return 0;
      9 }

      如果将func形参定义为非const,则字符串常量不能作为实参传入

    • 传递指向指针的引用

      1 int *&v1
      2 //v1 是一个引用,与指向 int 型对象的指针相关联
    • 通常,函数不应该有 vector 或其他标准库容器类型的形参。调用含有普通的非引用 vector 形参的函数将会复制 vector 的每一个元素 。从避免复制 vector 的角度出发,应考虑将形参声明为引用类型。然而,看过第十一章后我们会知道,事实上,C++ 程序员倾向于通过传递指向容器中需要处理的元素的迭代器来传递容器
       1 #include <iostream>
       2 #include <vector>
       3 using namespace std;
       4 void print_(vector<int>::iterator it1, vector<int>::iterator it2)
       5 {
       6     for(vector<int>::iterator it = it1; it != it2; ++it)
       7     {
       8         cout << *it << ' ';
       9     }
      10     cout << endl;
      11 }
      12 int main()
      13 {
      14     vector<int> v(10);
      15     print_(v.begin(), v.end());
      16     return 0;
      17 }

    • 数组形参

      1 // three equivalent definitions of printValues
      2 void printValues(int*) { /* ... */ }
      3 void printValues(int[]) { /* ... */ }
      4 void printValues(int[10]) { /* ... */ } //编译器忽略为任何数组形参指定的长度。
      当编译器检查数组形参关联的实参时,(非引用传参情况下)它只会检查实参是不是指针、指针的类型和数组元素的类型时是否匹配,而不会检查数组的长度
    • 不需要修改数组形参的元素时,函数应该将形参定义为指向 const 对象的指针
    • 通过引用传递数组
      如果形参是数组的引用,编译器不会将数组实参转化为指针,而是传递数组的引用本身。在这种情况下,数组大小成为形参和实参类型的一部分。 编译器检查数组的实参的大小与形参的大小是否匹配
    • 只严格地接受含有 10 个 int 型数值的数组
       1 #include <iostream>
       2 #include <vector>
       3 using namespace std;
       4 void print_(int (&a)[10]) //&arr 两边的圆括号是必需的,因为下标操作符具有更高的优先 
       5 {
       6     for(int i = 0; i<10; ++i)
       7         cout << a[i] << ' ';
       8     cout << endl;
       9 }
      10 int main()
      11 {
      12     int a[10]{0};
      13     print_(a);
      14     print_(a);
      15     return 0;
      16 }
      //把a大小改为11时,不能通过编译
    • 多维数组的传递
       1 #include <iostream>
       2 #include <vector>
       3 using namespace std;
       4 void print_(int (*a)[10])// void print_(int a[][10]), 
       5 {
       6     for(int i = 0; i<2; ++i)
       7         for(int j = 0; j<10; ++j)
       8             cout << a[i][j] <<endl;
       9 }
      10 int main()
      11 {
      12     int a[10][10]={};
      13     a[0][7] = 32;
      14     print_(a);
      15     return 0;
      16 }

    • 可以通过传递指向数组第一个和最后一个元素的下一个位置的指针来传参

    •  1 // const int ia[] is equivalent to const int* ia
       2 // size is passed explicitly and used to control access to elements of ia
       3 #include <iostream>
       4 using namespace std;
       5 void printValues(const int ia[], size_t size)
       6 {
       7    for (size_t i = 0; i != size; ++i) {
       8      cout << ia[i] << endl;
       9    }
      10 }
      11 int main()
      12 {
      13      int j[] = { 0, 1 }; // int array of size 2
      14      printValues(j, sizeof(j)/sizeof(*j));
      15      return 0;
      16 }
    • 当函数需要处理数组且函数体不依赖于数组的长度时应使用指针形参,其他情况下应使用引用形参
    • main函数参
       1 // const int ia[] is equivalent to const int* ia
       2 // size is passed explicitly and used to control access to elements of ia
       3 #include <iostream>
       4 using namespace std;
       5 int main(int argc, char *argv[])
       6 {
       7     for(int i=0; i<argc; ++i)//argc表示字符串个数
       8         cout << argv[i] << endl;
       9     return 0;
      10 }
    • 1 #include <iostream>
      2 #include <cstdlib>
      3 using namespace std;
      4 int main(int argc, char *argv[])
      5 {
      6        cout << atoi(argv[1]) + atoi(argv[2]) <<endl;
      7     return 0;
      8 }



    • 含可变参数的函数
    展开全文
  • 函数定义以及参数

    千次阅读 2018-01-02 20:33:15
    一、什么叫函数 1.函数就是完成特定功能的一个语句组,这组语句可以作为一个单位使用,并且给他取一个名字。 可以通过函数名在程序的不同地方多次执行。(函数调用) 函数分为预定义函数和自定义函数。 ...
  • 先看三种方式实现函数参数传递的实例程序 * 输入描述:两个待交换的整数 * 程序输出:交换后得两个整数 #include<stdio.h> void myswap(int x, int y) { int t; t=x; x=y; y=t; } int main() { int a...
  • C语言中函数参数传递的三种方式

    万次阅读 多人点赞 2017-07-22 21:09:40
    C语言中函数参数传递的三种方式(1)传值,就是把你的变量的值传递给函数的形式参数,实际就是用变量的值来新生成一个形式参数,因而在函数里对形参的改变不会影响到函数外的变量的值。(2)传址,就是传变量的地址...
  • 函数参数详解

    2020-03-09 15:08:58
    函数参数的分类: 实参分类: 1、位置传参:通过位置按顺序传递 2、关键字传参:通过参数名指定参数进行传递 形参的分类: 1、必备参数/必需参数:定义几个就要传几个 2、默认参数(缺省参数):可传可不传,不传的...
  • (struct)结构体变量作为函数参数调用的方法小结

    万次阅读 多人点赞 2015-04-29 19:37:38
    结构体变量作为函数参数传递的3种方法 将一个结构体变量中的数据传递给另一个函数,有下列3种方法: 用结构体变量名作参数。一般较少用这种方法。 用指向结构体变量的指针作实参,将结构体变量的地址传给形参。 用...
  • 函数参数的默认值

    千次阅读 2018-01-21 21:59:47
    函数参数的默认值 基本用法 ES6 之前,不能直接为函数的参数指定默认值,只能采用变通的方法。 function log(x, y) { y = y || 'World'; console.log(x, y);}log('Hello') // Hello Worldlog('Hello', 'China...
  • C语言二维数组作为函数参数传递

    万次阅读 多人点赞 2018-06-07 21:43:37
    二维数组作为函数参数 二维数组作为函数的参数,实参可以直接使用二维数组名,在被调用函数中可以定义形参所有维数的大小,也可以省略以为大小的说明。例如: void find(char a[3][10]); void find (char a[ ]...
  • C++结构体作为函数参数传参

    万次阅读 2020-06-25 10:45:56
    #include<iostream> using namespace std; #include<... *结构体作为函数参数传参 */ //值传递 void printStufdent1(struct Student st3) { cout << "子函数" << endl; st3.age .
  • 转载于:http://blog.csdn.net/vlily/article/details/7244682 转载于:http://blog.csdn.net/shengnan_wu/article/details/8116935 转载于:http://blog.csdn.net/callmeback/article/details/4242260/ ...
  • C语言函数参数传递的分析

    万次阅读 2013-12-29 20:16:31
    值传递,即按值传递参数,按值传递参数时,是将实参变量的值复制一个到临时存储单元中,如果在调用过程中改变了形参的值,不会影响实参变量本身,即实参变量保持调用前的值不变。 1、形参只能是变量,实参可以是常量...
  • 字符串赋值:strcpy_s(pstu->name, "张三"); 需要引入头文件:#include <string.h> #include <stdio.h> #include <string.h> struct Student { int age;...void InputStud...
  • http://www.liaoxuefeng.com/wiki/001374738125095c955c1e6d8bb493182103fac9270762a000/001374738449338c8a122a7f2e047899fc162f4a7205ea3000########################################################函数参数:...
  • C语言 数组做函数参数

    万次阅读 2018-04-25 00:20:51
    看下面代码:int main() { int a[5]={3,6,4,2,5}; char *ptrChar="hello world";//ptrChar是char类型的指针,指向内存空间 int *ptrInt=a;//ptrInt是指向int类型的指针 printf("...
  • Matlab 函数参数汇总

    千次阅读 2008-10-26 09:21:00
    Matlab 函数参数汇总MATLAB函数参考附录1.1 管理用命令函数名 功能描述 函数名 功能描述addpath 增加一条搜索路径 rmpath 删除一条搜索路径demo 运行Matlab演示程序 type 列出.M文件doc 装入超文本文档 version 显示...
  • 结构体、结构指针作为函数参数

    千次阅读 2019-05-20 07:19:25
    结构体、结构指针作为函数参数 结构体、结构体指针作为函数的参数现在应用的非常广泛,但一些细微之处还需要引起注意。本文将讨论其作为形参和实参的区别。 结构体作为参数 将结构体作为函数的参数,目的是通过...
  • ES6函数参数解构

    万次阅读 2018-10-10 20:23:44
    ES6函数参数解构 常规的JavaScript若要给函数传递的参数是一个对象,需要像下面这样来实现: function sayName(person) { if(Object.prototype.toString.call(person) == '[object Object]') { console.log( `${...
1 2 3 4 5 ... 20
收藏数 3,617,712
精华内容 1,447,084
关键字:

函数参数