В C можно указывать почти на что угодно. Язык позволяет создавать указатели для примитивных типов, массивов, функций и пользовательских типов. Но указатели на структуры — это то, где становится интересно. Они встречаются чрезвычайно часто. Если вы пишете код на C, вы, вероятно, будете сталкиваться с ними регулярно.
Вот базовый пример. Он показывает, как определить структуру и затем создать указатель на нее.
Этот фрагмент кода делает больше, чем просто присваивает адрес памяти. Он устанавливает связь между переменной ptr и структурой p1. Указатель хранит адрес структуры. Это позволяет вам косвенно обращаться к членам x и y. Это фундаментальный шаблон. Вы видите его в связных списках, динамическом выделении памяти и аргументах функций.
Зачем использовать указатели на структуры?
Копирование целых структур дорого обходится. Если ваша структура содержит много данных, передача ее по значению в функцию означает, что компилятор делает полную копию. Это тратит время и память. Использование указателя позволяет избежать копирования. Вы передаете адрес вместо значения. Функция может изменять исходные данные без накладных расходов.
Также возникает вопрос динамического размера. Массивы имеют фиксированный размер на этапе компиляции. Структуры сами по себе не обязательно решают проблему динамичности. Но когда вы объединяете структуру с malloc, вы получаете гибкое хранение данных. Вы можете выделить структуру в куче. Указатель на эту структуру позволяет вам управлять ее жизненным циклом вручную.
Доступ к членам через указатели
Как только у вас есть указатель, вам нужно получить доступ к данным внутри. Вы не можете использовать оператор точки. Выражение ptr.x не скомпилируется. ptr — это адрес, а не сама структура. Сначала вы должны разыменовать его.
Есть два способа сделать это. Первый — многословный.
Скобки здесь обязательны. Оператор точки имеет более высокий приоритет, чем оператор разыменования. Без них компилятор попытается обратиться к ptr.x, которого не существует.
Второй способ чище. C предоставляет стрелочный оператор ->. Он объединяет разыменование и доступ к члену в один шаг.
Этот синтаксис является стандартным. Именно его вы увидите в реальных кодовых базах. Он читается естественно как «перейти к объекту, на который указывает ptr, и получить его член x ». Он лаконичен. Он уменьшает визуальный шум.
Распространенные ошибки
Указатели NULL представляют риск. Если вы объявляете указатель, но не инициализируете его, он указывает на мусор. Доступ к ptr->x для нулевого указателя вызывает сегментацию (сегфолт). Вы должны проверять указатель на NULL перед его использованием.
Эта проверка не является опциональной в надежном коде. Она предотвращает сбои.
Другая проблема — утечки памяти. Если вы выделяете память с помощью malloc и теряете указатель, эта память остается зарезервированной до конца работы программы. Вы должны отслеживать каждое выделение. free() — ваша ответственность. Забыть об этом
Указатели на структуры в C часто становятся камнем преткновения для разработчиков, которые уверенно владеют базовыми указателями, но запутываются в синтаксисе. Рассмотрим простое определение записи для профиля пользователя.
Здесь RecPointer — это просто псевдоним для указателя на структуру Rec. Когда вы объявляете переменную этого типа, вы имеете дело с адресом в памяти, а не с самими данными.
Переменная r занимает четыре байта в 32-битной системе (или восемь в 64-битной). Это просто указатель. Он не содержит имя, город или состояние. Чтобы хранить реальные данные, необходимо выделить память в куче (heap).
Этот вызов malloc резервирует 45 байт. Это 21 байт для имени, 21 для города и 3 для состояния, плюс один байт для заполнения или выравнивания для соответствия границам памяти. Теперь r указывает на допустимый блок памяти, который ведет себя точно так же, как структура Rec.
Доступ к членам через разыменование
Для взаимодействия с данными необходимо разыменовать указатель. Именно здесь часто возникают ошибки, связанные с приоритетами операций. Вы можете получать доступ к членам с помощью стандартной точечной нотации, но должны обернуть операцию разыменования в скобки.
Обратите внимание на синтаксис. (*r).name — это правильный вариант. Если вы напишете *r.name, код не скомпилируется. Почему? Потому что оператор точки имеет более высокий приоритет, чем оператор разыменования. Компилятор интерпретирует *r.name как *(r.name). Поскольку r является указателем, r.name является недопустимым синтаксисом, и выражение терпит неудачу. Скобки заставляют сначала выполнить разыменование *r, получая структуру, а затем оператор точки получает доступ к полю name.
Это утомительно писать. Выглядит загроможденно. Это провоцирует ошибки.
Стрелочная нотация
C предоставляет более чистый способ работы с этим. Стрелочный оператор -> является синтаксическим сахаром для (*pointer).member. Это не другой механизм. Это не новый оператор, который изменяет способ доступа к памяти. Это просто более короткий способ записи операции разыменования и доступа к члену структуры в один шаг.
Это идентично strcpy((*r).name, "Leigh"). Это экономит два символа. Это избавляет от необходимости использовать вложенные скобки. Это стандартный способ, которым большинство разработчиков на C взаимодействуют с указателями на структуры.
Последствия для управления памятью
Вызов free(r) обязателен. Память была выделена из кучи. Если вы не освободите её, произойдет утечка памяти. Сам указатель r, четырехбайтовая переменная, хранящая адрес, является локальной для кадра стека или имеет глобальную область видимости, но данные, на которые он указывает, находятся в другом месте.
Когда вы используете r->name, вы изменяете данные по адресу, хранящемуся в r. Сам указатель r остается неизменным. Адрес не
Выделение памяти для массивов «на лету» является неотъемлемой частью программирования на C, но для этого необходимо понимать, как указатели взаимодействуют с блоками сырой памяти. Когда вам нужен массив фиксированного размера, размер которого неизвестен на этапе компиляции, стандартного выделения в стеке недостаточно. Придется обращаться к куче (heap).
Приведенный ниже фрагмент кода демонстрирует одну из распространенных схем:
Здесь malloc резервирует место для десяти целых чисел. Приведение к типу (int *) гарантирует, что указатель соответствует ожидаемому типу, хотя современные компиляторы C часто выдают предупреждения о явных приведениях для void*. Затем цикл инициализирует каждый элемент нулем с использованием нотации с индексами. Наконец, free возвращает память системе.
Но это не единственный способ записи.
Вы можете получить абсолютно тот же результат, заменив p[i] на арифметику указателей:
Почему это важно? Потому что p[i] — это просто синтаксический сахар для *(p+i). Компилятор обрабатывает их идентично. Если вы работаете с встраиваемыми системами или пишете плотные циклы, где важен каждый такт, знание того, что эти конструкции взаимозаменяемы, помогает читать унаследованный код и писать свой собственный без путаницы.
Тем не менее, здесь есть тонкая ловушка.
Если вы объявляете указатель на тип массива напрямую — например, int (*p)[10] — вы имеете дело с совершенно другим механизмом. Этот указатель указывает на весь массив целиком, а не только на его первый элемент. Инкремент такого указателя сдвигает его на размер всего массива, а не на размер одного целого числа. Большинство разработчиков используют int *, поскольку это проще и гибче.
Когда какой подход использовать
Выбор между нотацией с индексами и явной арифметикой указателей часто сводится к читаемости и намерениям.
- Используйте
p[i], когда хотите подчеркнуть доступ на основе индекса. Это понятнее для большинства читателей. - Используйте
*(p+i), когда вы занимаетесь низкоуровневой манипуляцией с памятью или должны избежать особенностей «распада массива» в сложных выражениях.
Оба подхода требуют тщательного управления памятью. Забыли вызвать free — утекаете память. Вызвали ее слишком рано — получаете неопределенное поведение. И хотя malloc здесь выглядит просто, всегда проверяйте, что возвращаемое значение не равно NULL, прежде чем разыменовывать указатель.
«Указатели на массивы мощны, но требуют дисциплины. Одно неверное движение — и вы читаете мусор или, что хуже, повреждаете память другой переменной».
На практике большинству разработчиков редко нужно писать сырую арифметику указателей для простых массивов. Библиотеки, такие как std::vector в C++, или более высокоуровневые абстракции в других языках обрабатывают это автоматически. Но в C? Вы остаетесь один на один с этой задачей.
Именно поэтому понимание механики имеет значение. Не только для сдачи собеседований или написания учебников, но и тогда, когда код ломается в 2 часа ночи, и вам нужно точно знать, что происходит в памяти.
Когда вы объявляете указатель на массив целых чисел, вы не создаете ничего экзотического. Это просто стандартный указатель на int. Магия происходит с помощью malloc. Вы выделяете блок памяти, достаточный для нужного количества целых чисел. Указатель затем указывает на первый элемент этого блока.
C не заботится о том, как вы к нему обращаетесь. Вы можете использовать квадратные скобки, например p[5], или арифметику указателей, например *(p + 5). Компилятор считает их идентичными. Эта гибкость делает динамические массивы такими полезными для строк. Вы не угадываете размер. Вы выделяете ровно столько памяти, сколько требуется для длины строки плюс нуль-терминатор.
Массивы указателей против массивов структур
Зачем использовать массив указателей, если можно просто использовать массив структур? Место. Или, точнее, его отсутствие.
Рассмотрим структуру Rec с тремя символьными массивами по 81 байту каждый. Это 243 байта на запись. Если вы объявите Rec records[10], вы мгновенно зарезервируете 2430 байт в памяти. Все сразу. Даже если вы когда-либо будете использовать только одну запись.
Массив указателей меняет математику.
Сам массив a содержит только 10 указателей. В 64-битной системе это 80 байт. Это лишь малая часть памяти, необходимой для полных структур. Память для самих записей остается неиспользованной, пока она вам не понадобится.
Вы можете выделять одну запись по мере необходимости.
Этот шаблон решает проблемы, требующие большого объема памяти, откладывая выделение. Вы платите только за то, что используете. Когда вы закончите с записью, вы вызываете free. Указатель становится висячим, но память возвращается системе.
Структуры, содержащие указатели
Структуры могут содержать указатели. Это позволяет смешивать данные фиксированного размера с данными переменного размера в одном объекте.
Возьмем запись в адресной книге. Имя, город и номер телефона могут иметь разумные максимальные длины. Однако комментарий может быть чем угодно: от одного слова до целого романа. Вы не хотите тратить место, выделяя огромный буфер для каждой записи только на тот случай, если кто-то напишет длинный комментарий.
Сама структура Addr небольшая
Как поля комментариев обрабатывают пустые и заполненные записи
Не каждая запись в базе данных содержит комментарий. Когда поле остается пустым, оно не просто пусто. Оно содержит указатель. А именно, 4-байтовый указатель, который ни на что не указывает. Система рассматривает это отсутствие как допустимое состояние. Запись остается полной. Метаданные сохранены.
Но что происходит, когда пользователь действительно вводит текст?
Процесс выделения памяти меняется. База данных не резервирует фиксированный буфер для этих комментариев. Она не предполагает максимальную длину и не заполняет оставшееся пространство нулями. Это было бы расточительно. Вместо этого система вычисляет точную длину строки. Затем она выделяет ровно столько байт, сколько необходимо.
Это динамическое выделение эффективно. Оно предотвращает фрагментацию из-за раздувания данных. Короткая заметка занимает несколько байт. Длинное эссе — больше. Указатель в пустой записи указывает на нулевую ссылку, сохраняя минимальный объем занимаемого места. Записи с содержимым растягиваются, чтобы вместить данные. Ничего не тратится впустую. Ничего не навязывается.
Является ли это единственным способом хранения текста? Нет. Но это умный способ балансировать между скоростью и пространством. Вы получаете отзывчивость заголовков фиксированного размера с гибкостью данных переменной длины. Это небольшая деталь. Низкоуровневый механизм. Но он имеет значение, когда вы управляете миллионами записей. База данных «дышит» легче. Использование диска остается компактным.
А пользователь? Он никогда не видит указатель. Он видит только свой комментарий. Или его отсутствие. Сложность скрыта. Хранение оптимизировано. В результате получается система, которая ощущается легкой, даже когда данные растут.
