精华内容
下载资源
问答
  • 在写一个简单的选择排序时,发现如果不在调用排序函数传入数组大小,程序得不到预期结果,经过调试,发现原来在不同地方sizeof(A)的结果是不同的,具体如下 #include<cstdio> #include<iostream> ...

    在写一个简单的选择排序时,发现如果不在调用排序函数时传入数组大小,程序得不到预期结果,经过调试,发现原来在不同地方sizeof(A)的结果是不同的,具体如下

     #include<cstdio>
     #include<iostream>
     using namespace std;
     
    void selectSort(int A[],int n){
    	//int n = sizeof(A)/sizeof(A[0]);
    	for(int i = 0; i< n; i++){
    		int k = i;
    		for(int j = i; j < n; j++){
    			if(A[j]<A[k])
    				k = j;
    		 } 
    		 int temp = A[k];
    		 A[k] = A[i];
    	 	 A[i] = temp;	 
    	 }
    
    } 	
    
    int main(){
    	int A[5] = {1,3,2,5,4};
    	int n = sizeof(A)/sizeof(A[0]);
    	cout<<sizeof(A)<<endl;
    	//cout<<n<<endl;
    	selectSort(A, n);
    	for(int i = 0; i < 5; i++){
    		cout<<A[i]<<endl;
    	}
    } 
    

    在mian函数中,sizeof(A)是所有数组元素所占用的内存空间字节数,因此可以通过sizeof(A)/sizeof(A[0])计算数组大小,而在定义的函数体内,sizeof(A)是A这个指针类型的大小,不能计算数组大小。

    展开全文
  • C++传入数组函数和从函数返回数组 本文参考了链接: https://blog.csdn.net/lijiayu2015/article/details/52821562 https://www.cnblogs.com/yangxi/archive/2011/09/18/2180759.html 表示感谢。 1级标题 ...

    C++传入数组给函数和从函数返回数组

    作者:Luyu

    C++中函数是不能直接返回一个数组的,但是数组其实就是指针,所以可以让函数返回指针来实现。指针存放着数组的首地址,指针这个变量就是存地址的容器。

    以下博文对我有所帮助,对作者表示感谢。
    怎样让函数返回数组 - 博客园
    怎样让函数返回数组 - CSDN
    以上链接只讲述了如何从函数A返回数组arr[]至main(),但是没有讲如何将main()中的返回的数组arr[]再次传入另一个函数B。

    1 目的

    C++中经常遇到数组在函数之间的传递问题。
    为了实现从主函数main()调用函数A和函数B,其中,函数A返回数组,返回值为数组的首地址(指针x),将其返回至main(),然后再将此数组以指针方式传入函数B,调用关系如下:
    main() ------> 调用函数A ------> 返回数组arr[] ------> 传入函数B ------> 在函数B中读取arr[]

    2 代码

    主函数main.cpp

    #include <iostream>
    #include <cmath>
    
    #include "coords_cen.h"
    #include "display.h"
    
    using namespace std;
    
    int main ()
    {
        // parameter of the physical problem
        double L = 1.0;
        double N = 20.0;
        double Dx = L/N;
        // define a pointer
        double* p1 ;
        // function coords_cen.cpp, return value of the function point to a pointer
        p1 = coords_cen(Dx,N,L);
        // function display.cpp, 
        // transfer the p1 (pointer/firstaddress of the array)
        display(Dx,N,L,p1);
    
    
        return 0;
    }
    

    函数coords_cen.cpp

    /*  the return value of this function
    is a pointer, which point to the first
    address of the return value (array)  */
    
    /* where the array x[] was generated by
    the dynamic array*/
    
    #include <iostream>
    #include "coords_cen.h"
    using namespace std;
    
    double* coords_cen(double Dx,double N,double L)
    {
        const int n=N;
        // static double x[n]; // another option
        double* x = new double[n]; // dynamic array
    
        for (int i=0; i<=(n-1); i++)
        {
            x[i] = (Dx/2)*(2*i+1);
        }
    
        return x;
        delete []x;
    }
    

    由于C++规定不允许返回一个未知长度的数组,因此无法使用以下方式在函数中定义数组:

    	double x[n]; 
    

    必须采取static限定:

    	static double x[20]; // n=20
    

    但是实际编程中不可能指定n的大小,因此解决的关键就是动态数组:

        double* x = new double[n]; // dynamic array
    

    这就解决了数组返回值的问题,实际上返回的是数组的首地址/指针/数组名。
    使用完毕后将其删除:

        delete []x;
    

    函数display.cpp

    // location of element's centers and interfaces
    #include <iostream>
    #include "display.h"
    using namespace std;
    
    void display(double Dx,
                 double N,
                 double L,
                 double* coords_cen)
    {
    
        cout<<"Dx: "<<Dx  <<endl;
        cout<<"N:  "<<N  <<endl;
        cout<<"L:  "<<L <<endl;
    
        for (int i=0; i<=(N-1); i++)
        {
            cout<<"coords_cen["<<i<<"]: "<<*(coords_cen+i)<<endl ;
        }
    }
    

    头文件coords_cen.h

    #ifndef COORDS_H_INCLUDED
    #define COORDS_H_INCLUDED
    
    double* coords_cen(double Dx,double N,double L);
    
    #endif // COORDS_H_INCLUDED
    

    头文件dispaly.h

    #ifndef DISPLAYVAR_H_INCLUDED
    #define DISPLAYVAR_H_INCLUDED
    
    void display(double Dx,
                 double N,
                 double L,
                 double* coords_cen);
    
    #endif // DISPLAYVAR_H_INCLUDED
    
    展开全文
  • C++中,如果要给一个函数传入一个数组,一般都是传入两个参数一个数组指针和一个数组大小 例: void print_1 (int n, int *datas ) {  for (int i = 0; i  {  std::cout  }  std::cout } 对这个函数...

    C++给函数传数组参数

    在C++中,如果要给一个函数传入一个数组,一般都是传入两个参数一个数组指针和一个数组大小

    例:
    void print_1 (int n, int *datas )
    {
        for (int i = 0; i < n; ++i)
        {
            std::cout << datas[i] << " ";
        }
        std::cout << std::endl;
    }

    对这个函数,我们可以这样使用它:
    const int N = 3;
    int datas[N] = {1, 2, 3};
    print_1 (N, datas);

    不过对这个函数,我们可能会传错 n 的大小,而在运行时可能出错,例如这样使用:
    const int N = 3;
    int datas[N] = {1, 2, 3};
    print_1 (4 , datas);


    有些时候,我们希望某函数只接受指定大小的数组,例如我们希望只接受大小为 3 的数组:
    void print_2 (int datas[3] )
    {
        for (int i = 0; i < 3 ; ++i)
        {
            std::cout << datas[i] << " ";
        }
        std::cout << std::endl;
    }

    但实际上,上面的函数不能正确工作:
    const int N = 3;
    int datas[N] = {1, 2, 3};
    print_2 (datas);

    int datas2[N - 1] = {1, 2};
    print_2 (datas2);
     

    也就是我们传入了一个大小为 2 的数组,编译器没报任何错误,我们的函数接口 print_2 (int datas[3 ]) 中的 3 没起任何作用


    事实上,上面的函数接口应该这样写:
    void print_3 (int (&datas) [3])
    {
        for (int i = 0; i < 3; ++i)
        {
            std::cout << datas[i] << " ";
        }
        std::cout << std::endl;
    }

    这时,我们如果这样使用是正确的
    const int N = 3;
    int datas[N] = {1, 2, 3};
    print_3 (datas);

    而我们如果这样使用,编译器会报错
    int datas2[N - 1] = {1, 2};
    print_3 (datas2);


    在上面这个例子(print_3)的基础上,我们可以使用模板进行泛型实现
    template<int N>
    void print_4 (int (&datas)[N])
     
    {
        for (int i = 0; i < N; ++i)
        {
            std::cout << datas[i] << " ";
        }
        std::cout << std::endl;
    }

    这时候,我们可以传递任意大小数组,而不担心给函数传入了错误的参数
    const int N = 3;
    int datas[N] = {1, 2, 3};
    print_4 (datas);

    int datas2[N - 1] = {1, 2};
    print_4 (datas2);

    假如我们给传了错误参数,函数将会报错
    const int N = 3;
    int datas[N] = {1, 2, 3};
    print_4<4 > (datas);

    C++中二位数组作为函数参数


    变量在作用域里面被声明的是什么类型,就当作什么类型来用。

    (1)参数是二维数组,但是要指定第二维的维数。

    int array[10][10];

    函数声明:void fuc(int a[][10]);

    函数调用:fuc(array);

    ——在函数fuc中,a是二维数组。使用a[i][j]形式来访问数组中元素。

    (2)参数使用一维指针数组。

    int *array[10];

    for(i = 0; i < 10; i++)

        array[i] = new int[10];

    函数声明:void fuc(int *a[10]);

    函数调用:fuc(array);

    ——在函数fuc中,a是一维指针数组。使用*(a[i] + j)形式来访问数组中元素。

    (3)参数使用指针的指针。

    int **array;

    array = new int *[10];

    for(i = 0; i <10; i++)

        array[i] = new int[10];

    函数声明:void fuc(int **a);

    函数调用:fuc(array);

    ——在函数fuc中, a是指针的指针。使用*(int *)(a + i*d2 + j)形式来访问数组中元素。其中:

    a[0]<=>array[0][0],

    a[1]<=>array[0][1],

    a[10]<=>array[1][0]

    注:d2为二维数组的二维维数,即列数。并且a + i*d2 + j为地址,所以要把这个类型为指针的指针的地址强制转换为指针来使用

    转载自:http://blog.csdn.net/hongjiqin/article/details/5739935 

    http://www.cnblogs.com/growup/archive/2011/03/01/1971529.html

    展开全文
  • 1、复杂类型需要C#在定义时保持和C++中的源类型一模一样,特别是成员的顺序,一定要一致。 2、复杂类型数组在长度固定时,使用[MarshalAs(UnmanagedType.ByValArray, SizeConst=length)] 如: [MarshalAs...

    1、复杂类型需要C#在定义时保持和C++中的源类型一模一样,特别是成员的顺序,一定要一致。
    2、复杂类型中的数组在长度固定时,使用[MarshalAs(UnmanagedType.ByValArray, SizeConst=length)]
    如:

    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 65535)]
    public int[] VectorData = new int[65535];
    

    ,长度不固定时,该成员需要定义为IntPtr类型的通用指针,如:

    public IntPtr fc;
    

    3、C++中以type* 定义的成员在C#中,除了 char* 可以用 C#的string对应外,其他都应考虑 IntPtr 和 Marshl.Alloc/FreeCoTaskMem。
    4、调用函数时需要传入的数组参数可以直接使用C#的数组(数组类型一致),如:

    double[] iqBuffer = new double[iqPairs * 2];
    SGenerator.Dll_get_ASKIQ(0, iqBuffer, iqPairs, 1);
    

    5、复杂类型中的IntPtr在赋值时应如下:
    注:C++中长度不固定的指向型数组指针都应有一个对应的int类型的长度变量才对。
    如:

    public IntPtr fc;
    public int fc_num;//fc的长度
    

    赋值时:

    int size = 6;
    int fc= new int[size];
    IntPtr fcbuffer = Marshal.AllocCoTaskMem(Marshal.SizeOf(fc[0]) * size);
    Marshal.Copy(fc, 0, fcbuffer, fc.Length);
    sp.fc = fcbuffer;
    sp.fc_num = size;
    

    6、引用类型在C#中声明函数的时候应加ref,C++中的type*类型的参数应使用[In,Out],如:

    [DllImport(DllName)]
    public static extern int Dll_CreateContext([In,Out] SPara sp, ref int length);
    [DllImport(DllName)]
    internal static extern void Dll_get_ASKIQ(int id, [In, Out] double[] data, int len, int fr);
    

    更多关于封送处理不同类型的数组请点击→传送门

    展开全文
  • 刚开始的时候自己打算让该函数接受一个数组作为参数,经过函数的排序后使得数组中的元素按非递减顺序排列。所以按照这个想法自己写下了如下的函数#include /* *插入排序,算法导论中的解释很好:可以将排序过程看做...
  • cout 传入数组单个元素的大小是:" (datas[0]) ; } 上述代码计算的结果是: 主函数数组的大小是:40 主函数数组地址的大小是:4 传入数组的大小为:4 传入数组单个元素的大小是:8  
  • #include const int ArSize = 8; int sum_arr(int arr[], ... 所以,在编写c++程序时,不能像python那样,直接传整个数组,然后length(arr)(此时arr只是一个指针,无法知道数组大小),必须要显式地指出数组的长度。
  • C++中函数传递数组的探索

    千次阅读 2016-03-04 21:44:12
    一、传入数组  一个C函数可以把数组作为形参,在C++具体表现形式有三种: void func(int para[]); void func(int para[20]); void func(int *para); 这三种形式虽然表现不同,在C++中都看成相同的,等价于...
  • 很多人c和c++的初学者都知道这样一个事实:数组不能直接作为函数的形参,当传入一个数组名时,数组会退化为对应的指针类型。 例如考虑如下函数:void chuanrushuzu(int a[10]) { return;//没有实质内容,只是为了...
  • 函数的参数可以是数组,且数组作为参数传入时,参数中数组的第一维不需要填写长度,如果是二维,那么第二维需要填写长度,在实际调用时也只需填写数组名。最重要的是,数组作为参数时,在函数中数组元素的修改就...
  • 众所周知,函数在传参数时会复制参数,但传指针时,只是复制了指针本身,而没有复制指针指向的值,所以可以通过传指针或引用来使函数内可以修改外部的值。那么,对于数组,会怎样? 上测试程序 #include&lt;...
  • C++中函数数组形参

    千次阅读 2017-08-27 08:55:10
    函数的操作数,也即形参(parameter),在一对圆括号声明,形参与形参之间以逗号分隔。 void swap(int a, int b) { int temp = a; a = b; b = temp; }在以上函数中,参数a和b就是swap()函数的形参。当调用该...
  • C#函数传入数组C++动态库

    千次阅读 2019-09-03 15:58:59
    传入引用数组参数,函数声明: public bool GetStatus(short channelId, ref CardStatus[] cardStatus, out int count) { //..... }
  • C++函数传递数组

    千次阅读 2017-10-14 16:38:55
    C语言不能向函数传递数组,但是C++中是可以的。这样就方便了许多 C语言函数操作数组: C例1:C语言 通过指针访问一维数组,二维数组,三维数组。 C例2:C语言 使用指针遍历二维数组 /** C++使用数组作为...
  • C++函数传递数组

    2018-12-09 17:18:54
    C++函数传递数组 数组的存储空间很大,如果能够把它作为参数传递给函数,那么就能发挥很大的作用了。比如本来一个选出最大数的max函数只能在两个数或三个数里面选出一个最大的数字,如果我们把数组传递过去,它就...
  • 例子:将任意长度的整形数组传递给求和函数sum,返回数组中所有元素之和。 写法1: #include <iostream> using namespace std; int sum(int arr[]) { int sum = 0; int len = sizeof(arr) / sizeof(arr[0])...
  •  当一个函数需要访问一个数组元素时,出于上述原因,往往也希望令传入的参数尽可能的少(至少我是这样...)。  首先,引出一个例子,对于std::vector<typename>来说,往往只需要传递一个参数就足够...
  • 1.普通方法 #include<iostream> #include<string> using namespace std; int howLong(string s1){ int m=s1.length(); return m; } int main(int argc,char* argv... char aa[]="hijfasddasfasfa...
  • C++函数传入二维数组

    千次阅读 2018-11-29 11:49:15
    1、指定第二维的大小 //定义 void function(void a[][N]); //访问 a[i][k]; //其中 i 为行,j 为列 2、指向第二维大小为N的指针 //定义 void function(void (*a)[N]); //访问 a[i][j]; ......
  • 如果声明代理需要传入数组,如下 DECLARE_DYNAMIC_DELEGATE_OneParam(FSerachDataByStringValDelegate, TArray<FPOIData>, poiDataSearchArr); 在蓝图层面是会报错的,报错信息如下 customevent_0 ...
  • C++函数数组参数

    2016-04-15 23:14:19
    from: ... 在C++中,如果要给一个函数传入一个数组,一般都是传入两个参数一个数组指针和一个数组大小 例: void print_1 (int n, int *datas ) {  for (int i = 0; i  {  std:
  • 在写一个程序时发现一个错误,经过反复调试发现:在主函数求长度和在子函数中求长度的结果不一样。例如: #include &lt;iostream&gt; using namespace std; int getwater(int*); int main() { int arr[]...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 66,600
精华内容 26,640
关键字:

c++函数中传入数组

c++ 订阅