Значение * & и ** & в С++

Ответ 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  value is changed to point to the newly allocate memory

    return 0;
}

Ответ 2

Сначала это ссылка на указатель, вторая - ссылка на указатель на указатель. См. Также FAQ на как отличаются указатели и ссылки.

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;
}

Ответ 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
}

Ответ 4

int* - это указатель на int, поэтому int*& должен быть ссылкой на указатель на int. Аналогично, int** - это указатель на указатель на int, поэтому int**& должен быть ссылкой на указатель на указатель на int.

Ответ 5

Чтобы понять эти фразы, рассмотрим пару вещей:

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

Итак, передаем двойной по ссылке.

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

теперь он передает указатель на двойную ссылку.

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

Наконец, он передает указатель на указатель на двойную ссылку. Если вы думаете в терминах typedefs, как это, вы поймете правильное упорядочение и и * плюс то, что это значит.

Ответ 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

Ответ 7

Как правило, вы можете прочитать объявление переменной справа налево. Следовательно, в случае int *ptr; , это означает, что у вас есть указатель * на целочисленную переменную int. Также, когда он объявил int **ptr2; , это переменная Pointer * для переменной Pointer * указывающая на целочисленную переменную int, которая совпадает с "(int *)* ptr2;"

Теперь, следуя синтаксису, объявив int*& rPtr; мы называем это ссылкой & на указатель * который указывает на переменную типа int. Наконец, вы можете снова применить этот подход также для int**& rPtr2; заключив, что это означает ссылку & на указатель * на указатель * на целое число int.

Ответ 8

Это * & amp; как в теории, так и на практике возможно и называется ссылкой на указатель переменной. и это действует как то же самое. Эта * & amp; комбинация используется в качестве параметра функции для определения типа "мимо". в отличие от ** также может использоваться для объявления переменной двойного указателя.
Передача параметра делится на передачу по значению, передачу по ссылке, передачу по указателю. Существуют различные ответы о доступных типах передачи. однако основное, что нам необходимо понять для этой темы, -

.передача по ссылке → обычно работает с уже созданной переменной, на которую ссылаются при передаче функции, например fun(int &a);

передача по указателю → Работает с уже инициализированной "переменной-указателем/адресом переменной", передаваемой в функцию, например, fun(int* a);

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; эта комбинация помогает. ниже приведен способ для того же примера, который я упоминал выше.

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-ссылки, ни того, чтобы мы передавали ссылку на переменную-указатель при передаче в функцию, поскольку текущая передача по типу уже является ссылкой на указатель.

Надеюсь это поможет :-)