Як пояснити початківцю покажчики С (декларація проти одинарних операторів)?

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

int foo = 1;
int *bar = &foo;
printf("%p\n", (void *)&foo);
printf("%i\n", *bar);

Для абсолютного початківця вихід може бути дивовижним. У другому рядку він / вона щойно оголосив * bar для & foo, але у рядку 4 виявляється * bar насправді foo замість & foo!

Плутанина, можна сказати, випливає з неоднозначності символу *: У другому рядку він використовується для оголошення вказівника. У рядку 4 він використовується як одинарний оператор, який отримує значення, на яке вказує вказівник. Дві різні речі, правда?

Однак це "пояснення" зовсім не допомагає новачку. Він вводить нову концепцію, вказуючи на тонку невідповідність. Це не може бути правильним способом цього навчити.

Отже, як це пояснили Керніган та Річі?

Одинарний оператор * - це оператор опосередкування або перенаправлення; при застосуванні до вказівника він отримує доступ до об'єкта, на який вказує вказівник. […]

Декларація вказівника ip, int *ipпризначена як мнемонічна; це говорить, що вираз *ipє цілим. Синтаксис оголошення для змінної імітує синтаксис виразів, у яких може відображатися змінна .

int *ipслід читати як " *ipповернеться int"? Але чому тоді призначення після декларації не відповідає цій схемі? Що робити, якщо новачок хоче ініціалізувати змінну? int *ip = 1(читайте: *ipповернеться intта intє 1) не буде працювати, як очікувалося. Концептуальна модель просто не здається узгодженою. Я щось тут пропускаю?

Редагувати: Тут спробували узагальнити відповіді .

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

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

Коли вони зрозуміють, що контексти різні, можна продовжити пояснення, що коли *символ знаходиться у оголошенні змінної перед ідентифікатором змінної, це означає «оголосити цю змінну як вказівник». Тоді ви можете пояснити, що при використанні в виразі (як унарний оператор) *символ є "оператором скидання", і це означає "значення за адресою", а не його попереднє значення.

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

Загалом, не можна пояснити, що контексти різні. Якщо студент не розуміє, що контексти різні, він не може зрозуміти, чому *символ може означати різні речі.

Причина, за якою стенограма:

int *bar = &foo;

у вашому прикладі може бути заплутаним те, що його легко неправильно прочитати як рівнозначне:

int *bar;
*bar = &foo;    // error: use of uninitialized pointer bar!

коли це насправді означає:

int *bar;
bar = &foo;

Виписано так, з відокремленою декларацією та призначенням змінної немає такого потенціалу для плутанини, і паралелізм декларації використання, описаний у вашій цитаті K&R, прекрасно працює:

• Перший рядок оголошує змінну bar, таку *barяк an int.

• Другий рядок призначає адресу fooдо bar, роблячи *bar(an int) псевдонім для foo(також an int).

Вводячи початківцям синтаксис вказівника С, може бути корисним спочатку дотримуватися цього стилю відокремлення декларацій вказівника від призначень і лише вводити комбінований короткочасний синтаксис (з відповідними попередженнями про його потенціал для плутанини), коли основні поняття вказівника використовують у C були адекватно інтерналізовані.

Не вистачає декларацій

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

1. int a; a = 42;

int a;
a = 42;

Ми заявляємо про intімені А . Потім ми ініціалізуємо його, надаючи йому значення 42.

2. int a = 42;

Ми оголошуємо і intназиваємо a і надаємо йому значення 42. Це ініціалізовано з 42. Визначення.

3. a = 43;

Коли ми використовуємо змінні, ми кажемо, що ми працюємо над ними. a = 43- це операція призначення. Присвоюємо число 43 змінній a.

Сказавши

int *bar;

ми оголошуємо смугу покажчиком на int. Сказавши

int *bar = &foo;

ми оголошуємо бар і ініціалізуємо його з адресою foo .

Після ініціалізації панелі ми можемо використовувати той самий оператор, зірочку, для доступу та роботи зі значенням foo . Без оператора ми отримуємо доступ та працюємо за адресою, на яку вказує вказівник.

Крім того, я дозволяю малюнку говорити.

Що

Спрощене ВІДПОВІДЬ щодо того, що відбувається. (І ось версія гравця, якщо ви хочете зробити паузу тощо)

2-е твердження int *bar = &foo;можна зобразити в пам'яті як,

   bar           foo
  +-----+      +-----+
  |0x100| ---> |  1  |
  +-----+      +-----+ 
   0x200        0x100

