Что такое указатель в си: Указатели (C++) | Microsoft Learn

Указатель C++ на указатель (двойной указатель)

В C++ указатель — это переменная, которая используется для хранения адресов памяти других переменных. Это переменная, которая указывает на тип данных (например, int или string) того же типа и создается с помощью оператора *.

Синтаксис указателя в C++:

data_type_of_pointer *name_of_variable = & normal_variable;

Содержание

1. Что такое указатель на указатель или двойной указатель в C++?
2. Как объявить указатель на указатель в C++?
3. Каков будет размер указателя на указатель в С++?

Что такое указатель на указатель или двойной указатель в C++?

Теперь мы уже знаем, что указатель хранит адрес памяти других переменных. Итак, когда мы определяем указатель на указатель, первый указатель используется для хранения адреса переменных, а второй указатель хранит адрес первого указателя. Именно по этой причине он известен как двойной указатель или указатель на указатель.

На приведенной ниже диаграмме объясняется концепция двойных указателей :

На приведенной выше диаграмме показано представление памяти указателя на указатель или двойного указателя, мы можем легко понять, что адрес переменной (т. е. адрес 1) хранится в указателе 1, а адрес указателя 1 (т. е. адрес 2) хранится в указателе 2. Это известно как двойные указатели или указатель на указатель.

Как объявить указатель на указатель в C++?

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

Синтаксис указателя на указатель (двойной указатель) в С++:

data_type_of_pointer **name_of_variable = & normal_pointer_variable;

Пример:

int val = 169;

int *ptr = &val; // storing address of val to pointer ptr.

int **double_ptr = &ptr; // pointer to a pointer declared which is pointing to an integer.

На приведенной ниже диаграмме объясняется концепция двойных указателей:

На приведенной выше диаграмме показано представление в памяти указателя на указатель. Первый указатель ptr1 хранит адрес переменной, а второй указатель ptr2 хранит адрес первого указателя.

Ниже приведена программа C++ для реализации Pointer to Pointer :

С++

#include <bits/stdc++.h>

usingnamespacestd;

 

intmain()

{

  intvariable = 169;

   

  

  

  int* pointer1;

 

  

  

  int** pointer2;

 

  

  

  pointer1 = &variable;

 

  

  

  pointer2 = &pointer1;

 

  

  

  

  cout << "Value of variable :- "<< 

           variable << "\n";

  cout << "Value of variable using single pointer :- "<< 

           *pointer1 << "\n";

  cout << "Value of variable using double pointer :- "<< 

           **pointer2 << "\n";

  return0;

}

Выход

Value of variable :- 169
Value of variable using single pointer :- 169
Value of variable using double pointer :- 169

Каков будет размер указателя на указатель в С++?

В языке программирования C++ двойной указатель ведет себя аналогично обычному указателю. Таким образом, размер переменной двойного указателя и размер переменной обычного указателя всегда равны.

Ниже приведена программа на C++ для проверки размера двойного указателя:

С++

#include <bits/stdc++.h>

usingnamespacestd;

 

intmain()

{

  intval = 169;

  int

* ptr = &val;

  int** double_ptr = &ptr;

 

  cout << " Size of normal Pointer: "<< 

            sizeof(ptr) << "\n";

  cout << " Size of double Pointer: "<< 

            sizeof(double_ptr) << "\n";

  return0;

}

Выход

 Size of normal Pointer: 8
 Size of double Pointer: 8

Примечание. Вывод приведенного выше кода также зависит от типа используемой машины. Размер указателя не фиксирован в языке программирования C++ и полностью зависит от других факторов, таких как архитектура ЦП и используемая ОС. Обычно для 64-битной операционной системы назначается размер памяти 8 байт, а для 32-битной операционной системы размер памяти 4 байта.

2.3.2. Указатели . Язык программирования C++. Пятое издание

Указатель (pointer) — это составной тип, переменная которого указывает на объект другого типа. Подобно ссылкам, указатели используются для косвенного доступа к другим объектам. В отличие от ссылок, указатель — это настоящий объект. Указатели могут быть присвоены и скопированы; один указатель за время своего существования может указывать на несколько разных объектов. В отличие от ссылки, указатель можно не инициализировать в момент определения. Подобно объектам других встроенных типов, значение неинициализированного указателя, определенного в области видимости блока, неопределенно.

