Блог

Перегружен operator* и operatoramp;

Оба operatoramp; (унарный) и operator* (унарный) могут быть перегружены.

Это означает, что if n является типом класса type , то *n может буквально иметь любую форму, включая, но не ограничиваясь type* , typeamp; , type .

Примером (глупым, но все же допустимым примером) было бы:

 struct type {
    int x;
};

intamp; operatoramp;(typeamp; t) {
    return t.x;
}
 

Live demo

Косвенность

У вас также может быть бесконечное количество косвенных указателей. В этом случае *n , **n , ***n также может привести Type* к, а также Typeamp; .

В качестве примера, учитывая две функции:

 void func_ptr(int*) {}
void func_ref(intamp;) {}
 

и следующие объекты:

 int a;
int* b = amp;a;
int** c = amp;b;
int*** d = amp;c;
 

тогда допустимо любое из следующих действий:

 func_ptr(b);
func_ptr(*c);
func_ptr(**d);

func_ref(*b);
func_ref(**c);
func_ref(***d);
 

Live demo

Заключение

Правильны ли таблица и пояснения? Есть ли какие-либо случаи, исключенные из таблицы (кроме производных, таких как *amp; n, указатель на указатель и т. Д.)?

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

Возможно, я неправильно интерпретирую вашу таблицу, но предполагая, что вы находитесь внутри трех функций слева и хотите получить int* n , использовать n и привязать ссылку к int значению, доступ к которому осуществляется через n соответственно:

Ваша исходная таблица

                    int *n   int n   int amp;n
void foo(int *n)     n       amp;n      n/amp;n
void foo(int n)     *n       n      n/*n
void foo(int amp;n)    n/*n     n/amp;n      n
 

Учитывая сигнатуры функций слева, у вас есть следующие ошибки:

В foo(int* n) :

• чтобы получить int , что вы *n не хотите amp;n
• вы должны привязать любые новые intamp; s к *n

В foo(int n)

• чтобы получить указатель на n вы amp;n не хотите *n
• чтобы привязать an intamp; к n тому, что вы хотите n , а не *n
• обратите внимание, что n это локальное, скопированное и отличное от вызывающего n

В foo(intamp; n) :

• чтобы получить указатель на n то, что вы amp;n не n хотите или *n
• чтобы использовать n , вы просто n не хотите / никогда amp;n

Итак, я бы написал таблицу следующим образом (я добавил столбцы для адреса n и является ли n это n из вызывающего контекста или локальной копии)

Предлагаемая исправленная таблица

                     int*   int    intamp; n2 = ...    int* p = ...   caller/local
void foo(int* p_n)   p_n   *p_n      *p_n            p_n             caller
void foo(int n)      amp;n     n         n              amp;n              local
void foo(intamp; n)     amp;n     n         n              amp;n              caller
 

Однако я не уверен, что такая таблица имеет большую полезность для разъяснения роли ссылок и указателей.

ОБНОВЛЕНИЕ: в вашем комментарии объясняется, что вы хотели, чтобы таблица передавала «форму передачи», которая, как я понимаю, является кодом, который вам понадобится внутри вызывающей стороны foo . Правильная таблица для этого должна быть:

                    int *n   int n   int amp;n    caller/local
void foo(int *n)     n       amp;n      amp;n          caller
void foo(int n)     *n       n       n           local
void foo(int amp;n)    *n       n       n           caller