Покажчики на покажчики проти звичайних покажчиків

Призначення вказівника - зберегти адресу певної змінної. Тоді структура пам'яті наступного коду повинна виглядати так:

int a = 5;
int *b = &a;

...... адреса пам'яті ...... значення
a ... 0x000002 ................... 5
b ... 0x000010 ..... .............. 0x000002

Гаразд Тоді припустимо, що зараз я хочу зберегти адресу вказівника * b. Тоді ми зазвичай визначаємо подвійний покажчик ** c, як

int a = 5;
int *b = &a;
int **c = &b;

Тоді структура пам'яті виглядає так:

...... адреса пам'яті ...... значення
a ... 0x000002 ................... 5
b ... 0x000010 ..... .............. 0x000002
c ... 0x000020 ................... 0x000010

Отже ** c посилається на адресу * b.

Зараз моє запитання: чому цей тип коду,

int a = 5;
int *b = &a;
int *c = &b;

генерувати попередження?

Якщо метою вказівника є просто збереження адреси пам'яті, я думаю, що не повинно бути ніякої ієрархії, якщо адреса, яку ми збираємося зберегти, стосується змінної, вказівника, подвійного вказівника тощо, тому код нижченаведеного типу повинен бути дійсним.

int a = 5;
int *b = &a;
int *c = &b;
int *d = &c;
int *e = &d;
int *f = &e;

В

int a = 5;
int *b = &a;   
int *c = &b;

Ви отримуєте попередження, оскільки &bмає тип int **, і намагаєтесь ініціалізувати змінну типу int *. Немає неявних перетворень між цими двома типами, що веде до попередження.

Щоб взяти довший приклад, який ви хочете попрацювати, якщо ми спробуємо здійснити розстановку посилань, fкомпілятор дасть нам int, а не вказівник, на який ми зможемо надалі проводити розмежування.

Також відзначимо , що в багатьох системах intі int*не той же розмір (наприклад, покажчик може бути 64 біт в довжину і AN int32 біта). Якщо ви розблокуєте посилання fта отримаєте значення int, ви втратите половину значення, і тоді ви навіть не зможете передати його на дійсний покажчик.

Якщо метою вказівника є просто збереження адреси пам'яті, я думаю, не повинно бути ієрархії, якщо адреса, яку ми збираємося зберегти, стосується змінної, вказівника, подвійного вказівника, ... і т.д.

Так, під час виконання вказівник просто містить адресу. Але під час компіляції також існує тип, пов'язаний з кожною змінною. Як уже говорили інші, int*і int**це дві різні, несумісні типи.

Існує один тип, void*який робить те, що ви хочете: він зберігає лише адресу, ви можете призначити їй будь-яку адресу:

int a = 5;
int *b = &a;
void *c = &b;

Але коли ви хочете розпізнати a void*, вам потрібно надати інформацію про тип "відсутнього":

int a2 = **((int**)c);

Зараз моє запитання: чому цей тип коду,

int a = 5; 
int *b = &a; 
int *c = &b; 

генерувати попередження?

Потрібно повернутися до основ.

• змінні мають типи
• змінні містять значення
• покажчик - це значення
• покажчик посилається на змінну
• if p- значення покажчика, тоді *pце змінна
• якщо vє змінною, то &vє покажчиком

І тепер ми можемо знайти всі помилки у вашій публікації.

Тоді припустимо, що зараз я хочу зберегти адресу вказівника *b

No. *b- це змінна типу int. Це не вказівник. bє змінною, значення якої є покажчиком. *b- змінна , значення якої є цілим числом.

**cпосилається на адресу *b.

НІ-НІ-НІ. Абсолютно не. Ви повинні правильно це розуміти, якщо збираєтеся розуміти вказівки.

*bє змінною; це псевдонім змінної a. Адреса змінної a- це значення змінної b. **cне посилається на адресу a. Швидше, це змінна, яка є псевдонімом змінної a. (І так само *b.)

Правильне формулювання така: значення змінної cє адреса з b. Або, еквівалентно: значення c- це вказівник, на який посилається b.

Звідки ми це знаємо? Поверніться до основ. Ви сказали це c = &b. Так у чому цінність c? Покажчик. До того, що? b.

Переконайтеся, що ви повністю розумієте основні правила.

Тепер, коли ви, сподіваємось, розумієте правильну залежність між змінними та покажчиками, ви зможете відповісти на своє запитання про те, чому ваш код видає помилку.

Система типів C вимагає цього, якщо ви хочете отримати правильне попередження і якщо ви хочете, щоб код взагалі скомпілювався. Тільки з одним рівнем глибини покажчиків ви б не знали, вказує вказівник на вказівник або на фактичне ціле число.

Якщо ви здійснюєте розмежування типу, int**ви знаєте, який тип ви отримуєте, int*і, подібним чином, якщо ви розрингуєте int*тип, це тип int. З вашою пропозицією тип буде неоднозначним.

На вашому прикладі неможливо зрозуміти, cвказує на a intчи int*:

c = rand() % 2 == 0 ? &a : &b;

На який тип вказує c? Компілятор цього не знає, тому наступний рядок виконати неможливо:

*c;

У C вся інформація про тип втрачається після компіляції, оскільки кожен тип перевіряється під час компіляції і більше не потрібен. Ваша пропозиція фактично витратить пам'ять і час, оскільки кожен покажчик повинен мати додаткову інформацію про час виконання про типи, що містяться в покажчиках.

Покажчики - це абстракції адрес пам’яті з додатковою семантикою типу, і такою мовою, як тип С, має значення.

По- перше, немає ніякої гарантії , що int *і int **мають однаковий розмір або подання (на сучасних настільних архітектур , які вони роблять, але ви не можете покладатися на це не скрізь так).

По-друге, тип має значення для арифметики покажчика. Враховуючи вказівник pтипу T *, вираз p + 1видає адресу наступного об’єкта типу T. Отже, припустимо такі декларації:

char  *cp     = 0x1000;
short *sp     = 0x1000;  // assume 16-bit short
int   *ip     = 0x1000;  // assume 32-bit int
long  *lp     = 0x1000;  // assume 64-bit long

Вираз cp + 1дає нам адресу наступного charоб'єкта, який буде 0x1001. Вираз sp + 1дає нам адресу наступного shortоб'єкта, який буде 0x1002. ip + 1дає нам 0x1004і lp + 1дає нам 0x1008.

Отже, дано

int a = 5;
int *b = &a;
int **c = &b;

b + 1дає нам адресу наступного intі c + 1дає нам адресу наступного вказівника на int.

Вказівники на покажчики потрібні, якщо ви хочете, щоб функція записувала в параметр типу вказівника. Візьміть такий код:

void foo( T *p )    
{
  *p = new_value(); // write new value to whatever p points to
}

void bar( void )
{
  T val;
  foo( &val );     // update contents of val
}

Це справедливо для будь-якого типуT . Якщо ми замінимо Tна тип покажчика P *, код стане

void foo( P **p )    
{
  *p = new_value(); // write new value to whatever p points to
}

void bar( void )
{
  P *val;
  foo( &val );     // update contents of val
}

Семантика абсолютно однакова, це лише типи, які різні; формальний параметр p- це завжди ще один рівень опосередкованості, ніж змінна val.

Я думаю, що не повинно бути ієрархії, якщо адреса, яку ми збираємося зберегти, стосується змінної, покажчика, подвійного покажчика

Без "ієрархії" було б дуже легко генерувати UB без жодних попереджень - це було б жахливо.

Розглянемо це:

char c = 'a';
char* pc = &c;
char** ppc = &pc;
printf("%c\n", **ppc);   // compiles ok and is valid
printf("%c\n", **pc);    // error: invalid type argument of unary ‘*’

Компілятор видає мені помилку і тим самим допомагає знати, що я зробив щось не так, і можу виправити помилку.

Але без "ієрархії", як:

char c = 'a';
char* pc = &c;
char* ppc = &pc;
printf("%c\n", **ppc);   // compiles ok and is valid
printf("%c\n", **pc);    // compiles ok but is invalid

Компілятор не може дати жодної помилки, оскільки немає "ієрархії".

Але коли рядок:

printf("%c\n", **pc);

виконується, це UB (невизначена поведінка).

Спочатку *pcчитає charтак, ніби це вказівник, тобто, можливо, читає 4 або 8 байтів, хоча ми зарезервували лише 1 байт. Тобто УБ.

Якщо програма не зазнала збою через UB вище, а просто повернула якесь значення вибору, другим кроком було б розмежування значення викиду. Ще раз УБ.

Висновок

Система типів допомагає нам виявляти помилки, розглядаючи int *, int **, int *** тощо, як різні типи.

Якщо метою вказівника є просто збереження адреси пам'яті, я думаю, що не повинно бути ніякої ієрархії, якщо адреса, яку ми збираємося зберегти, стосується змінної, вказівника, подвійного вказівника, ... і т. Д., Тому тип коду нижче має бути дійсним.

Думаю, тут є ваше непорозуміння: метою самого вказівника є збереження адреси пам'яті, але вказівник, як правило, також має тип, щоб ми знали, чого чекати в місці, на яке він вказує.

Особливо, на відміну від вас, інші люди дійсно хочуть мати таку ієрархію, щоб знати, що робити із вмістом пам'яті, на який вказує вказівник.

Саме суть системи покажчиків С має прикріплену до неї інформацію про тип.

Якщо ти зробиш

int a = 5;

&aмає на увазі, що те, що ви отримуєте, є int *таким, що, якщо ви переорієнтуєтесь, це буде intзнову.

Виводячи це на наступні рівні,

int *b = &a;
int **c = &b;

&bтакож є покажчиком. Але, не знаючи, що за цим ховається, відп. на що вказує, марно. Важливо знати, що розстановка посилання на вказівник виявляє тип оригінального типу, тож *(&b)це int *і **(&b)є оригінальним intзначенням, з яким ми працюємо.

Якщо ви відчуваєте, що у ваших обставинах не повинно існувати ієрархії типів, ви завжди можете працювати void *, хоча пряме використання досить обмежене.

Якщо метою вказівника є просто збереження адреси пам'яті, я думаю, що не повинно бути ніякої ієрархії, якщо адреса, яку ми збираємося зберегти, стосується змінної, вказівника, подвійного вказівника, ... і т. Д., Тому тип коду нижче має бути дійсним.

Ну, це справедливо для машини (адже приблизно все є числом). Але в багатьох мовах змінні вводяться, означає, що компілятор може потім переконатися, що ви використовуєте їх правильно (типи накладають правильний контекст на змінні)

Це правда, що вказівник на вказівник та вказівник (ймовірно) використовують однаковий обсяг пам’яті для зберігання їх значення (будьте уважні, це не відповідає дійсності для int та вказівника на int, розмір адреси не пов’язаний з розміром будинок).

Отже, якщо у вас є адреса адреси, яку ви повинні використовувати як є, а не як просту адресу, тому що якщо ви отримаєте доступ до вказівника до вказівника як простий вказівник, тоді ви зможете маніпулювати адресою int, як ніби це int , що ні (замінюйте int нічим іншим, і ви повинні побачити небезпеку). Ви можете заплутатися, тому що все це цифри, але у повсякденному житті ви цього не робите: я особисто сильно важу різницю в 1 і 1 собаці. собака і $ - це типи, ви знаєте, що з ними можна робити.

Ви можете запрограмувати на збірку і зробити те, що хочете, але ви будете спостерігати, наскільки це небезпечно, адже ви можете робити майже те, що хочете, особливо дивні речі. Так, змінювати значення адреси небезпечно, припустимо, у вас є автономний автомобіль, який повинен доставити щось за адресою, вираженою у відстані: 1200 вулиць пам’яті (адреса), і припустимо, що вуличні будинки розділені 100 футами (1221 - недійсна адреса), якщо ви можете маніпулювати адресами, як вам подобається, як цілі числа, ви зможете спробувати доставити о 1223 і впустити пакет посередині бруківки.

Іншим прикладом може бути будинок, адреса будинку, номер запису в адресній книзі цієї адреси. Всі ці три різні поняття, різні типи ...

Існують різні типи. І для цього є вагома причина:

Маючи ...

int a = 5;
int *b = &a;
int **c = &b;

... вираз ...

*b * 5

… Дійсний, тоді як вираз…

*c * 5

не має сенсу.

Велика справа не в тому, як зберігаються покажчики чи покажчики на покажчики, а в тому, на що вони посилаються.

Мова С сильно набрана. Це означає, що для кожної адреси існує тип , який повідомляє компілятору, як інтерпретувати значення за цією адресою.

У вашому прикладі:

int a = 5;
int *b = &a;

Тип ais intі тип bis int *(читається як "вказівник на int"). На вашому прикладі пам’ять міститиме:

..... memory address ...... value ........ type
a ... 0x00000002 .......... 5 ............ int
b ... 0x00000010 .......... 0x00000002 ... int*

Тип НЕ на насправді зберігаються в пам'яті, це просто , що компілятор знає , що, коли ви читаєте aви знайдете int, і коли ви читаєте bви знайдете адресу місця , де ви можете знайти int.

У другому прикладі:

int a = 5;
int *b = &a;
int **c = &b;

Тип cis int **, читається як "вказівник на вказівник на int". Це означає, що для компілятора:

• c є покажчиком;
• читаючи c, ви отримуєте адресу іншого вказівника;
• читаючи той інший покажчик, ви отримуєте адресу int.

Це,

• cє покажчиком ( int **);
• *cтакож є покажчиком ( int *);
• **cє int.

І пам’ять містила б:

..... memory address ...... value ........ type
a ... 0x00000002 .......... 5 ............ int
b ... 0x00000010 .......... 0x00000002 ... int*
c ... 0x00000020 .......... 0x00000010 ... int**