Указатели зачастую трудно понять. При отладке проблемы, связанные с ошибками в указателях, способны запутать даже опытных программистов.

Тип указателя определяется оператором в форме *d, где d — определяемое имя. Символ * следует повторять для каждой переменной указателя.

int *ip1, *ip2;  // ip1 и ip2 — указатели на тип int

double dp, *dp2; // dp2 — указатель на тип double;

                 // dp — переменная типа double

Получение адреса объекта

Указатель содержит адрес другого объекта. Для получения адреса объекта используется

оператор обращения к адресу (address-of operator), или оператор &.

int ival = 42;

int *p = &ival; // p содержит адрес переменной ival;

                // p — указатель на переменную ival

Второй оператор определяет p как указатель на тип int и инициализирует его адресом объекта ival типа int. Поскольку ссылки не объекты, у них нет адресов, а следовательно, невозможно определить указатель на ссылку.

За двумя исключениями, рассматриваемыми в разделах 2.4.2 и 15.2.3, типы указателя и объекта, на который он указывает, должны совпадать.

double dval;

double *pd = &dval; // ok: инициализатор — адрес объекта типа double

double *pd2 = pd;   // ok: инициализатор — указатель на тип double

int *pi = pd;       // ошибка: типы pi и pd отличаются

pi = &dval;         // ошибка: присвоение адреса типа double

                    // указателю на тип int

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

Значение указателя

Хранимое в указателе значение (т.е. адрес) может находиться в одном из четырех состояний.

1. Оно может указывать на объект.

2. Оно может указывать на область непосредственно за концом объекта

3. Это может быть нулевое значение, означающее, что данный указатель не связан ни с одним объектом.

4. Оно может быть недопустимо. Любое иное значение, кроме приведенного выше, является недопустимым.

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

Хотя указатели в случаях 2 и 3 допустимы, действия с ними ограничены.

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

Использование указателя для доступа к объекту

Когда указатель указывает на объект, для доступа к этому объекту можно использовать оператор обращения к значению (dereference operator), или оператор *.

int ival = 42;

int *p = &ival; // p содержит адрес ival; p — указатель на ival

cout << *p;     // * возвращает объект, на который указывает p;

                // выводит 42

Обращение к значению указателя возвращает объект, на который указывает указатель. Присвоив значение результату оператора обращения к значению, можно присвоить его самому объекту.

*p = 0;     // * возвращает объект; присвоение нового значения

            // ival через указатель p

cout << *p; // выводит 0

При присвоении значения *p оно присваивается объекту, на который указывает указатель p.

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

Ключевая концепция. У некоторых символов есть несколько значений

Некоторые символы, такие как & и *, используются и как оператор в выражении, и как часть объявления. Контекст, в котором используется символ, определяет то, что он означает.

int i = 42;

int &r = i;   // & следует за типом в части объявления; r — ссылка

int *p;       // * следует за типом в части объявления; p — указатель

p = &i;       // & используется в выражении как оператор

              // обращения к адресу

*p = i;       // * используется в выражении как оператор

              // обращения к значению

int &r2 = *p; // & в части объявления; * — оператор обращения к значению

В объявлениях символы & и * используются для формирования составных типов. В выражениях эти же символы используются для обозначения оператора. Поскольку тот же символ используется в совершенно ином смысле, возможно, стоит игнорировать внешнее сходство и считать их как будто различными символами.

Нулевые указатели

Нулевой указатель (null pointer) не указывает ни на какой объект. Код может проверить, не является ли указатель нулевым, прежде чем пытаться использовать его. Есть несколько способов получить нулевой указатель.

int *p1 = nullptr; // эквивалентно int *p1 = 0;

int *p2 = 0;       // непосредственно инициализирует p2 литеральной

                   // константой 0, необходимо #include cstdlib

int *p3 = NULL;    // эквивалентно int *p3 = 0;

Проще всего инициализировать указатель, используя литерал nullptr, который был введен новым стандартом. Литерал nullptr имеет специальный тип, который может быть преобразован (см. раздел 2.1.2) в любой другой ссылочный тип. В качестве альтернативы можно инициализировать указатель литералом 0, как это сделано в определении указателя p2.

