Question

我在函数声明中多次发现这些符号，但我不知道它们是什么意思。

示例：

void raccogli_dati(double **& V, double **p, int N) { 
  int ultimo = 3; 
  V = new double * [N/2]; 
  for(int i=0; i < N/2; i++) { 
    V[i] = new double[N/2], std :: clog << "digita " << N/2 - i
                 << " valori per la parte superiore della matrice V: "; 
    for(int j=i; j < N/2; j++) 
      std :: cin >> V[i][j], p[ultimo++][0] = (V[i][j] /= sqrt(p[i][0]*p[j][0]));
  } 
  for(int i=1; i < N/2; i++) 
    for(int j=0; j < i; j++) 
       V[i][j] = V[j][i];
}

Answer 1

这是通过引用获取参数。因此，在第一种情况下，您通过引用获取指针参数，因此您对指针值所做的任何修改都会反映在函数外部。第二个是与第一个相似，唯一的区别是它是一个双指针。见这个例子：

void pass_by_value(int* p)
{
    //Allocate memory for int and store the address in p
    p = new int;
}

void pass_by_reference(int*& p)
{
    p = new int;
}

int main()
{
    int* p1 = NULL;
    int* p2 = NULL;

    pass_by_value(p1); //p1 will still be NULL after this call
    pass_by_reference(p2); //p2 's value is changed to point to the newly allocate memory

    return 0;
}

Answer 2

首先是对指针的引用，第二个是对指针的指针的引用。另请参阅how pointers and references differ上的常见问题解答。

void foo(int*& x, int**& y) {
    // modifying x or y here will modify a or b in main
}

int main() {
    int val = 42;
    int *a  = &val;
    int **b = &a;

    foo(a, b);
    return 0;
}

Answer 3

通过引用而不是值传递指针。例如，这允许在函数中改变指针（而不是指向对象），使调用代码看到更改。

比较

void nochange( int* pointer ) //passed by value
{
   pointer++; // change will be discarded once function returns
}

void change( int*& pointer ) //passed by reference
{
   pointer++; // change will persist when function returns
}

Answer 4

int*是指向int的指针，因此int*&必须是指向int的指针。同样，int**是指向int指针的指针，因此int**&必须是指向指向int的指针的引用。

Answer 5

为了理解这些短语，我们来看几件事：

typedef double Foo;
void fooFunc(Foo &_bar){ ... }

所以通过引用传递双倍。

typedef double* Foo;
void fooFunc(Foo &_bar){ ... }

现在它通过引用将指针传递给double。

typedef double** Foo;
void fooFunc(Foo &_bar){ ... }

最后，它通过引用将指针传递给指向double的指针。如果您按照这样的typedef来思考，您将理解＆amp;的正确排序。和*加上它意味着什么。

Answer 6

*&表示通过引用接收指针。这意味着它是传递参数的别名。因此，它会影响传递参数。

#include <iostream>
using namespace std;

void foo(int *ptr)
{
    ptr = new int(50);    // Modifying the pointer to point to a different location
    cout << "In foo:\t" << *ptr << "\n"; 
    delete ptr ;
}

void bar(int *& ptr)
{
    ptr = new int(80);    // Modifying the pointer to point to a different location
    cout << "In bar:\t" << *ptr << "\n"; 
    // Deleting the pointer will result the actual passed parameter dangling
}
int main()
{
    int temp = 100 ;
    int *p = &temp ;

    cout << "Before foo:\t" << *p << "\n";
    foo(p) ;
    cout << "After foo:\t" << *p << "\n";

    cout << "Before bar:\t" << *p << "\n";
    bar(p) ;
    cout << "After bar:\t" << *p << "\n";

    delete p;

    return 0;
}

输出：

Before foo: 100
In foo: 50
After foo:  100
Before bar: 100
In bar: 80
After bar:  80

Answer 7

通常，您可以从右到左读取变量的声明。因此，对于int *ptr;来说，这意味着您对 Integer变量 *具有 Pointer int。同样，在声明为int **ptr2;时，它也是指向 Integer的 Pointer变量 *的 Pointer变量 *变量 int，与"(int *)* ptr2;"

相同

现在，按照声明int*& rPtr;的语法，我们说这是指向 Pointer &的引用 *到类型为int的变量。最后，对于int**& rPtr2;，您也可以再次应用此方法，表明它表示对 Pointer &的引用 * 指针 *指向整数 int。

Answer 8

此 *＆在理论上和实际中都可能使用，并称为对指针变量的引用。和它的行为一样。此 *＆组合用作“传递”类型定义的函数参数。与**不同，也可以用于声明双指针变量。
参数的传递分为按值传递，按引用传递，按指针传递。关于“通过”类型，有各种答案。但是，对于该主题，我们需要了解的基本知识是。

按引用传递 ->通常在传递给函数takeLatest(LOGIN_REQUESTED, watchForLogin) takeLatest(LOGIN_SUCCESSFUL, watchForLoginSuccess) watchForLogin(action) { doLogin('/some/url') .then(response => dispatch(loginSuccess(response))) // dispatch login success .catch(error => dispatch(loginFailed(error))) // dispatch error } watchForLoginSuccess(action) { doSomethingAfterLogin() }

时对已创建的变量进行引用

通过指针传递 ->在已初始化的“指针变量/变量地址”上运行，传递给函数fun(int &a);

fun(int* a);

在上面的示例中（这是我遇到的现实问题），我试图从lambda函数初始化几个指针变量，为此，我们需要通过双指针传递它，因此带有d引用指针在该lambda +中的所有用法，同时在使用双指针的函数中传递指针时，您需要传递对指针变量的引用。

因此对指针变量 *＆的引用也与此相同，因此此组合很有帮助。对于上面我提到的相同示例，以下面的方式给出。

auto addControl = [](SomeLabel** label, SomeControl** control) {
    *label = new SomeLabel;
    *control = new SomeControl;
    // few more operation further.
};

addControl(&m_label1,&m_control1);
addControl(&m_label2,&m_control2);
addControl(&m_label3,&m_control3);

所以在这里您可以看到您既不需要d引用，也不需要在传递函数时传递对指针变量的引用，因为当前按类型传递已经是对指针的引用。

希望这会有所帮助：-）

*＆amp;的含义和**＆amp;在C ++中

8 个答案: