精华内容
下载资源
问答
  • 数组指针形参
    千次阅读
    2021-05-10 21:08:32

    失败例子:

    int fuzhi(float* data) {
    
    	int num = 10;
    	float* new_data = new float[num];
    	for (int i = 0; i < num; i++) {
    	
    		new_data[i] = i;
    			
    	
    	}
    	data = new_data;
    	return 0;
    }
    int main(int argc, char **argv)
    {
    
    	Solution* so = new Solution();
    	vector<int> nums;
    
    
    	float* data=new float[10];
    	fuzhi(data);
    	int num = 10;
    
    	for (int i = 0; i < num; i++) {
    
    		cout << data[i] << endl;
    
    
    	}
    }

     

    成功例子:

    int fuzhi(float* data) {
    
    	int num = 10;
    	float* new_data = new float[num];
    	for (int i = 0; i < num; i++) {
    	
    		data[i] = i;
    			
    	
    	}
    	//data = new_data;
    	return 0;
    }
    int main(int argc, char **argv)
    {
    
    	Solution* so = new Solution();
    	vector<int> nums;
    
    
    	float* data=new float[10];
    	fuzhi(data);
    	int num = 10;
    
    	for (int i = 0; i < num; i++) {
    
    		cout << data[i] << endl;
    
    
    	}

     

    更多相关内容
  • 关于数组作为参数以及数组指针的应用

      本人在学习数组指针时,遇到一个数组作为参数传递的情况时,于是研究了一下,一般来说我们要设计一个函数,当要求数组传入函数时,往往使用的是指针来接收。例如我们设计一个函数名为fun的函数,要把arr数组传入fun中

    fun函数的定义如下 :

     在调用fun函数时,传入fun函数的是数组的首元素地址,并非数组本身,因此可以使用指针作为形参,p+i可以访问到arr数组的arr[i],通过操作符*就可以打印其值。

      当我们把fun函数改造一下:

    实际此时p仍为一个指针,这是以为对于一维数组来说,数组作为函数参数传递,实际上传递了一个指向数组的指针.在c编译器中,数组名作为函数参数时在函数体内数组名自动退化为指针。此时调用函数时,相当于传址,而不是传值,会改变数组元素的值。

    同理我们也可以用高维数组来作为函数的形参或实参,例如

     结果为 1 2 3

                 2 3 4、

                 3 4 5

    结果正确,编译器是如何访问这个二维数组的呢?

    p为指向二维数组首元素地址的指针,即指向数组{1,2,3}的地址(因为我们是将二维数组数组名传给当我们的p),*p(p[0])访问的是数组{1,2,3}的首元素地址,即& 1(没这个写法,只是这样表示),访问p[0][0]其实等于1,实际上可以认为p是p[0][0]地址,因为是一样的,但是+1时步长不同,那么p[i][j]相当于*(p+i*3+j)(数组在内存中是连续存放的),既&p[i][j]==p+i*3+j

    那么我们是否可以通过指针来当形参,来承接高维数组的地址呢?

    答案是可以的,因为二维数组我们可以看作是数组里存放了数组,那么首元素地址我们可以看作是第一行元素集合的地址,所以我们可以用数组指针去充当形参。

     p+i//是指第i行元素集合的地址

    *(p+i)+j//是指第i行j列的元素的地址

    展开全文
  • 一、C语言中的数组指针与指针数组 首先我们需要了解什么是数组指针以及什么是指针数组,如下图: int *p[5]; //指针数组 int (*p)[5]; //数组指针 那么两个之间有什么区别呢: 数组指针的意思即为通过指针引用数组...

    一、C语言中的数组指针与指针数组

    首先我们需要了解什么是数组指针以及什么是指针数组,如下图:

    int *p[5];             //指针数组
    int (*p)[5];           //数组指针
    

    那么两个之间有什么区别呢:

    数组指针的意思即为通过指针引用数组,p先和*结合,说明了p是一个指针变量,指向一个大小为5的数组。所以,int (*p)[5]即为一个数组指针。int *p[5]则是一个大小为5且存放整型指针的数组。

    1、指针数组

    对于语句“intp1[5]”,因为“[]”的优先级要比“”要高,所以 p1 先与“[]”结合,构成一个数组的定义,数组名为
    p1,而“int*”修饰的是数组的内容,即数组的每个元素。也就是说,该数组包含 5 个指向 int 类型数据的指针,如图 1
    所示,因此,它是一个指针数组。

    在这里插入图片描述

    2、数组指针

    对于语句“int(p2)[5]”,“()”的优先级比“[]”高,“”号和 p2 构成一个指针的定义,指针变量名为 p2,而 int
    修饰的是数组的内容,即数组的每个元素。也就是说,p2 是一个指针,它指向一个包含 5 个 int 类型数据的数组,如图 2
    所示。很显然,它是一个数组指针,数组在这里并没有名字,是个匿名数组。

    总结

    那么也可以理解为数组指针是指向数组的指针,其中数组中存放的还是指针,那么这就可以可以和二级指针的概念进行转换,以下通过实例来对两者进行对比。以下着重讲述指针数组,

    int arr[5]={1,2,3,4,5};
    int (*p1)[5] = &arr;
    /*下面是错误的*/
    int (*p2)[5] = arr;
    

    在上面的示例代码中,&arr 是指整个数组的首地址,而 arr 是指数组首元素的首地址,虽然所表示的意义不同,但二者之间的值却是相同的。那么问题出来了,既然值是相同的,为什么语句“int(*p1)[5]=&arr”是正确的,而语句“int(*p2)[5]=arr”却在有些编译器下运行时会提示错误信息呢(如在 Microsoft Visual Studio 2010 中提示的错误信息为“a value of type"int*"cannot be used to initialize an entity of type"int(*)[5]"”)?

    其实原因很简单,在 C 语言中,赋值符号“=”号两边的数据类型必须是相同的,如果不同,则需要显示或隐式类型转换。在这里,p1 和 p2 都是数组指针,指向的是整个数组。p1 这个定义的“=”号两边的数据类型完全一致,而 p2 这个定义的“=”号两边的数据类型就不一致了(左边的类型是指向整个数组的指针,而右边的数据类型是指向单个字符的指针),因此会提示错误信息。

    二、指针数组作为形参传递

    typedef struct {
        int a;
        int b;
    }test;
    
    void func1(test* tmp[]){
        printf("func1:%d\n", ((test*)tmp + 0)->a);
        printf("func1 ((test*)tmp)[0].c:%d\n", ((test*)tmp)[0].b);
        
        printf("func1:%d\n", ((test*)tmp + 1)->a);
        printf("func1 ((test*)tmp)[1].c:%d\n", ((test*)tmp)[1].b);
    }
        
    void func2(test* tmp){
        printf("func2 ((test*)tmp + 0)->a:%d\n", ((test*)tmp + 0)->a);
        printf("func2 tmp[0].b:%d\n", tmp[0].b);
        printf("func2 ((test*)tmp + 1)->a:%d\n", ((test*)tmp + 1)->a);
        printf("func2 tmp[1].b:%d\n", tmp[1].b);
    }
    
    int main(int argc, char const *argv[])
    {
        test aa[2];
        aa[0].a = 1;
        aa[0].b = 2;
        
        aa[1].a = 3;
        aa[1].b = 4;
        
        func1((test**)aa);
        printf("------------------------\n");
        func2((test*)aa);
        return 0;
    }
    

    结果:

    func1:1
    func1 ((test*)tmp)[0].c:2
    func1:3
    func1 ((test*)tmp)[1].c:4
    ------------------------
    func2 ((test*)tmp + 0)->a:1
    func2 tmp[0].b:2
    func2 ((test*)tmp + 1)->a:3
    func2 tmp[1].b:4
    

    其实除了上述两种传参的方式之外还可以使用值传递的方式;

    void func_3(test aa[]) 
    

    这种方式不再进行详解。

    三、数组指针作为形参传递

    typedef struct {
        int a;
        int b;
    }test;
    
    void func3(test (*tmp)[]){
        printf("func1:%d\n", (*tmp)->a);
        printf("func1:%d\n", (*tmp)->b);
        printf("func1:%d\n", (*tmp)[0].a);
        printf("func1:%d\n", (*tmp)[0].b);
    
        printf("=========================\n");
        
        printf("func1:%d\n", ((test*)tmp)[0].a);
        printf("func1:%d\n", ((test*)tmp)[0].b);
        printf("func1:%d\n", ((test*)tmp+1)->a);
        printf("func1:%d\n", ((test*)tmp+1)->b);
    
        printf("=========================\n");
    
        printf("func3:%d\n", (*tmp + 1)->a);
        printf("func3:%d\n", (*tmp + 1)->b);
        printf("func1:%d\n", (*tmp)[1].a);
        printf("func1:%d\n", (*tmp)[1].b);
    }
    
    int main(int argc, char const *argv[])
    {
        test aa[2];
        aa[0].a = 1;
        aa[0].b = 2;
        
        aa[1].a = 3;
        aa[1].b = 4;
        
        func3(&aa);
        return 0;
    }
    
    
    

    结果:

    func1:1
    func1:2
    func1:1
    func1:2
    =========================
    func1:1
    func1:2
    func1:3
    func1:4
    =========================
    func3:3
    func3:4
    func1:3
    func1:4
    
    展开全文
  • 指针数组和数组指针(含数组作为形参在函数间传递的几种方法)

    前言

    小白一个,这是我的第一篇文章。写文章的主要目的是用于记录一些学习笔记(当然,包含个人理解,有问题欢迎通过多种途径进行交流指正)

    一年前认认真真地学习了C++,并靠此初步入门了编程。最近开始回来复习和巩固,以下是本次笔记的主要内容。

    • 数组指针和指针数组的区别

    事实上,从英文角度便可以很容易的理解这个问题。

    数组指针是 a pointer to an array (to 指向嘛),指的是一个指针,其指向一个数组(例如,指向数组的首地址)

    指针数组是 array of pointers (of 后是修饰成分),指的是一个数组,其内部存储的变量类型是指针。

    很显然,数组指针是指向数组的指针,指针数组是储存指针的数组。(中文角度也可以,中文里一般把主语放最后面,定语前面),感觉这样理解东西很有意思。

    举例:

    	int (*a)[2] = {}; // 数组指针
    	int * b[3] = {}; // 指针数组
    	
    	std::cout << typeid(a).name() << std::endl;
    	std::cout << typeid(b).name() << std::endl;

    结果: PA2_i 代表“指针数组,大小为2”,A2_Pi代表“数组指针,大小为3”

    •  数组作为形参在函数间传递的几种方法

    数组传入的方式大致是分为两种思路,为了介绍全面,这里以二维数组为例
    一种是静态的,一种是动态的(但总的来说都是传递初始位置的地址,列数、行数等)

     这里就不再多废话,说明直接贴注释里。先附上主函数

    #include<iostream>
    #include<typeinfo>
    
    using namespace std;
    
    int main()
    {
    	int arr1[2][3] = {}; // 全为0
    	int arr2[3][3][3] = {};
    	array1(arr1);
    	array2(arr1[0],2,3);
    	array3(arr1,2);
    	array4(arr2,3);
    	
    	return 0;
    }

     第一种:静态数组(直接把信息写死,传入的数组只能为2行3列)

    void array1(int arr[2][3]) 
    {
    	cout << endl;
    	for(int t1=0; t1<2; t1++)
    	{
    		for(int t2=0; t2<3; t2++)
    		{
    			cout << arr[t1][t2] ;
    		}
    		cout << endl;
    	}
    }

    第二种:动态数组,利用指针进行传入,采用更多参数的好处是更灵活,其行数,列数等信息由实际传入数值决定,但代价是需要更多储存空间。

    ​
    // 上面的表达等价于void array1(int rows, int cols, int *arr) 
    void array2(int * arr, int rows, int cols) 
    {
    	cout << endl;
    	for(int t1=0; t1<rows; t1++)
    	{
    		for(int t2=0; t2<cols; t2++)
    		{
    			cout << arr[t1*rows + cols] ; 
    // 可以发现,当作一维的数组来处理了(二维数组本质是一维数组,存储空间是连续的)
    		}
    		cout << endl;
    	}
    }
    // 与void array1(int a[2][3])原理相同
    void array3(int arr[][3],int rows) 
    // 形参部分等价于 int (*arr)[3],int rows,这里的(*arr)[3]就是一个数组指针(可以互换验证)
    {
    	cout << endl;
    	for(int t1=0; t1<rows; t1++)
    	{
    		for(int t2=0; t2<3; t2++)
    		{
    			cout << arr[t1][t2] ;
    		}
    		cout << endl;
    	}
    }
    
    ​

    来个推广到三维数组的例子

    // 形参部分等价于 int (*arr)[3],int rows,这里的(*arr)[3]就是一个数组指针(可以互换验证)
    void array4(int arr[][3][3],int rows) 
    {
    	cout << endl;
    	for(int t1=0; t1<rows; t1++)
    	{
    		for(int t2=0; t2<3; t2++)
    		{
    			for(int t3=0; t3<3; t3++)
    			{
    				cout << arr[t1][t2][t3] << ' ';
    			}
    			cout << endl;
    		}
    		cout << endl;
    	}
    }

    几个有趣的问题

    问题1

    	cout << arr1 << endl; // 地址一样,但类型不一样
    	cout << arr1[0] << endl;
    	cout << typeid(arr1).name() << endl;
    	cout << typeid(arr1[0]).name() << endl;

    问题1 的运行结果是

    问题2

    对于函数

    void array5(int a[],int len){}
    	int a[2];
    	array5(a,2);
    //	array5(a[0],2); // 编译不通过,因为是值。
    
    // 对于二维的情况
        int b[2][2];
    //  b[0][0] 是值,但b[0]不是,而是子数组的指针

    拓展知识可以参考如下链接:

    c++二维数组a[m][n]中为何a的值和a[0]的值相同? - 知乎

    展开全文
  • 数组指针作为形参传递

    千次阅读 2019-04-17 00:02:59
    数组作为函数形参时,数组的地址可以用做函数调用的实参。 可以通过数组地址的传递,在函数内可以对该数组进行访问和修改。 eg: #include <stdio.h> #define SIZE 10 /* 形式1 */ void func_1(const char ...
  • 2.c++形参传入数组指针时,需要传入数组的长度 #include <iostream> using namespace std; int* getSortedArray(int *array,int length);//函数声明,排序后返回数组 bool sortedOK(int *array,int length);//...
  • 二级指针,二维数组形参 // pointpoint.cpp : 定义控制台应用程序的入口点。 // #include "stdafx.h" #include "stdlib.h" #include "stdio.h" int **sum0(int **arr, int row, int col, int *retSize, int **...
  • 数组作为形参知识点 1.数组的维度必须是一个常量表达式 int main(void) { constexpr int i = 20; int j = 5;//不是常量表达式 int arr1[i];//正确 int arr2[j];//错误 system("pause"); return 0...
  • 数组引用形参和多维数组形参 void print(int (&arr)[10]) {..............} //如果形参里面是 (int &arr[10]) 这是引用的数组,相对于是包含10个引用的数组,这一般是非法的声明 这样的数组引用形参只能将...
  • 1.二维多维数组除第一维长度可省略外,其他维不可省略 eg: void find(char a[3][10]); 对 void find (char a[ ]... 对(用数组指针指向二维数组 [] 优先级高于*) void find(char a[ ][ ]); 错 void find ...
  • 二级指针是指向指针的指针,因为指针存放的是地址,所以二级指针是指向一级指针本身的地址,而非一级指针所指向的... 3 //void display(char *ptr[100], int len) // 第三种数组指针作为形参的写法 4 //void displ...
  • c/c++语言数组形参

    2021-10-16 10:53:30
    在写程序的时候发现了一个漏洞:数组形参的时候会退化,只会传递地址。 1.连续的二维数组:可以看作一维数组,二维数组array[high][wide]本身是一个二级指针,*array是一个指向a[0][0]的一级指针p,&array[i]...
  • 二维数组作为形参

    千次阅读 2021-08-26 10:41:22
    首先需要理解编译器对于二维数组是如何寻址的: ...因此如果想要采用数组下标的形式作为形参,则必须给定n值(该即二维数组一行有多少列),否则无法定位出所寻址行的首地址,则无法进行正常的寻址。
  • `param1`为二维数组,在函数`void total_score_of_each_stu(param1, param2, param3,param4)`中该以怎样的形参形式去接收函数调用时实参传递的参数?
  • C语言中数组指针 作为形参

    千次阅读 2015-06-05 21:33:48
    在修改程序的过程中,看到两种将数组作为形参的方法,于是搜了一下,找了一下比较全面地介绍数组指针的文章。 先写下我遇到的两种方式: 方式1: void filter_c(long double *,long double *,float *,int);//函数...
  • //总结关于二维数组指针和函数形参实参 //1.指针: **p 和(*p)[2]都可以指向二维数组 **p是二维指针,系统不知道+1是加多少,(*p)[2]则明确指出每+1是指2(int) //2.实参: function(p , arr) ‘p’指**p (*p)[2]...
  • 今天想用一个二维字符串数组保存字符串,在参数传递过程中发现返回的结果不对,上网一搜,发现二维数组作为形参传递不像一维数组那么简单,请看以下详细分析。 异常代码: int StrCut(char* pinput, char **ppOut) {...
  • C 数组形参

    千次阅读 2019-03-14 14:57:28
    1、对于一维数组来说,数组作为函数参数传递,实际上传递了一个指向数组指针,在c编译器中,当数组名作为函数参数时,在函数体内数组名自动退化为指针。此时调用函数时,相当于传址,而不是传值,会改变数组元素的...
  • C++中数组作为形参的方法

    千次阅读 2019-06-04 15:27:08
    有两种传递方法,一种是function(int a[]); 另一种是function(int *a) 这两种两种方法在函数中对数组参数的修改都会影响到实参本身的值!...但是数组是个例外,因为数组的数据太多了,将其一一赋值既麻烦又浪费空...
  • 多维数组一直是个非常绕的东西,而且经常会忘记怎么用它。其实只要理清楚他们之间的关系就是很简单的东西。这篇文章希望能帮助像我一样的初学者更好的理解多维数组
  • c/c++ 当数组作为形参时会退化为指针 这几个结果会不会都是10呢? 错误 我今天遇到了,我就想不明白为什么,最后才知道 当数组做为函数的形参的时候,该参数退化为指针,并且是无法直接求得数组的大小。 传数组给一个...
  • 数组形参和实参总结

    千次阅读 2021-02-23 20:31:49
    指针数组和数组指针,二维数组和二级指针作为形参和实参 C语言学习笔记——指针数组作为函数参数传递的方式 在一维数组中,数组名表示的是数组第一个元素的地址。 C语言调用函数时采用“值传递”方式,当用变量...
  • 数组指针作为函数形参时,能作为函数实参的是二维数组,数组指针 c.当二维数组作为函数形参时,能作为函数实参的是二维数组,数组指针 d.当指针数组作为函数形参时,能作为函数实参的是指针数组,二级指针,一级...
  • C语言二维数组作为形参传递

    千次阅读 2019-01-22 10:48:38
    C语言中,把二维数组作为形参进行传递,有...限制条件:形参二重指针,实参也要求二重指针,用于二维数组动态分配 case 2: void output_printf(int a[4][6],int row,int col) 限制条件: 显示的指定行列 case 3: v...
  • 数组作为形参的使用

    万次阅读 多人点赞 2018-07-30 13:08:00
    1、对于一维数组来说,数组作为函数参数传递,实际上传递了一个指向数组指针,在c编译器中,当数组名作为函数参数时,在函数体内数组名自动退化为指针。此时调用函数时,相当于传址,而不是传值,会改变数组元素的...
  • #include<iostream> using namespace std;...//传递数组,需声明数组第二维的大小 { for (int i = 0; i < 5; i++) { for (int j = 0; j < 5; j++)cout << A[i][j] << " "; cou...
  • 二维数组形参写法

    万次阅读 2019-02-24 15:13:08
    传递二维数组 固定行列,直接传递地址 #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; void Print(int array[3][3]) { printf("\n"); for(int i=0;i&lt;3;i++...
  • 二维数组形参

    千次阅读 2017-10-17 14:57:30
    二维数组形参(以二维数组int a[4][3]为例),且在函数调用中可以通过a[i][j]的方式获取二维数组中个各值,可以有两种方式:1. 使用二维数组形参 void fun_test2(int ppArr_test[][3]); 或 void fun_test...
  • 在线代码编辑器: http://codepad.org/1、*指针void display(int *arr, const int row, const int col){for(int i=; i < row ; ++i){for(int j=; j < col; ++j){cout<< *(arr + i*col + j)<}cout<...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 82,763
精华内容 33,105
关键字:

数组指针形参

友情链接: sediaoban.rar