Программисты со стажем иногда используют переменную препроцессора (preprocessor variable) NULL, которую заголовок cstdlib определяет как 0.

Немного подробней препроцессор рассматривается в разделе 2.6.3, а пока достаточно знать, что препроцессор (preprocessor) — это программа, которая выполняется перед компилятором. Переменные препроцессора используются препроцессором, они не являются частью пространства имен std, поэтому их указывают непосредственно, без префикса std::.

При использовании переменной препроцессора последний автоматически заменяет такую переменную ее значением. Следовательно, инициализация указателя переменной NULL эквивалентна его инициализации значением 0. Сейчас программы С++ вообще должны избегать применения переменной NULL и использовать вместо нее литерал nullptr.

Нельзя присваивать переменную типа int указателю, даже если ее значением является 0.

int zero = 0;

pi = zero; // ошибка: нельзя присвоить переменную типа int указателю

Совет. Инициализируйте все указатели

Неинициализированные указатели — обычный источник ошибок времени выполнения.

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

У большинства компиляторов при использовании неинициализированного указателя биты в памяти, где он располагается, используются как адрес. Использование неинициализированного указателя — это попытка доступа к несуществующему объекту в произвольной области памяти. Нет никакого способа отличить допустимый адрес от недопустимого, состоящего из случайных битов, находящихся в той области памяти, которая была зарезервирована для указателя.

Авторы рекомендуют инициализировать все переменные, а особенно указатели. Если это возможно, определяйте указатель только после определения объекта, на который он должен указывать. Если связываемого с указателем объекта еще нет, то инициализируйте указатель значением nullptr или 0. Так код программы может узнать, что указатель не указывает на объект.

Присвоение и указатели

И указатели, и ссылки предоставляют косвенный доступ к другим объектам. Однако есть важные различия в способе, которым они это делают. Самое важное то, что ссылка — это не объект. После того как ссылка определена, нет никакого способа заставить ее ссылаться на другой объект. При использовании ссылки всегда используется объект, с которым она была связана первоначально.

Между указателем и содержащимся в нем адресом нет такой связи. Подобно любой другой (нессылочной) переменной, при присвоении указателя для него устанавливается новое значение. Присвоение заставляет указатель указывать на другой объект.

int i = 42;

int *pi = 0;   // указатель pi инициализирован, но не адресом объекта

int *pi2 = &i; // указатель pi2 инициализирован адресом объекта i

int *pi3;      // если pi3 определен в блоке, pi3 не инициализирован

pi3 = pi2;     // pi3 и pi2 указывают на тот же объект, т.е. на i

pi2 = 0;       // теперь pi2 не содержит адреса никакого объекта

Сначала может быть трудно понять, изменяет ли присвоение указатель или сам объект, на который он указывает. Важно не забывать, что присвоение изменяет свой левый операнд. Следующий код присваивает новое значение переменной pi, что изменяет адрес, который она хранит:

pi = &ival; // значение pi изменено; теперь pi указывает на ival

С другой стороны, следующий код (использующий *pi, т.е. значение, на которое указывает указатель pi) изменяет значение объекта:

*pi = 0; // значение ival изменено; pi неизменен

Другие операции с указателями

Пока значение указателя допустимо, его можно использовать в условии. Аналогично использованию арифметических значений (раздел 2.1.2), если указатель содержит значение 0, то условие считается ложным.

int ival = 1024;

int *pi = 0;      // pi допустим, нулевой указатель

int *pi2 = &ival; // pi2 допустим, содержит адрес ival

if (pi)           // pi содержит значение 0, условие считается ложным

 // . ..

if (pi2)          // pi2 указывает на ival, значит, содержит не 0;

                  // условие считается истинным

 // …

Любой отличный от нулевого указатель рассматривается как значение true. Два допустимых указателя того же типа можно сравнить, используя операторы равенства (==) и неравенства (!=). Результат этих операторов имеет тип bool. Два указателя равны, если они содержат одинаковый адрес, и неравны в противном случае. Два указателя содержат одинаковый адрес (т.е. равны), если они оба нулевые, если они указывают на тот же объект или на область непосредственно за концом того же объекта. Обратите внимание, что указатель на объект и указатель на область за концом другого объекта вполне могут содержать одинаковый адрес. Такие указатели равны.

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