Тепер barпокажчик типу , intщо містить адресу &з foo. Використовуючи одинарний оператор, *ми затримуємося отримати значення, що міститься у «foo», використовуючи покажчик bar.

EDIT : Мій підхід з початківцями полягає в поясненні memory addressзмінної, тобто

Memory Address:Кожна змінна має пов’язану з нею адресу, надану ОС. В int a;, &aадреса змінної a.

Продовжуйте пояснювати основні типи змінних у C,

Types of variables: Змінні можуть містити значення відповідних типів, але не адреси.

int a = 10; float b = 10.8; char ch = 'c'; `a, b, c` are variables. 

Introducing pointers: Як сказано вище, наприклад, змінні

 int a = 10; // a contains value 10
 int b; 
 b = &a;      // ERROR

Можна призначити, b = aале ні b = &a, оскільки змінна bможе містити значення, але не адресу, отже, нам потрібні покажчики .

Pointer or Pointer variables :Якщо змінна містить адресу, вона відома як змінна вказівник. Використовуйте *в декларації, щоб повідомити, що це покажчик.

• Pointer can hold address but not value
• Pointer contains the address of an existing variable.
• Pointer points to an existing variable

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

• Перш ніж показати будь-який код, використовуйте діаграми, ескізи або анімації, щоб проілюструвати, як працюють покажчики.
• Представляючи синтаксис, поясніть дві різні ролі символу зірочки . Багато навчальних посібників відсутні або ухиляються від цієї частини. Виникає плутанина ("Коли ви розбиваєте ініціалізовану декларацію вказівника на декларацію та наступне призначення, ви повинні пам’ятати про видалення *" - comp.lang.c FAQ ) Я сподівався знайти альтернативний підхід, але я думаю, що це шлях.

Ви можете написати int* barзамість того, int *barщоб виділити різницю. Це означає, що ви не будете дотримуватися підходу «Міміка використання декларації використання K&R», але підходу Stroustrup C ++ :

Ми не оголошуємо *barцілим числом. Ми оголошуємо barсебе int*. Якщо ми хочемо ініціалізувати новостворену змінну в тому ж рядку, зрозуміло, що ми маємо справу bar, а не *bar.int* bar = &foo;

Недоліки:

• Ви повинні попередити свого учня про проблему декларування кількох покажчиків ( int* foo, barпроти int *foo, *bar).
• Ви повинні підготувати їх до світу рани . Багато програмістів хочуть бачити зірочку поруч із назвою змінної, і вони знадобляться, щоб виправдати свій стиль. І багато посібників зі стилів чітко застосовують цю позначення (стиль кодування ядра Linux, керівництво стилем NASA C тощо).

Редагувати: інший підхід , який було запропоновано, полягає в тому, щоб пройти «імітаційний» K&R шлях, але без синтаксису «скорочення» (див. Тут ). Як тільки ви пропустите виконання декларації та завдання в одному рядку , все буде виглядати набагато узгодженіше.

Однак рано чи пізно студенту доведеться мати справу з покажчиками як аргументами функції. І вказівники як типи повернення. І покажчики на функції. Вам доведеться пояснити різницю між int *func();і int (*func)();. Я думаю, рано чи пізно все розвалиться. І, можливо, швидше краще, ніж пізніше.

Є причина, чому стиль K&R надає перевагу int *pстилю Stroustrup int* p; обидві є дійсними (і означають те саме) в кожній мові, але як сказав Stroustrup:

Вибір між "int * p;" та "int * p;" йдеться не про правильне і неправильне, а про стиль та акценти. C підкреслені вирази; декларації часто вважалися мало чим необхідним злом. C ++, з іншого боку, робить великий акцент на типи.

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

Тому деяким людям буде легше почати з думки, що int*річ - це інша річ, ніж intі піти звідти.

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

Чи ні. Якби був один спосіб, коли всі вперше зрозуміли цю концепцію, у вас не виникло б проблем в першу чергу, і найкращий спосіб пояснити її одній людині не обов'язково буде найкращим способом пояснити її іншій.

tl; dr:

З: Як пояснити початківцю покажчики С (декларація проти одинарних операторів)?

Відповідь: ні. Поясніть початківцям покажчики та покажіть їм, як представити їх поняття вказівника у синтаксисі C після.

Нещодавно я мав задоволення пояснювати покажчики початківцю програмування на С і натрапляв на наступні труднощі.

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

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

• Поясніть їх діаграмами вікна та стрілки. Ви можете зробити це без шістнадцяткових адрес, якщо вони не стосуються, просто покажіть стрілки, що вказують або на інше поле, або на якийсь символ нуля.

• Поясніть за допомогою псевдокоду: просто запишіть адресу foo та значення, що зберігаються в барі .

