C ++ Концептуальная проблема с указателями (указателями)

Question

У меня есть структура, обычно содержащая указатель на int.Однако в некоторых особых случаях необходимо, чтобы этот указатель int указывал на другой указатель, который затем указывает на int.Вау: я уже упоминал слово указатель 5 раз!

• Возможно ли это?

Я думал об этом так: вместо использования второго указателя типа int,что, скорее всего, невозможно, так как мой основной указатель на int может указывать только на int, а не на другой указатель на int, я мог бы сделать ссылку следующим образом:

int intA = 1;
int intB = 2;
int& intC = intB;

int* myPointers[ 123 ];
myPointers[ 0 ] = &intA;
myPointers[ 1 ] = &intB;
myPointers[ 3 ] = &intC;

Так что вышеприведенное будет делать то, что я хочу: Ссылка на intB (intC) ведет себя так, как я хочу (если она изменяется, она также меняется intB)

• Проблема: я не могу изменить ссылки один разони установлены, верно?Или есть способ?

Все вкратце: как получить значение для работы с * (указатели) и ** (указатели на указатели)?

Answer 1

int* и int** - это разные типы, поэтому вы не можете использовать один как другой без использования потенциально непереносимого приведения.

В декларации:

int& intC = intB;

Ссылка intC всегда будет ссылаться на int intB. Привязка не может быть изменена.

Вы можете использовать объединение для поддержки типа, который может быть либо int*, либо int**, но вам нужно быть уверенным, когда вы читаете, какой член объединения допустим в любой момент.

union PIntOrPPInt
{
    int* pint;
    int** ppint;
};

int intA;
int intB;
int* pintC = &intB;

PIntOrPPInt myPointers[ 123 ];

myPointers[ 0 ].pint = &intA;
myPointers[ 1 ].pint = &intB;
myPointers[ 3 ].ppint = &pintC;

Answer 2

Мы редко, если вообще используем указатели на указатели в C ++. Вместо этого, как вы предлагаете, мы используем ссылку на указатели. Тем не менее, C ++ является строго типизированным языком со статической типизацией. Поэтому вы должны решить во время компиляции, на что будут указывать элементы массива.

Один из подходов состоит в том, чтобы обернуть элементы массива в классе:

struct P {
    P() : p(0) { }
    P(int* p) : p(p) { }
    P(int** p) : p(*p) { }
    operator int*() const { return p; }
    int *p;
};

int main(int argc, char* argv[])
{
    int *i1 = new int(5);
    int **i2 = &i1;
    int *&i3 = i1;
    P arr[4] = {i1, i2, i3, P()};
    delete i1;
    return 0;
}

Answer 3

Вы можете поместить указатель на intB в обоих элементах массива:

myPointers[ 1 ] = &intB;
myPointers[ 3 ] = &intB;

Таким образом, оба элемента указывают на одну и ту же переменную, и *myPointers[1] всегда будет таким же, как *myPointers[3]. Это то, чего вы хотите достичь?