Дополнительные операции с указателями будут описаны в разделе 3.5.3.

Тип void* является специальным типом указателя, способного содержать адрес любого объекта. Подобно любому другому указателю, указатель void* содержит адрес, но тип объекта по этому адресу неизвестен.

double obj = 3.14, *pd = &obj;

// ok: void* может содержать адрес любого типа данных

void *pv = &obj; // obj может быть объектом любого типа

pv = pd;         // pv может содержать указатель на любой тип

С указателем void* допустимо немного действий: его можно сравнить с другим указателем, можно передать его функции или возвратить из нее либо присвоить другому указателю типа void*. Его нельзя использовать для работы с объектом, адрес которого он содержит, поскольку неизвестен тип объекта, неизвестны и операции, которые можно с ним выполнять.

Как правило, указатель void* используют для работы с памятью как с областью памяти, а не для доступа к объекту, хранящемуся в этой области. Использование указателей void* рассматривается в разделе 19.1.1, а в разделе 4.11.3 продемонстрировано, как можно получить адрес, хранящийся в указателе void*.

Упражнения раздела 2.3.2

Упражнение 2.18. Напишите код, изменяющий значение указателя. Напишите код для изменения значения, на которое указывает указатель.

Упражнение 2.19. Объясните основные отличия между указателями и ссылками.

Упражнение 2.20. Что делает следующая программа?

int i = 42;

int *p1 = &i;

*p1 = *p1 * *p1;

Упражнение 2. 21. Объясните каждое из следующих определений. Укажите, все ли они корректны и почему.

int i = 0;

(a) double* dp = &i; (b) int *ip = i; (c) int *p = &i;

Упражнение 2.22. С учетом того, что p является указателем на тип int, объясните следующий код:

if (p) // …

if (*p) // …

Упражнение 2.23. Есть указатель p, можно ли определить, указывает ли он на допустимый объект? Если да, то как? Если нет, то почему?

Упражнение 2.24. Почему инициализация указателя p допустима, а указателя lp нет?

int i = 42; void *p = &i; long *lp = &i;

объявлений указателей | Microsoft Узнайте

Редактировать

Твиттер LinkedIn Фейсбук Электронная почта

• Статья
• 25. 01.2023
• 3 минуты на чтение

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

Syntax

declarator :
  pointer _opt direct-declarator

direct-declarator :
  identifier
  ( декларатор )
  прямой декларатор [
константное выражение0027 _opt ]
  direct-declarator ( parameter-type-list )
  direct-declarator ( идентификатор-списка _OPT )

Pointer :
* 0027 opt
  * type-qualifier-list opt pointer

type-qualifier-list :
  type-qualifier
  type-qualifier list type-qualifier

type-specifier задает тип объекта, который может быть любым базовым, структурным или типом объединения. Переменные-указатели также могут указывать на функции, массивы и другие указатели. (Информацию об объявлении и интерпретации более сложных типов указателей см. в разделе Интерпретация более сложных деклараторов.)

Сделав спецификатор типа недействительным , вы можете отложить спецификацию типа, на который указывает указатель. Такой элемент называется "указатель на void " и записывается как void * . Переменная, объявленная как указатель на void , может использоваться для указания на объект любого типа. Однако для выполнения большинства операций с указателем или объектом, на который он указывает, тип, на который он указывает, должен быть явно указан для каждой операции. (переменные типа char * и тип void * совместимы по присваиванию без приведения типа.) Такое преобразование можно выполнить с помощью приведения типа. Дополнительные сведения см. в разделе Преобразования типов.

Квалификатор типа может быть либо const , либо volatile , либо обоими. Эти ключевые слова указывают, соответственно, что указатель не может быть изменен самой программой ( const ) или что указатель может быть законно изменен каким-либо процессом, находящимся вне контроля программы ( летучий ). Дополнительные сведения о const и volatile см. в разделе квалификаторы типов.

Декларатор называет переменную и может включать модификатор типа. Например, если декларатор представляет массив, тип указателя изменяется, чтобы быть указателем на массив.

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

Примеры

Следующие примеры иллюстрируют объявления указателей.

 символов *сообщение; /* Объявляет переменную-указатель с именем message */
 

Указатель message указывает на переменную с типом char .

 int *указатели[10]; /* Объявляет массив указателей */
 

Массив указателей состоит из 10 элементов; каждый элемент является указателем на переменную типа int .

 интервал (*указатель)[10]; /* Объявляет указатель на массив из 10 элементов */
 

Переменная указатель указывает на массив из 10 элементов. Каждый элемент в этом массиве имеет тип int .

 целая константа *x; /* Объявляет переменную-указатель x,
                      к постоянному значению */
 

Указатель x можно изменить, чтобы он указывал на другое значение int , но значение, на которое он указывает, изменить нельзя.

 const int some_object = 5 ;
интервал другой_объект = 37;
int *const y = &fixed_object;
int volatile *const z = &some_object;
int *const volatile w = &some_object;
 

Переменная y в этих объявлениях объявляется как постоянный указатель на значение int . Значение, на которое он указывает, может быть изменено, но сам указатель всегда должен указывать на одно и то же место: адрес fixed_object . Точно так же z — это константный указатель, но также объявлено, что он указывает на 9.0052 int , значение которого не может быть изменено программой. Спецификатор volatile указывает, что хотя значение const int , на которое указывает z , не может быть изменено программой, оно может быть законно изменено процессом, работающим одновременно с программой. Объявление w указывает, что программа не может изменить значение, на которое указывает указатель, и что программа не может изменить указатель.

 список структур *следующий, *предыдущий; /* Использует тег для списка */
 

В этом примере объявляются две переменные-указатели ( следующий и предыдущий ), которые указывают на тип структуры list . Это объявление может появиться перед определением типа структуры list (см. следующий пример), если определение типа list имеет ту же видимость, что и объявление.

 список структур
{
    символ *токен;
    счет;
    список структур *next;
} линия;
 

Переменная строка имеет тип структуры с именем список . Тип структуры list состоит из трех членов: первый член — это указатель на значение char , второй — значение int , а третий — указатель на другую структуру list .

 идентификатор структуры
{
    беззнаковое целое число id_no;
    имя структуры *pname;
} записывать;
 

Переменная запись имеет тип структуры id . pname объявлен как указатель на другой тип структуры с именем имя . Это объявление может появиться до того, как будет определено имя типа .

См. также

Деклараторы и объявления переменных

Обратная связь

Просмотреть все отзывы о странице

Основы работы с указателями

Этот документ знакомит с основами работы указателей в нескольких языках программирования — C, C++, Java и Pascal. Этот документ является сопутствующим документом для Pointer Fun с цифровым видео Binky или его можно использовать отдельно.

Это документ 106 в Стэнфордской образовательной библиотеке CS. Этот и другие бесплатные материалы доступны на сайте cslibrary. stanford.edu. Некоторые документы, связанные с этим, включают...

Раздел 1. Правила указателя

Одна из приятных особенностей указателей заключается в том, что правила, управляющие их работой, довольно просты. Правила можно накладывать друг на друга для получения сложных результатов, но отдельные правила остаются простыми.

1) Указатели и пуанты

Указатель хранит ссылку на что-то. К сожалению, не существует фиксированного термина для того, на что указывает указатель, и в разных языках программирования существует большое разнообразие вещей, на которые указывают указатели. Мы используем термин pointee для того, на что указывает указатель, и придерживаемся основных свойств отношения указатель/указатель, которые истинны для всех языков. Термин "ссылка" означает почти то же самое, что и "указатель" - "ссылка" подразумевает обсуждение на более высоком уровне, в то время как "указатель" подразумевает традиционную скомпилированную языковую реализацию указателей в виде адресов. Для основных правил указателя/указателя, описанных здесь, термины фактически эквивалентны.

На приведенном выше рисунке показан указатель с именем x , указывающий на указатель, в котором хранится значение 42. Указатель обычно изображается в виде прямоугольника, а ссылка, которую он хранит, изображается в виде стрелки, начинающейся в прямоугольнике и ведущей к его указателю.

Выделение указателя и выделение указателя, на который он указывает, — это два отдельных шага. Вы можете думать о структуре указателя/указателя как о работе на двух уровнях. Оба уровня должны быть настроены, чтобы все работало. Наиболее распространенная ошибка заключается в том, что вы концентрируетесь на написании кода, управляющего уровнем указателя, но забываете настроить уровень указателя. Иногда операции с указателями, которые не касаются указателей, называются «поверхностными», а операции над указателями — «глубокими».