• Потім, коли ваш новачок розуміє, що таке покажчики, і чому, і як ними користуватися; потім покажіть відображення на синтаксисі C.

Я підозрюю, що причина K&R в тексті не дає концептуальної моделі в тому, що вони вже розуміли покажчики , і, ймовірно, припускав, що це робив і кожен інший компетентний програміст. Мнемоніка - це лише нагадування про відображення від добре зрозумілого поняття до синтаксису.

Це питання дещо заплутане, коли починаєш вивчати С.

Ось основні принципи, які можуть допомогти вам почати:

1. У С є лише кілька основних типів:

   • char: ціле значення з розміром 1 байт.

   • short: ціле значення з розміром 2 байти.

   • long: ціле значення розміром 4 байти.

   • long long: ціле значення розміром 8 байт.

   • float: неціле значення з розміром 4 байти.

   • double: неціле значення з розміром 8 байт.

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

   Цілі типи short, longа за long longними зазвичай дотримуються int.

   Однак це не обов'язково, і ви можете використовувати їх без цього int.

   Крім того, ви можете просто констатувати int, але це може трактуватися різними компіляторами по-різному.

   Отже, підсумовуючи це:

   • shortте саме, short intале не обов'язково те саме, що int.

   • longте саме, long intале не обов'язково те саме, що int.

   • long longте саме, long long intале не обов'язково те саме, що int.

   • У даному компіляторі intє short intабо long intабо long long int.

2. Якщо ви оголошуєте змінну якогось типу, то ви також можете оголосити іншу змінну, що вказує на неї.

   Наприклад:

   int a;

   int* b = &a;

   Отже, по суті, для кожного базового типу ми також маємо відповідний тип вказівника.

   Наприклад: shortі short*.

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

   • Ви можете розглядати bяк змінну типу int*.

   • Ви можете розглядати *bяк змінну типу int.

   Отже, деякі декларують int* b, тоді як інші декларують int *b.

   Але справа в тому, що ці дві декларації однакові (пробіли безглузді).

   Ви можете використовувати або bяк вказівник на ціле число, або *bяк фактичне вказане ціле значення.

   Ви можете отримати (прочитати) загострене значення: int c = *b.

   І ви можете встановити (запис) загострене значення: *b = 5.

3. Вказівник може вказувати на будь-яку адресу пам'яті, а не лише на адресу певної змінної, яку ви раніше оголосили. Однак ви повинні бути обережними при використанні покажчиків, щоб отримати або встановити значення, розташоване на вказаній адресі пам'яті.

   Наприклад:

   int* a = (int*)0x8000000;

   Тут ми маємо змінну, яка aвказує на адресу пам'яті 0x8000000.

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

   Ви можете сміливо змінювати значення a, але вам слід дуже обережно змінювати значення *a.

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

Можливо, переходити через нього трохи більше, це полегшує:

#include <stdio.h>

int main()
{
    int foo = 1;
    int *bar = &foo;
    printf("%i\n", foo);
    printf("%p\n", &foo);
    printf("%p\n", (void *)&foo);
    printf("%p\n", &bar);
    printf("%p\n", bar);
    printf("%i\n", *bar);
    return 0;
}

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

На моєму досвіді, це переходить через те, "чому це друкує саме так?" горб, а потім одразу показуючи, чому це корисно в параметрах функцій при ручному ігранні (як прелюдія до деяких основних матеріалів K&R, таких як обробка рядків / обробка масивів), що робить урок не просто сенсом, а стирком.

Наступний крок - змусити їх пояснити вам, як це i[0]стосується &i. Якщо вони зможуть це зробити, вони цього не забудуть, і ви можете почати говорити про структури, навіть трохи раніше часу, просто так воно зануриться.

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

Тип виразу *bar є int; таким чином, тип змінної (і виразу) barє int *. Оскільки змінна має тип вказівника, її ініціалізатор також повинен мати тип вказівника.

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

Я б краще прочитав це як перше, що *стосується intбільш ніж bar.

int  foo = 1;           // foo is an integer (int) with the value 1
int* bar = &foo;        // bar is a pointer on an integer (int*). it points on foo. 
                        // bar value is foo address
                        // *bar value is foo value = 1

printf("%p\n", &foo);   // print the address of foo
printf("%p\n", bar);    // print the address of foo
printf("%i\n", foo);    // print foo value
printf("%i\n", *bar);   // print foo value

int *bar = &foo;

Question 1: Що таке bar?