Оскільки "тип" не зберігається разом зі значенням, і вказівник може вказувати на будь-яку адресу пам'яті, спосіб, яким компілятор знає тип значення за адресою, в основному полягає в тому, щоб взяти тип вказівника та видалити крайній правий *.

До речі, це для звичайної 32-розрядної архітектури. Для більшості 64-розрядних архітектур ви будете мати:

..... memory address .............. value ................ type
a ... 0x0000000000000002 .......... 5 .................... int
b ... 0x0000000000000010 .......... 0x0000000000000002 ... int*
c ... 0x0000000000000020 .......... 0x0000000000000010 ... int**

Адреси зараз складають 8 байт, тоді як an intвсе ще становить лише 4 байти. Оскільки компілятор знає тип кожної змінної, він легко впорається з цією різницею і прочитає 8 байт для вказівника та 4 байти для int.

Чому цей тип коду генерує попередження?

int a = 5;
int *b = &a;   
int *c = &b;

&Оператор дає покажчик на об'єкт, тобто &aмає типу , int *щоб призначити (через ініціалізацію) це , bякий має також тип int *є дійсним. &bдає покажчик на об'єкт b, який &bмає тип покажчика int *, я .e., int **.

C говорить у обмеженнях оператора присвоєння (які виконуються для ініціалізації), що (C11, 6.5.16.1p1): "обидва операнди є вказівниками на кваліфіковані або некваліфіковані версії сумісних типів" . Але у визначенні C визначено, що є сумісним типом, int **а що int *не є сумісними типами.

Отже, в int *c = &b;ініціалізації є порушення обмеження, що означає, що компілятор вимагає діагностики.

Одним із обґрунтувань правила тут є відсутність гарантії стандартом, що два різні типи покажчиків мають однаковий розмір (крім void *і типів покажчиків на символи), тобто sizeof (int *)іsizeof (int **) можуть бути різними значеннями.

Це було б тому, що будь-який вказівник T*насправді має тип pointer to a T(або address of a T), де Tвказаний тип. У цьому випадку *може бути прочитаний як pointer to a(n), і Tє вказаним типом.

int     x; // Holds an integer.
           // Is type "int".
           // Not a pointer; T is nonexistent.
int   *px; // Holds the address of an integer.
           // Is type "pointer to an int".
           // T is: int
int **pxx; // Holds the address of a pointer to an integer.
           // Is type "pointer to a pointer to an int".
           // T is: int*

Це використовується для розмежування посилань, коли оператор розмежування бере а T*і повертає значення, тип якого T. Тип повернення можна розглядати як скорочення крайнього лівого "вказівника на a (n)" і як усе, що залишилось.

  *x; // Invalid: x isn't a pointer.
      // Even if a compiler allows it, this is a bad idea.
 *px; // Valid: px is "pointer to int".
      // Return type is: int
      // Truncates leftmost "pointer to" part, and returns an "int".
*pxx; // Valid: pxx is "pointer to pointer to int".
      // Return type is: int*
      // Truncates leftmost "pointer to" part, and returns a "pointer to int".

Зверніть увагу, як для кожної з вищезазначених операцій тип повернення оператора перенаправлення відповідає типу вихідної T*декларації T.

Це значно допомагає як первісним компіляторам, так і програмістам у синтаксичному аналізі типу вказівника: Для компілятора оператор адреса-оператора додає *тип до типу, оператор розмежування видаляє a *із типу, і будь-яке невідповідність є помилкою. Для програміста число *s є прямим показником того, на скільки рівнів непрямості ви маєте справу ( int*завжди вказує на int, float**завжди вказує на float*які, в свою чергу, завжди вказує floatтощо).

Тепер, беручи це до уваги, є дві основні проблеми з використанням лише одного, *незалежно від кількості рівнів опосередкованості:

1. Вказівник набагато складніше для розпізнавання компілятора, оскільки він повинен посилатися на останнє призначення, щоб визначити рівень непрямості та визначити тип повернення належним чином.
2. Вказівник важче зрозуміти програмісту, оскільки легко втратити відстеження того, скільки шарів непрямої дії є.

В обох випадках єдиним способом визначити фактичний тип значення було б повернути його назад, змусивши вас шукати десь ще, щоб знайти його.

void f(int* pi);

int main() {
    int x;
    int *px = &x;
    int *ppx = &px;
    int *pppx = &ppx;

    f(pppx);
}

// Ten million lines later...

void f(int* pi) {
    int i = *pi; // Well, we're boned.
    // To see what's wrong, see main().
}

Це ... є дуже небезпечною проблемою, і її легко вирішити, якщо кількість *s прямо представляє рівень непрямості.