Question

我有一个问题。

void static splitArray(int *A, int size, int ind1, int ind2, int *&first, int &firstSize, int *&second, int &secondSize)
{
    firstSize = ind2 - ind1 + 1;
    secondSize = size - firstSize;
    first = new int[firstSize];
    second = new int[secondSize];
    int cnt1 = 0, cnt2 = 0;

    for (int i = 0; i < size; i++){ 
        if ((i >= ind1) && (i <= ind2)){
            first[cnt1] = A[i];
            cnt1++;
        } 
        else {
            second[cnt2] = A[i];
            cnt2++;
        }
    }

此函数用于在参数中的给定数字索引之间拆分输入数组，并组合剩余部分并填充参数中的数组。但在参数，参考和dereferance运算符一起使用。（*＆amp;）它是否应该相互抵消？它是如何工作的？你能帮我吗？

Answer 1

考虑一个简单的例子

int x;
int &rx = x;

int *p;
int * &rp = p;

声明

int *&first

是对int *

类型的对象的引用的声明

在functipn变量的主体中，第一个和第二个变量被改变。

first = new int[firstSize];
second = new int[secondSize];

因为它们是对参数的引用，所以这些更改实际上将与作为参数传递给函数的原始对象一起完成。

Answer 2

这里有一个指向int的指针的引用传递给函数。

退一步，如果你只将'指向一个int的指针'传递给一个函数，一旦进入函数内部，就可以改变指针指向的位置（即你可以改变指针所在位置的内存位置）将指向）。

在这种情况下，因为你传递了一个指向int的指针（想象它就像另一个间接级别，即此处的间接级别等同于间接级别，就好像你有指向指针的指针一样）一个int），你实际上可以改变指针本身的内存位置。

Answer 3

它看起来确实很奇怪，但可以使一些代码看起来更简单。考虑两种创建数组的等效方法：

void array_byref(int*& p)
{
  p = (int*) malloc(sizeof(int)*3);
  p[0] = 0;
  p[1] = 1;
  p[2] = 2;
}

void array_byptr(int** p)
{
  *p = (int*) malloc(sizeof(int)*3);
  (*p)[0] = 0;
  (*p)[1] = 1;
  (*p)[2] = 2;
}

顶部示例看起来比下面的示例更整洁，因为它组合了指针和引用。但是我并没有真正看到“在野外”的使用，所以我不认为这是常见的或良好的做法。

Answer 4

*和&字符可以做两件事：

他们声明指针和引用类型

int i = 7;   // this is just an int
int *p;      // this is a pointer-to-int
int &r = i;  // this is a reference-to-int;

他们操作取消引用指针并获取对象的地址（分别）

int i = *p; // dereference pointer-to-int p (and get an integer value)
p = &i;     // take the address of int i (and get a pointer-to-int)

我们可以在一些实际代码中显示它们：

// the function header is declaring the arguments,
// so here * and & are part of the type
int foo(int i,    // i is an int
        int *p,   // p is a pointer-to-int
        int &r,   // r is a reference-to-int
        int *&rp  // rp is a reference to a pointer-to-int
        )
{
    // the function body is executing statements,
    // so * and & here mean the operators
    *p = i; // operator* dereferences pointer p,
            // then we store the value of i at that address
    r = i;  // references do this automatically
    rp = p; // we just changed the caller's pointer-to-int,
            // via the reference, so it points to the same int as p
    p = &i; // then we used operator& to take the address of i, and
            // point our local copy of pointer-to-int p there

    // one last declaration, for old time's sake
    int &l = *p; // a reference to the integer p points at
    return l;
}

你可以运行它来查看效果：

#include <iostream>
using namespace std;
int main() {
   const int c = 42;
   int i = 7;
   int *in = &i;
   int **out = 0;

   int result = foo(c, in, i, out);
   cout << "c   = " << c << endl;
   cout << "i   = " << i << endl;
   cout << "in  = " << in << ", *in = " << *in << endl;
   cout << "out = " << out << ", *out = " << *out << endl;
}

C ++引用和解除引用

4 个答案: