精华内容
下载资源
问答
  • Java调用C语言动态库(JNA方式):回调函数、结构体数组传参、结构体数组返回-附件资源
  • 数组传参

    2019-06-27 19:49:21
    今天说一下用数组进行传参,先是获取到需要的数据,接着就是赋值到数组里面进行保存。日期就是获取到当前的日期进行编辑保存,保存完了就可以进行传参了。下面是视图的代码。 $("#sure").click(function () { var ...

    今天说一下用数组进行传参,先是获取到需要的数据,接着就是赋值到数组里面进行保存。日期就是获取到当前的日期进行编辑保存,保存完了就可以进行传参了。下面是视图的代码。

    $("#sure").click(function () {
                var CurrentTicketNumber = $("input[name='CurrentTicketNumber']").val();
                var StartTicketNumber = $("input[name='StartTicketNumber']").val();
                var BillType = $("select[name='BillType']").val();
                var Remarks = $("input[name='Remarks']").val();
                if (aaa != "" && bbb != "" && ccc != "" && ddd != "") {
                 var sum = new Object();
                 sum.CurrentTicketNumber = CurrentTicketNumber;
                 sum.StartTicketNumber = StartTicketNumber;
                 sum.BillType = BillType;
                 sum.Remarks = Remarks;
                 var now = new Date;
                 var day = ("0" + now.getDate()).slice(-2);//格式化日,如果小于9,前面补0
                 var month = ("0" + (now.getMonth() + 1)).slice(-2);//格式化月
                 var today = now.getFullYear() + "-" + (month) + "-" + (day);//拼装完整日期
                 sum.TicketingDate = today;
                 $.post("NewBill", sum, function (data) { layer.msg(data.Text, { icon: 0 })
                        if (data.State == true) {
                            tableReload();         $("#modal").hide();
                            $("input[type='reset']").click();
                        }
                    })
                }
            })
    

    接着就到了控制器的代码了,参数可以用表的形式一并接收,也可以用单个的具体的参数接收,只要参数名能对上就是可以的。

    public ActionResult NewBill(R_Bill Bill){
                ReturnJson returnJson = new ReturnJson();
              try {
                    var bill = (from tb in myModuls.R_Bill
                                where tb.TicketingDate == Bill.TicketingDate
                                select tb).Count();
                    if (bill==0){
                        myModuls.R_Bill.Add(Bill);
                        if (myModuls.SaveChanges()>0){
                            returnJson.State = true;
                            returnJson.Text = "成功入库";
                        }
                    }else{
                        returnJson.State = false;
                        returnJson.Text = "该时间已经有数据入库,请稍后...";
                    }
                }catch (Exception){
                    returnJson.State = false;
                    returnJson.Text = "数据异常";
                }
                return Json(returnJson, JsonRequestBehavior.AllowGet);
            }
    

    控制只做了简单的判断,确保在该入库的时间内不重复就好了,代码到这里就可以说是完整的了。接着看一下效果图。第一张是新增的内容,第二张是新增后查询出来的。用的就是数组的方法。
    在这里插入图片描述
    在这里插入图片描述

    展开全文
  • 二维数组传参问题

    2021-07-18 16:44:58
    前言:之前一直知道二维数组名是指针的指针,是一个二级指针,总想着在函数定义时把它定义为一个二级指针,可是一次也没成功过,直至这次实训遇到了这个二维数组传参问题,求助了一个同学才得以解决。本文解决 的...

    前言:之前一直知道二维数组名是指针的指针,是一个二级指针,总想着在函数定义时把它定义为一个二级指针,可是一次也没成功过,直至这次实训遇到了这个二维数组传参问题,求助了一个同学才得以解决。本文解决 的问题是怎么样将二维数组作为一个参数传递到函数中。
    步骤
    我们都知道在函数调用前需要先声明和实现。对于一个整型二维数组。其实在函数签名中写形参定义:int a[3][3],代表的就是这个函数中有一个3*3的整型数组。和函数调用时传进去的a[3][3]含义完全不同。这个a[3][3]代表的是一个元素,方括号内容是其索引下标。知道了这一点不同就好办了。因此如果你想让一个二维数组作为函数参数时,不需要再考虑什么二级指针什么的,只需要在函数签名里向定义一个二维数组一样写上你所需要数组的类型和大小,与此同时在函数调用的实参中把该函数名传进去即可。
    由于实参放进去的是一个数组名(二级指针即地址),因此从该种方式的函数传参属于地址传参。函数调用是可以改变传进去的实参的。
    例子证明

    #include<stdio.h>
    void Print(int a[3][3]){
    	for(int i=0;i<3;i++){
    		for(int j=0;j<3;j++)
    			printf("%-5d",a[i][j]);
    		printf("\n");
    		
    	}
    }
    void Change(int a[3][3]){
    	for(int i=0;i<3;i++){
    		for(int j=0;j<3;j++)
    		 	a[i][j]=1;
    	}
    }
    int main(){
    	int a[3][3]={0};
    	Print(a);
    	Change(a);
    	Print(a);
    	return 0;
    	
    }
    

    上述例子验证了这样传递二维数组的正确性和传址传递的正确性。

    展开全文
  • 数组传参问题

    2021-05-23 17:53:48
    数组问题 1)数组作为参数传递时,由于传递的是首个元素的地址,是一个指针,传输效率快。所以不能通过sizeof 关键字来求出所占内存的大小。但是如果是一个字符串的话,由于其后默认带有 “\0” 标识,因此可以求出...

    数组问题

    1)数组作为参数传递时,由于传递的是首个元素的地址,是一个指针,传输效率快,且长度为变量。sizeof 关键字求出所占内存的大小是在编译时得到的。一般通过以下形式处理。

    #include"stdio.h"
    
    void fun(int array[],int len);
    int main()
    {
    	int array[]={1,2,3};
    	fun(array,sizeof(array)/sizeof(int));
    	return 0;
    }
    

    2)打印字符串可以直接通过以下形式打印。

    #include"stdio.h"
    
    
    int main()
    {
    	char *str="hello,world!";
    	printf(str);
    	return 0;
    }
    

    3)如果是一个字符数组的话,由于其后默认带有 “\0” 标识,可以通过 printf 打印出来

    #include"stdio.h"
    void fun(char *s)
    {
    	printf(s);
    }
    int main(void)
    {
    	char s[]={'H','F','\0'};
    	//char *s="HF";//默认带有\0
    	//char s[]={'H','F'};
    	return 0;
    }
    
    展开全文
  • 初学 angularjs时,对 数组传参方式感到很好奇([‘a’, ‘b’, function(a,b){}]),它到底怎么实现的呢?后来由于工作很忙,对这个问题也就慢慢忘记了。 今天闲来无事,有想到了这个问题。最简单的方法就是查看...
  • [C] 数组指针、指针数组及数组传参

    千次阅读 多人点赞 2019-01-30 18:30:31
    指针字符指针数组指针指针数组 在指针的学习阶段,有不少同学都十分畏惧这个物什,甚至“谈指针色变”。其实对指针的不理解,其实本质上是对内存的不理解,本篇博客就从零开始、系统的来讲解指针这个话题。 首先...


    小引

    在指针的学习阶段,有不少同学都十分畏惧这个物什,甚至“谈指针色变”。其实对指针的不理解,其实本质上是对内存的不理解,本篇博客就从零开始、系统的来讲解指针这个话题。


    首先我们应该明确以下的一些基础常识:

    1. 指针是一个变量,用来存放地址,地址唯一标识一块内存地址。
    2. 指针的大小是固定的4 或 8个字节。(3264位平台)
    3. 指针是有类型的,指针的类型决定了指针加减整数运算的步长,以及指针解引用时的权限。

    字符指针

    顾名思义,就是指向字符变量的指针,指针内存放的内容是一个字符。它的一般写法如下:

    int main(){
    	char ch = 'w';
    	char *ptr = &ch;
    	*ptr = 'w';
    	return 0;
    }
    

    如果此时对ptr进行strlen,就会内存访问越界,属于未定义行为,结果不可预期。因为指针指向的是一个字符而不是字符串。

    指向单个字符的使用方式简单明了,但是相对于下面的这种常见的指向字符串的使用方式,就相形见绌了。

    int main(){
    	char *ptr_1 = "this is a C string";
    	printf("%s\n",ptr_1);
    	return 0;
    }
    

    这样也可以间接的表现为指针指向了字符串
    代码中char *ptr_1 = "this is a C string";语句看似是将字符串放入了指针内,但其本质是将这个字符串的首地址存放到了指针内。

    如果此时对ptr_1进行strlen,就会正确的打印出字符串的个数,因为此时指针的指向不再是单个字符,而是字符串。
    其实编译器无法识别指针的指向是字符数组 还是字符串,所以它的指向需要使用者来定义保证。

    请看代码:

    int main(){
        char str1[] = "This is a C string.";
        char str2[] = "This is a C string.";
        char *str3 = "This is a C string.";
        char *str4 = "This is a C string.";
     
        if(str1 == str2)
            printf("str1 and str2 are same\n");
        else
            printf("str1 and str2 are not same\n");
           
        if(str3 == str4)
            printf("str3 and str4 are same\n");
        else
            printf("str3 and str4 are not same\n");
        return 0;
    }
    

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

    • 这里str3str4指针指向的是同一个常量字符串。C/C++语法上会把常量字符串存储到单独的一个内存区域,当几个不同的指针同时指向同一个字符串时,他们实际会指向同一块内存(这个字符串的首地址)。所以这几个指针其实是同一个指针。
    • 但是用相同的常量字符串对不同的数组进行初始化时就会在内存中开辟出不同的区域。指向其各自首地址的指针也就是不同的指针了。
      所以str1和str2不同,str3和str4不同。

    数组指针

    它的本质是指针,指针的指向是一个 数组。它的定义如下:

    int (*arr)[20];
    

    因为[]的优先级高于*,而()的优先级高于[]。所以加上圆括号()改变优先级顺序。(不加圆括号的情况下面会提及)
    先进行括号( )内的操作,这里变量名arr*结合就明确了他是一个指针变量,括号操作符完成再与其他元素进行结合,它指向了一个大小为10个整型元素的数组。

    【二维数组也是一个数组指针】

    • 对于arr&arr
      arr是数组名,数组名表示数组首元素的地址
      &arr就是数组指针,指针的指向是整个数组。

    请看如下代码:

    int main(){
        int arr[10] = {0};
        printf("%p\n", arr);
        printf("%p\n", &arr);
        return 0;
    }
    

    运行结果为:
    在这里插入图片描述
    二者输出内容相同,这就说明数组名& 数组名是等价的吗?其实不然,请看如下代码:

    int main(){
        int arr[10] = { 0 };
        printf("arr = %p\n", arr);
        printf("&arr = %p\n", &arr);
        printf("arr+1 = %p\n", arr+1);
        printf("&arr+1 = %p\n", &arr+1);
        return 0;
    }
    

    运行结果为:
    在这里插入图片描述
    这里对数组名 + 1& 数组名 + 1操作发现二者出现了区别,说明它们有着本质上的差别。
    arr指向数组首元素&arr是数组指针,指向数组,二者指向的地址是相同的但类型不同。
    arr + 1是指向数组首元素之后一个元素的指针。
    &arr + 1是指向下一个数组,跨过了整个数组,步距为数组元素的大小之和。

    与数组指针相混淆的有另一个名词:指针数组

    指针数组

    int *p1[10];
    

    它的本质是数组,数组中的所有元素都是 指针
    【二级指针也是一个指针数组】

    int *arr1[10]; 		//整型指针的数组
    char *arr2[4]; 		//一级字符指针的数组
    char **arr3[5];		//二级字符指针的数组
    

    具体举例:

    const char *arr[] = {
    	"hehe",
    	"haha",
    	"xixi"
    };
    
    • arr数组中的三个字符串也就是三个字符数组,数组可以隐式转换为指针,所以就可以使得arr的类型设为char *的字符指针类型,所以arr中三个元素的类型都是char *
    • 加上const关键字修饰本数组是为了确保数组内内容不发生改变。同时因为是三个字符串常量,其本身也不会发生改变。
      这样就定义好了一个指针数组。

    一维数组传参

    1. 整型数组

    对于数组:

    int arr[10] = { 0 };		
    

    使用以下函数进行传参:

    //	情况 1
    void test(int arr[])
    
    • 正确
      编译器会把函数的参数名arr识别为*arr的指针,与其数组大小无关,所以数组大小的参数省略书写也是完全可以的。

    //	情况 2
    void test(int arr[10])
    
    • 正确
      这是最直观的传参方式,实参和形参变量的类型、大小都相同,很容易理解和书写,是非常常见的一种写法。

    //	情况 3
    void test(int *arr)
    
    • 正确
      和情况1同义,编译器会把传入函数的数组参数隐式转化为指针*arr,数组元素也会转换成数组的移动,所以这种写法也是可以的。

    所以以上三种方法都是正确的,内涵也是相同的,读者使用时可以根据具体情况选择不同的表现形式,提高代码可读性。

    2. 指针数组

    对于数组:

    int *arr2[20] = { 0 };		
    

    使用以下函数进行传参:

    //	情况一
    void test2(int *arr[20])
    
    • 正确
      传参方式直观,实参与形参参数类型、大小均相同,便于理解。

    //	情况二
    void test2(int **arr)
    
    • 正确
      在这段代码中,可以把int*看作一个整体,将它typedef成为一个类型t
      那么实参中的数组定义就可以看成t arr2[20];了,调用函数传参就可以看成t *arr,就与上面所讲的一维整型数组传参如出一辙了。这样传参也是正确的。

    所以指针数组可以当做二级指针来传参


    二维数组传参

    对于数组:

    int arr[3][5] = {0};
    

    使用以下函数进行传参:

    //	情况 1
    void test(int arr[3][5])
    
    • 正确
      同样是最直观的写法,类型大小均相同,不多赘述。

    //	情况 2
    void test(int arr[][])
    
    • [×]不正确
      因为对于一个二维数组,两个[]中第一个数是行数,第二个数列数,行数可以目前不知道,但是每一行有多少元素,即列数,必须要知道,否则给定一串元素就不知道如何划分行列数,这样才会方便运算。

    //	情况 3 
    void test(int arr[][5])
    
    • 正确
      二维数组传参第一个数字可以省略,如若给定一部分数据,就可以根据列数计算出行数,这些工作都是自动完成的,所以C语言规定二维数组行数可以省略,但列数不可省。

    【小结】:

    二维数组传参,函数形参只能省略第一个[]的数字,第二个[ ]中的数字不可省略

    对一个二维数组,可以不知道有多少行,但是必须知道一行多少元素。


    //	情况一
    void test(int (*arr)[5])
    
    • 正确
      这样的写法是一个数组指针,可以正确传参。
      而除此之外,以下的其他写法都是错误的:

    //	情况二
    void test(int* arr[5])
    
    • [×]不正确
      这样的写法是一个指针数组,而二维数组的传参应该是一个数组指针,错误。

    //	情况三
    void test(int *arr)
    
    • [×]不正确
      作为一级指针传入数组会造成实参与形参类型不符,错误。

    //	情况四
    void test(int **arr)
    
    • [×]不正确
      和第二种情况是等效的,正是因为指针数组可以当做二级指针来传参,两者可以互相转化,错误。

    【小结】:二维数组可以作为 数组指针 传参

    一级指针传参

    常见的传参方式如下:

    void print(int *p, int sz){
    	int i = 0;
    	for(i = 0;i < sz;i++){
    		printf("%d\n",*(p + i));
    	}
    }
    
    int main(){
    	int arr[10] = {1,2,3,4,5,6,7,8,9};
    	int *p = arr;
    	int sz = sizeof(arr) / sizeof(arr[0]);
    	print(p,sz);		//一级指针p,传给函数print
    	return 0;
    }
    

    Q:那么当一个函数的参数部分为一级指针的时候(例如int *),函数能接收什么参数?

    1. int*类型的一级整型指针
    2. 数组元素类型为int的一维数组

    二级指针传参

    常见的传参方式如下:

    void test(int** ptr){
        printf("num = %d\n", **ptr);    
    }
    
    int main(){
        int n = 10;
        int *p = &n;
        int **pp = &p;
        test(pp);		//二级指针pp传给函数test
        test(&p);
        return 0;
    }
    

    Q:当函数的参数是二级指针时(例如int **),可以接收什么参数?

    1. 二级指针
    2. 指针数组
    展开全文
  • sizeof(数组名),计算整个数组的大小。` int arr[10] = { 1, 2, 3, 4, 5 }; printf("%d\n", sizeof(arr)); 输出结果为40 &数组名,取出的是数组的地址。(数组地址和数组首元素地址不同表现在各自地址都是...
  • 4:数组做入参时,因为传入的是数组的首地址,所以无论采取*a还是a赋值方式,a的值都改写; #include #include void func(int * a) { int c = 20; *a = c; memcpy(a, &c, 1); } void func1(int b[]) { int c = 20; ...
  • 函数传参 数组传参 1 制作一个简单的阶乘脚本。通过数组给函数传参 #!/bin/bash #1 先定义一个数组 num=(1 2 3) #2 定义一个函数 array(){ factorial=1 for i in $* #(重点2) do #定义阶层的公式 factorial=$...
  • 关于数组传参那点事

    2018-11-19 20:22:46
    } 数组传参、指针传参 一维数组传参 //(此处的等价指能达到相同的效果) //两者等价 void test2 (int *arr[20])<==>void test2(int **arr) //三者等价 void test(int arr[])<==>void test(int arr[10])<==>void test...
  • C++二维数组传参

    2020-12-02 16:37:20
    //C++中并没有多维数组的概念,实际上是数组数组 //二维数组作为参数传入的三种方法 #include<iostream> using namespace std; //需要指明每一行有多少个元素 void Print1(int M[][3],int n) { for (int ...
  • C语言二维数组传参问题

    千次阅读 2020-02-01 11:07:56
    一维数组传参 我们知道,在C语言中,当数组作为实参进行传递时,本质上就是指针在做实参(传递地址值)。如下所示 /* 打印数组的元素值 */ void printArr(int* arr,int len){ for (int i = 0; i<len; i++) { ...
  • } int main() { //n行m列的二维动态数组 int n,m; scanf("%d %d",&n,&m); //v有n个元素,每个元素是vector(m,-5) //每个元素有m个int型元素,初值为-5 vector<vector<int>> v(n, vector(m,-5)); v[2].resize(8,3);/...
  • 在一次稀疏矩阵压缩算法中,为了保证压缩函数可复用性,使用了void** 作为压缩形参,结果二维数组传入一直无法获取到内容。 结果出现的方案如下 方法1 方法2: 数组指针 或者是 二级指针 结果相同 int ** arr; ...
  • C语言中,二维数组的参数传递。 例如: char str[5][100]; 如果作为参数传递,内有详细示例。 三种传参示例供参考。
  • 一、一维数组传参 #include<stdio.h> #include<stdlib.h> #include <stdio.h> void test(int arr[])//ok? yes {} void test(int arr[10])//ok? yes {} void test(int *arr)//ok? yes {} void ...
  • JS中数组作为参数传递,会随着函数内部的改变而改变,所以在传递之时要注意千万不能直接把之后还有需要的参数传递进去。 不但如此,如果你想用var Barray = Aarray 的...所以传参时可以使用var Barray = new Array ...
  • post请求,数组传参写法。脱坑

    千次阅读 2020-09-15 18:13:31
    方法是这个public R removeByIds( @RequestBody String[] ids) {XXX},post请求;...原来是要用上面的传参方式,就是数组或集合,直接写里面的元素,不要数组名!!!且用方括号!!! 之前集中错误的传参: ...
  • 一、传参问题: 1.形参为二维数组, 并给定第二维长度。必须给出后面的维度大小 声明: int findK(int arr[][3], int rows, int cols, int k); 调用: findK(arr,n,m,k); 缺点:必须在声明中给出第二维度的大小 2....
  • C/C++函数中数组传参

    2020-03-21 21:04:23
    12, 11, 4, 11 原因: 在C/C++里数组作为参数时传递的实际上是指向数组第一个元素的指针,因此sizeof(str)返回的是指针的大小,即4。 12是因为在最后还添加了一个\0,所以是11+1=12。 //以下三个是等效的 void fun...
  • axios处理数组传参

    千次阅读 2019-09-17 21:16:40
    后端要求的数组参数为以下格式: 前端的原始参数: let params = { points: [ { lat: 111, lng: 222 } ] }; params = qs.stringify(params); 用qs.stringify)序列化后得到的默认是下面这种格式: 上面这种...
  • C 二维数组传参

    千次阅读 2018-11-15 09:02:45
    今天写程序的时候要用到二维数组作参数传给一个函数,我发现将二维数组作参数进行传递还不是想象得那么简单里,但是最后我也解决了遇到的问题,所以这篇文章主要介绍如何处理二维数组当作参数传递的情况,希望大家不...
  • [C语言]二维数组传参的格式(详细+总结)

    万次阅读 多人点赞 2018-11-30 10:57:38
    初遇二维数组作函数参数,宛如自己化身为了大头儿子。很头大。 不禁大声呐喊:该怎么声明定义,该怎么调用,又该怎么函数中操作元素和地址? 在此,我要拨开这些问题的一些迷雾。 我相信,有心人看完后,再遇就...
  • C++ 动态申请二维数组与二维数组传参

    千次阅读 多人点赞 2018-12-15 11:59:41
    这样可以动态分配一个一维数组 但是如何动态分配一个二维数组呢?像这样: int **pa = new int[3][3] ?测试一次 => 显然这种分配方式是不正确的: 在尝试新的方法之前,我们需要首先了解二维数组在内存中...
  • 二维数组传参

    千次阅读 2019-03-13 14:54:27
    规定:如果将二维数组作为参数传递给函数,那么在函数的参数声明中必须指明数组的列数,数组的行数没有太大关系,可以指定也可以不指定。因为函数调用时传递的是一个指针,它指向由行向量够成的一维数组。因此二维...
  • 数组传参是我在写快速排序时遇到的基础问题 我提出的问题如下: quick_sort(array, 0, length-1) 这个array是数组名的意思吗? void quick_sort(int array[],int left,int right) 那这个定义函数的时候 为什么又...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 80,120
精华内容 32,048
关键字:

数组传参