Ans: Це змінна вказівник (на тип int). Вказівник повинен вказувати на деяке дійсне місце в пам'яті, а пізніше його слід відмінити (* бар), використовуючи одинарний оператор *, щоб прочитати значення, збережене в цьому місці.

Question 2: Що таке &foo?

Ans: foo - це змінна тип. intКотрий зберігається в якомусь дійсному місці пам'яті, і це місце ми отримуємо від оператора, &тож тепер у нас є дійсне місце в пам'яті &foo.

Таким чином, обидва разом, тобто те, що потрібен покажчик, було дійсним місцем пам'яті, і це отримує &fooтак, щоб ініціалізація була хорошою.

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

Ви повинні вказати на початківця, що * має різний зміст у декларації та виразі. Як відомо, * у виразі є одинарним оператором, а * У декларації - це не оператор, а лише такий синтаксис, який поєднується з типом, щоб повідомити компілятору, що це тип вказівника. краще сказати початківцю, "* має інше значення. Для розуміння значення * ви повинні знайти, де використовується *

Думаю, чорт у космосі.

Я б написав (не тільки для початківця, але й для себе): int * bar = & foo; замість int * bar = & foo;

це повинно виявити, який взаємозв'язок між синтаксисом і семантикою

Вже зазначалося, що * має декілька ролей.

Є ще одна проста ідея, яка може допомогти новачку зрозуміти речі:

Подумайте, що "=" також має кілька ролей.

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

Коли ви бачите:

int *bar = &foo;

Подумайте, що це майже рівнозначно:

int *bar(&foo);

Дужки мають перевагу над зірочкою, тому "& foo" набагато легше інтуїтивно віднести до "бар", а не "* бар".

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

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

int x;

оголошує x як int: вираз 'x' буде мати тип int. Загалом, щоб зрозуміти, як записати тип нової змінної, напишіть вираз із залученням цієї змінної, яка оцінює базовий тип, а потім поставте основний тип зліва та вираз праворуч.

Таким чином, декларації

int *p;
int a[3];

констатуйте, що p - вказівник на int, оскільки '* p' має тип int, і що a - це масив ints, оскільки тип [3] (ігноруючи конкретне значення індексу, яке карається розміром масиву) має тип int.

(Далі описано, як поширити це розуміння на функціонування покажчиків тощо)

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

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

template<typename T>
using ptr = T*;

Потім це можна використовувати як

ptr<int> bar = &foo;

Після цього порівняйте нормальний синтаксис / C із цим підходом лише для C ++. Це також корисно для пояснення показників const.

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

У декларації

int *bar = &foo;  

*символ НЕ оператор разименованія . Натомість це допомагає вказати тип barінформування компілятора, який barє вказівником наint . З іншого боку, коли він з'являється у висловлюванні, *символ (коли використовується як одинарний оператор ) виконує непряме. Тому заява

*bar = &foo;

було б неправильно, оскільки воно призначає адресу fooоб'єкта, на який barвказує, а не на barсебе.

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

"Звичайно, це створює різні проблеми з неінтуїтивними матеріалами, такими як int * a, b."

