精华内容
下载资源
问答
  • C++数组形参

    2019-11-30 23:05:35
    C++数组形参 数组的两个特性: 1、数组不允许拷贝 2、使用数组时,通常会将其转换成指针 所以,我们无法以按值传递的方式传递数组,但仍然可以把形参写成类似数组的形式 void print(const int*); void print(const ...

    C++数组形参

    数组的两个特性:
    1、数组不允许拷贝
    2、使用数组时,通常会将其转换成指针
    所以,我们无法以按值传递的方式传递数组,但仍然可以把形参写成类似数组的形式

    void print(const int*);
    void print(const int[]);
    void print(const int[10]);
    int i = 0;
    int j[2] = {0, 1}
    print(&i); //正确,&i 的类型是int *
    print(j); // 正确,j转换成int *,并指向j[0]
    

    这三个函数是等价的:每个函数的唯一形参是const int *。

    展开全文
  • c++ 数组形参

    2013-02-03 16:16:00
    数组形参会被弱化为指针,所以处理数组的函数通常通过指向数组中元素的指针来处理数组。 // three equivalent definitions of printValues void printValues(int *) { /* … */ } void printValues(int []) {...

    数组形参会被弱化为指针,所以处理数组的函数通常通过指向数组中元素的指针来处理数组。

    // three equivalent definitions of printValues
    void printValues(int *) { /**/ }
    void printValues(int []) { /**/ }
    void printValues(int [10]) { /**/ }

    上面3种定义等价,形参类型都是int *,通常使用第1种。第2种形式虽然看起来更直观,但容易引起误解,因为函数操纵的毕竟不是数组本身,而是指向数组元素的指针。第3种形式的数组长度是被忽略的,这里的10并无实际的约束作用,在printValues内部不应依赖这个数组长度做事情。

    和其他类型一样,形参也可以是数组的引用。这时编译器不会将数组实参转换为指针,而是传递数组的引用本身。数组大小成为形参和实参类型的一部分。编译器检查数组实参的大小与形参的大小是否匹配。

    // ok: parameter is a reference to an array; size of array is fixed
    void printValues(int (&arr)[10]) 
    { 
        for (size_t i = 0; i != 10; ++i)
            cout << arr[i] << endl;
    }
    
    int main()
    {
        int i = 0, j[2] = {0, 1};
        int k[10] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
    
        printValues(&i); // error: argument is not an array of 10 ints
        printValues(j); // error: argument is not an array of 10 ints
        printValues(k); // ok: argument is an array of 10 ints
    
        return 0;
    }

    这个版本的printValues只严格接受含有10个ints的数组,所以在printValues函数体内依赖数组大小也是安全的。&arr两边的括号是必须的,否则int &arr[10],会被当做是含有10个引用的数组。

    也可以传递多维数组,所谓多维数组实际就是数组的数组。多维数组同样以指向首元素的指针方式传递。除了第一维以外的所有维的长度都必须明确指定。

    // first parameter is an array whose elements are arrays of 10 ints
    void printValues(int (*matrix)[10], int rowSize);
    void printValues(int matrix[][10], int rowSize);

    实际上形参还是被弱化为一个指针,只不过它现在所指向的是含有10个ints的数组。

    因为非引用型数组形参被弱化为指针,所以无法得知数组的大小,这就容易造成数组越界。一般处理方法有以下三种。

    (1)在数组尾端放置一个结束标记,类似于c-style字符串的\0结束符。

    (2)传递指向数组的第一个和最后一个元素的下一位置的指针,c++标准库程序采用这种方法。

    void printValues(const int *beg, const int *end)
    {
        while (beg != end) 
            cout << *beg++ << endl;
    }

    (3)显示传递表示数组大小的形参

    void printValues(const int ia[], size_t size)
    {
        for (size_t i = 0; i != size; ++i)
            cout << ia[i] << endl;
    }

    【学习资料】 《c++ primer》

    展开全文
  • 【day0403】C++ 数组形参的传递

    千次阅读 2016-04-03 21:42:10
    # 数组是C/C++重要的一个知识点,C++的字符串又不同于...今天写点代码试试函数参数传递--数组形参 * 三种传递数组的写法 * 数组实参:数组名--指向数组首地址的一个指针 * 通过医用传递数组 * 二维(多维)数组的传递

    # 数组是C/C++重要的一个知识点,C++的字符串又不同于c的字符数组(C风格字符串)

    今天写点代码试试函数参数传递--数组形参

    * 三种传递数组的写法

    * 数组实参:数组名--指向数组首地址的一个指针

    * 通过引用传递数组

    * 二维(多维)数组的传递


    Demo1:

    #include <iostream>
    
    using namespace std;
    
    /*数组形参*/
    
    //传入数组首地址,还需传入数组长度
        /*以下两个相同*/
    //void print_1(const int x[], const size_t len);
    //void print_1(const int x[10], const size_t len); //长度10没有用
    void print_1(const int *x, const size_t len)
    {
        cout << "传入数组首地址(指针):\n";
    
        for (size_t i = 0; i < len; ++i){
            cout << x[i] << ", ";
        }
    }
    
    //数组引用形参
    void print_2(int (&x)[10])  //长度10必须写
    {
        cout << "\n\n数组引用形参:\n";
    
        for (size_t i = 0; i < 10; ++i){
            cout << x[i] << ", ";
        }
    }
    
    //C++标准库的写法
    //传入收地址和指向最后一个的下一个地址。
    void print_3(int *bgn, int *end)
    {
        cout << "\n\nC++标准库的写法:\n";
    
        while (bgn != end){
            cout << *bgn++ << ", ";
        }
    }
    
    /// 二维数组形参
    /// 参数:*x表示数组的第0行,每行有10个元素;一共有row_size行
    void print_4(int (*x)[10], int row_size)
    {
        cout << "\n\n二维数组的形参:\n";
    
        for (int i = 0; i != row_size; ++i){
            for (int j = 0; j < 10; ++j){
                cout << x[i][j] << ", ";
            }
            cout << endl;
        }
    }
    
    /// C风格字符数组,最后一个字符是NULL
    void print_ch(const char *arr)
    {
        cout << "\n\nC风格字符数组:\n";
    
        while (*arr != NULL){
            cout << *arr++;
        }
    }
    
    
    int main()
    {
        int arr[10] = {14,15,21,23,56,8,78,79,22,94};
        int arr2[][10] = {{14,15,21,23,56,8,78,79,22,94},
                          {15,21,23,56,8,78,79,22,94,1},
                          {21,23,56,8,78,79,22,94,22,33} };
        char *str = "Hello Love! Today is 0403.\n";
    
        print_1(arr, 10);
    
        print_2(arr);
    
        print_3(arr, arr+10);
    
        print_4(arr2, 3);
    
        print_ch(str);
    
        return 0;
    }
    
    输出:



    展开全文
  • C++多维数组形参

    千次阅读 2016-05-13 22:14:30
    需求今天在学习数据结构和算法时遇到一个需要传递多维数组形参的问题。问题本身很简单,向方法传递一个二维数组,但是使用的时候为了能够让数组维度值能够动态可变(比如向同一个方法传递3X3矩阵或者4X4矩阵),也...

    需求

    今天在学习数据结构和算法时遇到一个需要传递多维数组形参的问题。问题本身很简单,向方法传递一个二维数组,但是使用的时候为了能够让数组维度值能够动态可变(比如向同一个方法传递3X3矩阵或者4X4矩阵),也还是费了些脑子。

    实现

    一维数组

    看多维数组形参传递之前我们先看看简单的一维数组。

    void arrTest(int arr[2]){
        cout << sizeof(arr) << endl;
    }

    这几乎是最简单的数组传递方式了,但是通常不推荐这么写,因为这样一来你就无法在方法内获取数组长度了:你可以试试将2改为3,4或者其他任何数,输出的都是int类型数组所占的大小。
    当然你可以说我已经数组长度为2了还要获取数组长度做什么。好问题,对于一个你已经确定长度的需求来说这么写没问题,但是实际操作中常常需要传递可变长度数组或者根据项目变化需要修改数组长度,这个时候再来修改这个2可能就很麻烦了,尤其是方法内多个地方用到这个长度或者多个方法都涉及到这个长度。这个时候我们就需要将参数传递到数组里面了:

    void arrTest0(int arr[],int n){
        cout << arr[n - 1] << endl;
    }

    其中arr[]是数组,n是长度。当然,如果你知道长度,比如长度为2,写为void arrTest0(int arr[2],int n)也是没问题的,编译可以通过,但是如果你传入的数组长度不为2,运行时就会报错,所以还是将这个长度空出来比较好。这里的arr[]实际上是作为指向数组的指针来处理的,所以上面的写法等价于:

    void arrTest1(int* arr, int n){
        cout << arr[n - 1] << endl;
    }

    测试:

    int arr1[2] = { 1, 2 };
    arrTest(arr1);
    arrTest0(arr1, 2);
    arrTest1(arr1, 2);

    结果:
    4
    2
    2
    好了,一维数组就到此为止,我们下面进入正题:多维数组。

    多维数组

    为了测试方便,我使用二维数组来测试,更高维度的数组使用方式和二维数组基本相同,读者自行扩展。
    首先来看最基本的写法:

    void arrTest2(int arr[][3], int n){
        cout << arr[n - 1][2] << endl;
    }

    其中arr[][3]是数组,n是数组第一维的维度,除了地以维之外,其他所有维度必须预设维度,也就是说arr[][]编译不会通过。这样就比较蛋疼了,如果我并不知道数组长度怎么办,或者手一抖将arr[n - 1][2]写为了arr[n - 1][3]怎么办(我写这篇文章的时候最开始就写为了arr[n - 1][3])?当然有办法,强大的C++早就给我们预留了实现机制:数组名称本质上是指针,对数组的操作基本等同于对指针的操作。于是,上面的写法就可以使用指向一维数组的指针来代替了:

    void arrTest3(int* arr[], int n){
        cout << arr[n - 1][n - 1] << endl;
    }

    更加通用的,我们连一维数组也改为指针,这样对于任意维度的数组我们可以写出通用的传参模式:

    void arrTest4(int** arr, int n){
        cout << arr[n - 1][n - 1] << endl;
    }

    看到这里貌似万事大吉皆大欢喜,但是剧情往往并不如想象中发展,一些幺蛾子总要出来给我们捣点乱:对于arrTest2,我们可以直接将一个二维数组名作为参数传递进来,但是对于arrTest3和arrTest4,直接传递数组形参会报错(int (*)[3]类型的实参与 int **类型的形参不兼容),看来我们得想法办法将数组转换为int **类型。这个还比较麻烦,我在网上找了半天发现得先定义一个int **指针,然后将数组的每一维度逐一传递给该指针:

    int* r[3];
    for (int i = 0; i < 3; i++)
            r[i] = arr2[i];

    上面arr2是数组。注意,int* r[3]不能写为int** r,这样在赋值的时候会提示没有初始化。
    如果你有更好的方式请告诉我,不胜感激!!!

    测试:

        int arr2[3][3] = { { 11, 12, 13 }, { 21, 22, 23 }, { 31, 32, 33 } };
        arrTest2(arr2,3);
        int* r[3];
        for (int i = 0; i < 3; i++)
            r[i] = arr2[i];
        arrTest3(r, 3);
        arrTest4(r, 3);

    结果:
    33
    33
    33

    转载请注明出处:http://blog.csdn.net/ylbs110/article/details/51399235

    完整代码

    #include "stdafx.h"
    #include <iostream>
    
    using namespace std;
    
    void arrTest(int arr[2]){
        cout << sizeof(arr) << endl;
    }
    void arrTest0(int arr[],int n){
        cout << arr[n - 1] << endl;
    }
    void arrTest1(int* arr, int n){
        cout << arr[n - 1] << endl;
    }
    void arrTest2(int arr[][3], int n){
        cout << arr[n - 1][2] << endl;
    }
    void arrTest3(int* arr[], int n){
        cout << arr[n - 1][n - 1] << endl;
    }
    void arrTest4(int** arr, int n){
        cout << arr[n - 1][n - 1] << endl;
    }
    int _tmain(int argc, _TCHAR* argv[])
    {
        int arr1[2] = { 1, 2 };
        arrTest(arr1);
        arrTest0(arr1, 2);
        arrTest1(arr1, 2);
    
        int arr2[3][3] = { { 11, 12, 13 }, { 21, 22, 23 }, { 31, 32, 33 } };
        arrTest2(arr2,3);
        int* r[3];
        for (int i = 0; i < 3; i++)
            r[i] = arr2[i];
        arrTest3(r, 3);
        arrTest4(r, 3);
        system("pause");
        return 0;
    }
    展开全文
  • 数组形参 当我们为函数传递一个数组时,实际上传递的是指向数组首元素的指针 数组形参不能以值传递的方式传递数组 以下三种写法等价,每个函数唯一的形参都是const int * void print(const int *) void print(const ...
  • C++数组形参的传递

    千次阅读 2019-01-15 09:59:57
    不允许拷贝:无法以值传递的方式使用数组形参 使用数组时通常都会转换为指针:当我们为函数传递一个数组时,实际上传递的是指向数组首元素的指针。 传参的方法 当下有一个数组int j[2]={0,1},我们自写了一个函数 ...
  • C++数组形参

    2017-08-21 21:58:50
    因为数组不允许被拷贝、所以我们无法以值传递得方式使用数组参数 使用数组时数组会被转换成指针使用,所以我们为一个函数传递一个参数时,实际上传递的是数组元素的首元素的指针 一下三种方式函数的声明是一致的:...
  • C++数组作为形参进行传递
  • 17 C++基础-数组形参

    2018-04-13 19:46:49
    1.数组形参 数组特性 - 不允许拷贝数组 - 使用数组时通常会将其转换为指针 void print(const int*) { } void print(const int[]) { } void print(const int[10]) { } 上述的函数的数组形参是等价...
  • c++数组形参

    2017-02-01 18:49:00
    圣经中讲到:模板非类型形参是模板定义内部的常量值,在需要常量表达式的时候,可使用非类型形参指定数组的长度, 当调用 func是,编译器会从数组的实参计算非类型形参的值,也就是编译器替我们 计算好了size的值...
  • C++中根本不存在所谓的“数组形参”,因为数组在传入时,实质上只传入指向其首元素的指针:void average(int ary[12]);//形参是一个int *这种从数组到指针的自动转换被称之为“退化”。
  • 简晰C++数组形参

    2006-10-28 17:57:00
    简晰C++数组形参#include using namespace std;void Foo1(int arr[100]){ cout }void Foo2(int (&arr)[100]){ cout }void main(){ int a[100]; cout Foo1(a); Foo2(a); }其运行结果如下: In main function :...
  • 揭开C/C++数组形参的迷雾

    千次阅读 2005-03-30 07:35:00
    揭开C/C++数组形参的迷雾作者:乾坤一笑 文章来源:本站原创 点击数: 325 更新时间:2004-11-29揭开C/C++数组形参的迷雾作者:乾坤一笑楔子 去年,周星星大哥曾经在VCKBASE/C++论坛发表过一篇文章“数组引用...
  • C++函数的数组形参

    2017-12-05 11:17:48
    1 不允许将实参数组拷贝给形参 不能将数组的内容拷贝给其它数组作为其初始值,也不能用数组为...所以,当数组作为函数的实参时,不能将其元素拷贝给形参。 2 将数组名转换为指针 在很多用到数组名字的地方,编译器都

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,117
精华内容 446
关键字:

c++数组形参

c++ 订阅