精华内容
下载资源
问答
  • 题中a是int*类型的,b是指向int*的引用,按理应该是正确的啊,为什么会报错呢?这是因为编译器对指向数组的引用检查更加严格,需要检查数组的维数,在这里a被理解成指向10个int数组的指针int [10],对于引用也需要...
  • 对数组引用

    2014-02-15 18:32:31
    所谓数组引用,即指向数组的引用; 如 int a[10] ;   int (&b)[10] = a ; 如果写成 int a[10] ;  int* &b = a ; 将会报错: cannot convert from 'int [10]' to 'int *&'。  或许你会说在数组名不...
    所谓数组引用,即指向数组的引用;
    如    int   a[10] ;    
         int   (&b)[10] = a ;
    如果写成 int   a[10] ;
                    int* &b = a ;
    将会报错: cannot convert from 'int [10]' to 'int *&'。
      或许你会说在数组名不就是指向这个数组的一个指针吗?题中a是int*类型的,b是指向int*的引用,按理应该是正确的啊,为什么会报错呢?这是因为编译器对指向数组的引用检查更加严格,需要检查数组的维数,在这里a被理解成指向10个int数组的指针int [10],对于引用也需要相应的引用类型int (&)[10],即指向10个int数组的指针的引用。
    c和c++中有一个“数组降价”问题。
    #include <iostream>
    void test( char arr[100] )
    {
         std::cout << sizeof(arr) << std::endl ; // 输出 4
    }
    int main()
    {
        char arr[100] = { 0 };
        std::cout << sizeof(arr) << std::endl; // 输出 100 
        test( arr );

        return 0 ;
    }
    这段代码的输出是100
                                4

          对于同样的arr,一个输出100,另一个输出4。是因为void test( char arr[100] )中的arr被降价了。
    void test( char arr[100] ) 中的arr被降阶处理了,
           void test( char arr[100] ) 等同于void test( char arr[] ), 也等同于
      void test( char* const arr ) 如果你原意,它甚至等同于
      void test( char arr[10] )
      编译器对数组的维数不作检查。
    也就是说
    void test( char arr[100] )
    {
         std::cout << sizeof(arr) << std::endl;
    }

    被降成
    void test( char* const arr )
    {       std::cout << sizeof(arr) << std::endl; // 既然是char*,当然输出4
    }     这样,即然不检查数组的大小,对于需要保证数组大小的程序就会带来问题。如何解决这个问题呢?可以用c++中的对数组的引用。
    看下面这段代码:
    ......
    void test( const char (&arr)[100] )
    {
         std::cout << sizeof(arr) << std::endl ; // 输出 100
    }
    ......
        char arr[100] = { 0 };
        std::cout << sizeof(arr) << std::endl; // 输出 100 
        test( arr );
    ......
    这样test就能接受100个char的数组,且只能接受大小为100的char数组
    如果
      char arr[20] = {0};
           test( arr ) ;
    就会报错
      在C++ 中,对数组的引用可以直接传递数组名,因为数组的大小的信息已在形参里提供了。但是这样一来我们只能固定数组的大小来用这个函数了。用模板加数组的引用可以解决这个问题,看如下代码:
    template <int sz>
    void test(char (&arr)[sz])
    {
        for ( int i = 0; i < sz; i++ )
              ......}char a[2] = { 0 }, b[15] = { 0 };test(a);  //oktest(b);  //ok......
         这样解决了数组长度可变的问题,但也引入了新的问题:
    (1)当有多个不同的test调用时,会产生多份test代码。而传统的函数调用只有一份代,也调用的次数无关。
    (2)由于这些代码都是在编译阶段生成的,它需要知道引用数组的大小。所以这样写的函数显然不能用指针变量作为函数的参数,因此不能用这个函数处理动态分配的内存区域,这样的区域的大小是在运行时确定的。
    展开全文
  • 对数组引用

    千次阅读 2012-10-01 20:36:52
    在Bjarne Stroustrup(C++创始人,他的主页)所写的《The C++ Programming Language, special edition》书中的第5章5.9节的第1题练习题中,要求写一个声明语句并进行初始化,“a reference to an array of 10 integers...

    在Bjarne Stroustrup(C++创始人,他的主页)所写的《The C++ Programming Language, special edition》书中的第5章5.9节的第1题练习题中,要求写一个声明语句并进行初始化,“a reference to an array of 10 integers”,实现如下:

    //an array of 10 integers
    int arry[10] = {0};
    
    //a reference to an array of 10 integers
    int (&rcp)[10] = arry;

    因为&的优先级低于[],所以要加上圆括号,不加圆括号,则表示数组的每个元素的类型为int &:

    int &rcp[10];

    如果将数组名理解为常量指针,则也可以这样写:

    int *const &rcp1 = arry;//reference to a constant pointer to integer

    不过,这里的变量rcp1变成了对一个常量指针的引用。

    利用数组引用及模板,可以实现一个获取任意类型数组大小的函数:

    template<class T, size_t N>
    size_t getArraySize(T (&)[N]) {
      return N;
    }

    函数的参数必须为数组名或数组引用:

    int main() {
      int iarry[10];
      int (&rarry)[10] = iarry;
      int *const parry = iarry;
      cout << getArraySize(iarry) << endl; //output: 10
      cout << getArraySize(rarry) << endl; //output: 10
      cout << getArraySize(parry) << endl; //error
    
      return 0;
    }

    展开全文
  • c++对数组引用

    2014-05-20 14:17:33
    所谓数组引用,即指向数组的引用; 如 int a[10] ;   int (&b)[10] = a ; 如果写成 int a[10] ;  int* &b = a ; 将会报错: cannot convert from 'int [10]' to 'int *&'。  或许你会说在数组名不...
    所谓数组引用,即指向数组的引用;
    如    int   a[10] ;   
         int   (&b)[10] = a ;
    如果写成 int   a[10] ;
                    int* &b = a ;
    将会报错: cannot convert from 'int [10]' to 'int *&'。
      或许你会说在数组名不就是指向这个数组的一个指针吗?题中a是int*类型的,b是指向int*的引用,按理应该是正确的啊,为什么会报错呢?这是因为编译器对指向数组的引用检查更加严格,需要检查数组的维数,在这里a被理解成指向10个int数组的指针int [10],对于引用也需要相应的引用类型int (&)[10],即指向10个int数组的指针的引用。
    c和c++中有一个“数组降价”问题。
    #include <iostream>
    void test( char arr[100] )
    {
         std::cout << sizeof(arr) << std::endl ; // 输出 4
    }
    int main()
    {
        char arr[100] = { 0 };
        std::cout << sizeof(arr) << std::endl; // 输出 100 
        test( arr );

        return 0 ;
    }
    这段代码的输出是100
                                4

          对于同样的arr,一个输出100,另一个输出4。是因为void test( char arr[100] )中的arr被降价了。
    void test( char arr[100] ) 中的arr被降阶处理了,
           void test( char arr[100] ) 等同于void test( char arr[] ), 也等同于
      void test( char* const arr ) 如果你原意,它甚至等同于
      void test( char arr[10] )
      编译器对数组的维数不作检查。
    也就是说
    void test( char arr[100] )
    {
         std::cout << sizeof(arr) << std::endl;
    }

    被降成
    void test( char* const arr )
    {       std::cout << sizeof(arr) << std::endl; // 既然是char*,当然输出4
    }     这样,即然不检查数组的大小,对于需要保证数组大小的程序就会带来问题。如何解决这个问题呢?可以用c++中的对数组的引用。
    看下面这段代码:
    ......
    void test( const char (&arr)[100] )
    {
         std::cout << sizeof(arr) << std::endl ; // 输出 100
    }
    ......
        char arr[100] = { 0 };
        std::cout << sizeof(arr) << std::endl; // 输出 100 
        test( arr );
    ......
    这样test就能接受100个char的数组,且只能接受大小为100的char数组
    如果
      char arr[20] = {0};
           test( arr ) ;
    就会报错
      在C++ 中,对数组的引用可以直接传递数组名,因为数组的大小的信息已在形参里提供了。但是这样一来我们只能固定数组的大小来用这个函数了。用模板加数组的引用可以解决这个问题,看如下代码:
    template <int sz>
    void test(char (&arr)[sz])
    {
        for ( int i = 0; i < sz; i++ )
              ......
    }
    char a[2] = { 0 },
    char b[15] = { 0 };
    test(a);  //ok
    test(b);  //ok......
         这样解决了数组长度可变的问题,但也引入了新的问题:
    (1)当有多个不同的test调用时,会产生多份test代码。而传统的函数调用只有一份代,也调用的次数无关。
    (2)由于这些代码都是在编译阶段生成的,它需要知道引用数组的大小。所以这样写的函数显然不能用指针变量作为函数的参数,因此不能用这个函数处理动态分配的内存区域,这样的区域的大小是在运行时确定的。
    展开全文
  • C/C++对数组引用

    千次阅读 2011-06-30 22:46:00
    所谓数组引用,即指向数组的引用;如: int a[10] ; int (&b)[10] = a ;如果写成: int a[10] ; int* &b = a ;将会报错: cannot convert from int [10] to int *&。或许你会说
    所谓数组引用,即指向数组的引用;
    如:               int   a[10] ;   
                        int   (&b)[10] = a ;
    如果写成:     int   a[10] ;
                        int* &b = a ;
    将会报错: cannot convert from 'int [10]' to 'int *&'。

    或许你会说在数组名不就是指向这个数组的一个指针吗?题中a是int*类型的,b是指向int*的引用,按理应该是正确的啊,为什么会报错呢?这是因为编译器对指向数组的引用检查更加严格,需要检查数组的维数,在这里a被理解成指向10个int数组的指针int [10],对于引用也需要相应的引用类型int (&)[10],即指向10个int数组的指针的引用。
    c和c++中有一个“数组降价”问题。
    #include <iostream>
    void test( char arr[100] )
    {
         std::cout << sizeof(arr) << std::endl ; // 输出 4
    }
    int main()
    {
        char arr[100] = { 0 };
        std::cout << sizeof(arr) << std::endl; // 输出 100 
        test( arr );
        return 0 ;
    }
    这段代码的输出是:  100
                                      4

    对于同样的arr,一个输出100,另一个输出4。是因为void test( char arr[100] )中的arr被降价了。
    void test( char arr[100] ) 中的arr被降阶处理了,
    void test( char arr[100] ) 等同于void test( char arr[] ), 也等同于
    void test( char* const arr ) 如果你原意,它甚至等同于
    void test( char arr[10] )
    编译器对数组的维数不作检查。也就是说
    void test( char arr[100] )
    {
         std::cout << sizeof(arr) << std::endl;
    }

    被降成
    void test( char* const arr )
    {    
      std::cout << sizeof(arr) << std::endl; // 既然是char*,当然输出4
    }    
    这样,即然不检查数组的大小,对于需要保证数组大小的程序就会带来问题。如何解决这个问题呢?可以用c++中的对数组的引用。
    看下面这段代码:

    void test( const char (&arr)[100] )
    {
         std::cout << sizeof(arr) << std::endl ; // 输出 100
    }
    char arr[100] = { 0 };
    std::cout << sizeof(arr) << std::endl; // 输出 100 
    test( arr );

    这样test就能接受100个char的数组,且只能接受大小为100的char数组
    如果:
    char arr[20] = {0};
    test( arr ) ;
    就会报错
    在C++ 中,对数组的引用可以直接传递数组名,因为数组的大小的信息已在形参里提供了。但是这样一来我们只能固定数组的大小来用这个函数了。用模板加数组的引用可以解决这个问题,看如下代码:
    template <int sz>
    void test(char (&arr)[sz])
    {
        for ( int i = 0; i < sz; i++ )
              ......
    }
    char a[2] = { 0 }, b[15] = { 0 };
    test(a);  //ok
    test(b);  //ok

    这样解决了数组长度可变的问题,但也引入了新的问题:
    (1)当有多个不同的test调用时,会产生多份test代码。而传统的函数调用只有一份代,也调用的次数无关。
    (2)由于这些代码都是在编译阶段生成的,它需要知道引用数组的大小。所以这样写的函数显然不能用指针变量作为函数的参数,因此不能用这个函数处理动态分配的内存区域,这样的区域的大小是在运行时确定的。


    展开全文
  • perl对数组的操作

    万次阅读 2013-11-14 10:43:37
    本文和大家重点讨论一下Perl语法中Perl数组和列表,列表是包含在括号里的一序列的值,可以为任何数值,也可为空,如: ...my @array1 = ( 'a' .. 'd' ); my @replaced = splice( @array, 3, 2 ...
  • 反观数组,当数组作为形参,形参和实参都放在一个栈中,但是他们指向的是同一个数组,也就是说形参实参共享这个数组,所以实参传值传的其实是个引用,指向同一个数组,形参在方法中变了,那么实参也会变;...
  • 对数组取地址的一点问题

    千次阅读 2009-10-28 15:25:00
    在看《深入浅出MFC》的时候,遇到了如题的问题,去网上查了下,原来如此原帖地址...[4] 我通过下面一段程序发现:通常说a实质是数组的地址,那么: int a[3][4]; co
  • 对数器:很多测试算法的案例,通过使用对数器可以检验你的算法是否正确。 使用对数器: 1.有一个你要测试的方法a:这里以插入排序为例 template&amp;amp;amp;amp;lt;typename T&amp;amp;amp;amp;gt; void ...
  • 1 对数几率回归原理分析 1.1 引入 1.2 损失函数 1.3 求最优解 2 对数几率回归实践 Logistic回归的一般过程 Logistic回归的优缺点 Logistic回归算法描述(改进的随机梯度下降) 《机器学习实战》第五章代码...
  • 该楼层疑似违规已被系统折叠隐藏此楼查看此楼西工大机考《C语言程序设计》网考寻求答案(非免费)找我Q...,以下选项中对a数组元素正确引用的是( )。A.a[2][!1]B.a[2][3]C.a[0][3]D.a[1>2][!1]2. 以下描述错误的是...
  • c语言中在某个文件中定义的全局变量可以在不同的文件中引用对数组和指针这两种全局变量在使用时必须要注意,外部引用格式不正确时会出现编译或运行错误。下面通过不同的例子来说明数组和指针类型全局变量的引用。 ...
  • 引用数组元素

    千次阅读 2019-04-24 17:15:47
    a[i] 和 p[i] 两种形式。在编译时这两种形式也要处理成 *(a+i) 或 *(p+i) ,即先按“a+i x(一个元素占用字节数)”计算出第 i 号元素的地址,然后通过指针运算 符 “ * ” 来引用该元素。 下面举个例子看一下这两种...
  • 假设我们定义了一个ArrayWrapper的类,这个类对数组进行了封装。 [cpp]   view plain copy class  ArrayWrapper  {    public :   ArrayWrapper ( int  n)...
  • JS学习4(引用类型)

    千次阅读 2016-04-21 16:20:05
    引用类型是一种数据结构,用于将数据和功能组织在一起。对象是某个特定引用类型的实例。新对象使用new操作符后面跟一个构造函数来创建,构造函数本身就是一个函数,只不过这个函数是出于创建新对象而定义的。 var...
  • 1.不能建立引用数组,但是可以建立数组的引用。 c++中,引用可以说只是某个变量的别名,所谓别名,是和指针类型区分开的,指针类型可以指向某个变量,而且指针类型本身也是一个变量,而引用本身实际上不是一个变量...
  • C++中引用的理解

    2012-12-03 22:14:02
    1.引用(reference)是c++对c语言的重要扩充。 2.引用就是某一变量(目标)的一个别名,对引用的操作与对变量直接操作完全一样。 3.声明引用时,必须同时对其进行初始... a为目标原名称,ra为目标引用名。给ra赋值:
  • 如何引用数组呢?

    2020-12-06 11:53:59
    数组引用的方式 1、下标法 2、指针法 方法分析 下标法:(i=0;i<length;i++) 指针法:(p=a;p<(a+10);p++) (指针=数组名,引用第一个元素;指针<(数组名+数组长度);指针++) 代码如下: #include <stdio...
  • C++传参数的正确姿势

    千次阅读 2017-11-19 21:20:09
    vector传递参数  前几天写一个很简单的c++程序,但是中间遇到了很有趣的问题,搞得我当时一顿懵,后来弄懂了,简单总结一下。   话说到底是什么问题...  咱们以对数组的元素加一为例,首先数组以两种方式来表示
  • C语言数组引用

    千次阅读 2018-05-01 14:05:07
    一维数组元素的引用:数组元素的一般形式为:数组名[下标](下标从0开始)printf("%d\n",arr[5])数组名arr通常情况下代表数组元素的首地址printf("%d\n",arr); //输出为1数组名arr在两种情况...
  •  eg: *(a+i) 或 *(p+i) //其中a为数,*(a+i)意为a数组的首地址+i——即指向第i个元素{注意:这里不是说地址加上i,要看是什么类型,eg:char型的话一个字节一个地址,int类型的话VC++中是4个字节一个地址,...
  • 建议26:用引用代替指针  指针,可以通向内存世界,让我们具备了对硬件直接操作的超级能力。C++意识到了强大指针所带来的安全隐患,所以它适时地引入了一个新概念:引用引用,从逻辑上理解就是“别名”,通俗地讲...
  • 为什么不能建立引用数组?

    千次阅读 2015-10-02 10:20:56
    引用就是某一个变量的别名,引用的地址就是原变量的地址,引用的值就是原变量的值 不能建立引用的数组,例如:int & ref[3] = { 2, 3, 5}; //声明ref引用的数组是错误的 但是可以建立数组的引用:例如:int arr[3]; ...
  • 引用代替指针

    千次阅读 2013-06-20 19:36:00
    建议26:用引用代替指针(1) 指针,可以通向内存世界,让我们具备了对硬件直接操作的超级能力。C++意识到了强大指针所带来的安全隐患,所以它适时地引入了一个新概念:引用引用,从逻辑上理解就是“别名”,通俗...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 21,149
精华内容 8,459
关键字:

对数组a的正确引用