Тут ви повинні використовувати, розуміти і пояснювати логіку компілятора, а не людську логіку (я знаю, ви людина, але тут ви повинні імітувати комп'ютер ...).

Коли пишеш

int *bar = &foo;

групи компіляторів, які як

{ int * } bar = &foo;

Тобто: тут нова змінна, її назва bar, її тип - вказівник на int, а її початкове значення - &foo.

І потрібно додати: =вищезазначене позначає ініціалізацію, а не афектацію, тоді як у наступних виразах *bar = 2;це є облудою

Редагувати за коментарем:

Остерігайтеся: у випадку багаторазового оголошення декларація *пов'язана лише з такою змінною:

int *bar = &foo, b = 2;

bar - вказівник на int, ініціалізований адресою foo, b - int, ініціалізований на 2, а в

int *bar=&foo, **p = &bar;

bar у нерухомому покажчику на int, а p - вказівник на покажчик на int, ініціалізований на адресу або рядок.

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

"char * pstr" схоже так

"char str [80]"

Але, важливі речі, покажчик трактується як просто ціле число в нижньому рівні компілятора.

Розглянемо приклади:

#include <stdio.h>
#include <stdlib.h>

int main(int argc, char **argv, char **env)
{
    char str[] = "This is Pointer examples!"; // if we assume str[] is located in 0x80001000 address

    char *pstr0 = str;   // or this will be using with
    // or
    char *pstr1 = &str[0];

    unsigned int straddr = (unsigned int)pstr0;

    printf("Pointer examples: pstr0 = %08x\n", pstr0);
    printf("Pointer examples: &str[0] = %08x\n", &str[0]);
    printf("Pointer examples: str = %08x\n", str);
    printf("Pointer examples: straddr = %08x\n", straddr);
    printf("Pointer examples: str[0] = %c\n", str[0]);

    return 0;
}

Результатам сподобається це 0x2a6b7ed0 - адреса str []

~/work/test_c_code$ ./testptr
Pointer examples: pstr0 = 2a6b7ed0
Pointer examples: &str[0] = 2a6b7ed0
Pointer examples: str = 2a6b7ed0
Pointer examples: straddr = 2a6b7ed0
Pointer examples: str[0] = T

Отже, майте на увазі, що вказівник - це якась ціла кількість. представляючи Адреса.

Я б пояснив, що ints - це об'єкти, як floats і т. Д. Покажчик - це тип об'єкта, значення якого представляє адресу в пам'яті (отже, чому вказівник за замовчуванням NULL).

При першому оголошенні вказівника ви використовуєте синтаксис типу-pointer-name. Він читається як "цілочисельний покажчик, названий ім'ям, який може вказувати на адресу будь-якого цілого об'єкта". Цей синтаксис ми використовуємо лише під час декларування, подібно до того, як ми оголошуємо int як 'int num1', але використовуємо 'num1' лише тоді, коли хочемо використовувати цю змінну, а не 'int num1'.

int x = 5; // цілий об'єкт зі значенням 5

int * ptr; // ціле число зі значенням NULL за замовчуванням

Для вказівки на адресу об'єкта ми використовуємо символ "&", який можна прочитати як "адресу".

ptr = & x; // тепер значення - це адреса 'x'

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

std :: cout << * ptr; // роздрукувати значення за адресою

Ви можете коротко пояснити, що " " - це "оператор", який повертає різні результати з різними типами об'єктів. При використанні з покажчиком оператор " " більше не означає "помножений на".

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

Вказівник - це лише змінна, яка використовується для зберігання адрес.

Пам'ять у комп'ютері складається з байтів (Байт складається з 8 біт), розташованих послідовно. Кожен байт має пов'язане з ним число так само, як індекс чи індекс у масиві, який називається адресою байта. Адреса байта починається від 0 до одного менше, ніж розмір пам'яті. Наприклад, в 64 Мб оперативної пам’яті є 64 * 2 ^ 20 = 67108864 байт. Тому адреса цих байтів починатиметься від 0 до 67108863.

Давайте подивимося, що станеться при оголошенні змінної.

int позначки;

Як ми знаємо, int займає 4 байти даних (якщо використовувати 32-розрядний компілятор), тож компілятор резервує 4 послідовних байти з пам'яті для зберігання цілого числа. Адреса першого байту з 4 виділених байтів відома як адреса знаків змінної. Скажімо, що адреса чотирьох послідовних байтів - 5004, 5005, 5006 і 5007, тоді адреса змінних знаків буде 5004.

Декларування змінних вказівника

Як уже було сказано, покажчик - це змінна, яка зберігає адресу пам'яті. Як і будь-які інші змінні, вам потрібно спочатку оголосити змінну вказівника, перш ніж використовувати її. Ось як можна оголосити змінну вказівника.

Синтаксис: data_type *pointer_name;

data_type - тип вказівника (також відомий як базовий тип вказівника). pointer_name - це ім'я змінної, яка може бути будь-яким дійсним ідентифікатором C.

Візьмемо кілька прикладів:

int *ip;

float *fp;

int * ip означає, що ip - змінна вказівник, здатна вказувати на змінні типу int. Іншими словами, вказівник змінної ip може зберігати адресу змінних типу int. Аналогічно, вказівна змінна fp може зберігати лише адресу змінної float типу. Тип змінної (також відомий як базовий тип) ip - вказівник на int, а тип fp - вказівник на плавання. Змінна вказівника типу вказівника на int може бути символічно представлена ​​як (int *). Аналогічно, змінну вказівника типу вказівника на плавати можна представити у вигляді (float *)

Після оголошення змінної вказівника наступним кроком є ​​призначення нею дійсної адреси пам'яті. Ніколи не слід використовувати змінну вказівника, не присвоюючи їй якусь дійсну адресу пам'яті, тому що відразу після оголошення вона містить значення сміття і може вказувати на будь-яке місце в пам'яті. Використання непризначеного покажчика може дати непередбачуваний результат. Це навіть може спричинити збій програми.

int *ip, i = 10;
float *fp, f = 12.2;

ip = &i;
fp = &f;

Джерело: thecguru - це найпростіше, але детальне пояснення, яке я коли-небудь знаходив.