2) Разыменование

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

Операция разыменования указателя работает только в том случае, если указатель имеет указатель — указатель должен быть выделен, а указатель должен указывать на него. Самая распространенная ошибка в коде указателя — забывание настроить указатель. Наиболее распространенный сбой во время выполнения из-за этой ошибки в коде — сбой операции разыменования. В Java неправильное разыменование будет вежливо помечено системой выполнения. В скомпилированных языках, таких как C, C++ и Pascal, неправильное разыменование иногда приводит к сбою, а иногда и к повреждению памяти каким-то незаметным случайным образом. По этой причине ошибки указателей в скомпилированных языках трудно отследить.

3) Назначение указателя

Назначение указателя между двумя указателями заставляет их указывать на одного и того же указателя. Итак, присваивание y = x; заставляет y указывать на тот же указатель, что и x . Назначение указателя не касается указателей. Он просто изменяет один указатель, чтобы он имел ту же ссылку, что и другой указатель. После назначения указателя говорят, что два указателя «разделяют» указатель.

Раздел 2. Код Бинки, пример

В этом разделе представлен тот же пример кода, что и в Веселье указки с видео Бинки. Существуют версии кода на нескольких компьютерных языках. Все версии имеют одинаковую структуру и демонстрируют одни и те же основные правила и уроки работы с указателями; они просто различаются по своему синтаксису. Независимо от какого-либо конкретного языка, основная структура примера такова...

Предположим, у вас есть тип указателя с именем «Node», который содержит две вещи: int и указатель на другой Node (объявление для такого типа Node приведено ниже). С таким типом указателя вы можете расположить три указателя Node в структуре, где они указывали бы друг на друга вот так...

Указатель с именем x указывает на первый указатель Node. Первый узел содержит указатель на второй, второй содержит указатель на третий, а третий содержит указатель обратно на первый. Эту структуру можно построить, используя только те правила размещения, разыменования и назначения указателей, которые мы видели. Используя приведенное ниже объявление, каждый узел содержит целое число с именем , значением и указатель на другой узел с именем next .

Напишите код для построения структуры на приведенном выше рисунке. Для удобства вы можете использовать временные указатели в дополнение к х . Единственный требуемый новый синтаксис заключается в том, что в C оператор -> разыменовывает указатель для доступа к полю в указателе, поэтому -> значение обращается к полю с именем value в указателе x .

Представленная здесь структура Node на самом деле является реальным типом данных, используемым для построения структуры данных «связанный список». Связанные списки представляют собой реалистичное прикладное использование указателей и являются отличной областью для развития ваших навыков работы с указателями. См. «Основы связанных списков» и «Задачи связанных списков» в Стэнфордской образовательной библиотеке CS для получения большого количества материалов со связанными списками.

Copyright Nick Parlante, 1999. Этот материал можно копировать и распространять при условии сохранения стандартного уведомления Стэнфордской образовательной библиотеки CS на первой странице: «Это документ 106 в Стэнфордской образовательной библиотеке CS. Этот и другие бесплатные материалы доступны по адресу cslibrary.stanford.edu."

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

1. Разместите два указателя x и y . Выделение указателей не назначьте любые путеводители.
2. Выделите указатель и установите x , чтобы он указывал на него. Каждый язык имеет для этого свой синтаксис. Важно то, что память динамически выделяется для одного указателя, и x настроены так, чтобы он указывал на этот указатель.
3. Разыменование x для сохранения 42 в его указателе. Это базовый пример операции разыменования. Начните с x , следуйте стрелке, чтобы получить доступ к ее указателю.
4. Попробуйте разыменовать и , чтобы сохранить 13 в его указателе. Это дает сбой, потому что y не имеет указателя - он никогда не был назначен.
5. Присвоить y = x; , так что y указывает на х пуант. Теперь x и y указывают на одну и ту же точку - они "совместно используются".
6. Попробуйте разыменовать y , чтобы сохранить 13 в своем указателе. На этот раз это работает, потому что предыдущее задание дало и пуант.