Зачем нужны указатели?

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

Лучшее объяснение указателей и арифметики указателей, которое я читал, находится в Язык программирования C K&R. Хорошая книга для начинающих изучать C++ - Учебник по C++.

По большей части указатели представляют собой массивы (в C / C++) - это адреса в памяти, и при желании к ним можно обращаться как к массиву (в «обычных» случаях).

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

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

Потому что копирование больших объектов повсюду тратит время и память.

1. Указатели позволяют ссылаться на одно и то же пространство в памяти из разных мест. Это означает, что вы можете обновлять память в одном месте, а изменение можно увидеть из другого места в вашей программе. Вы также сэкономите место, имея возможность совместно использовать компоненты в своих структурах данных.
2. Вы должны использовать указатели в любом месте, где вам нужно получить и передать адрес в определенное место в памяти. Вы также можете использовать указатели для навигации по массивам:
3. Массив - это блок непрерывной памяти, выделенный для определенного типа. Имя массива содержит значение начальной точки массива. Когда вы добавляете 1, вы попадаете на второе место. Это позволяет вам писать циклы, которые увеличивают указатель, который скользит вниз по массиву, без явного счетчика для использования при доступе к массиву.

Вот пример на C:

char hello[] = "hello";

char *p = hello;

while (*p)
{
    *p += 1; // increase the character by one

    p += 1; // move to the next spot
}

printf(hello);

отпечатки

ifmmp

потому что он берет значение для каждого символа и увеличивает его на единицу.

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

В C++ лучше использовать ссылки, чем указатели. Хотя ссылки по сути являются указателями, C++ до некоторой степени скрывает этот факт и создает впечатление, будто вы передаете по значению. Это позволяет легко изменить способ получения значения вызывающей функцией без изменения семантики его передачи.

Рассмотрим следующие примеры:

Использование ссылок:

public void doSomething()
{
    int i = 10;
    doSomethingElse(i);  // passes i by references since doSomethingElse() receives it
                         // by reference, but the syntax makes it appear as if i is passed
                         // by value
}

public void doSomethingElse(int& i)  // receives i as a reference
{
    cout << i << endl;
}

Использование указателей:

public void doSomething()
{
    int i = 10;
    doSomethingElse(&i);
}

public void doSomethingElse(int* i)
{
    cout << *i << endl;
}

Указатели важны во многих структурах данных, дизайн которых требует способности эффективно связывать или связывать один «узел» с другим. Вы не стали бы «выбирать» указатель, скажем, над обычным типом данных, таким как float, у них просто разные цели.

Указатели полезны там, где требуется высокая производительность и / или компактный объем памяти.

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

Вот немного другой, но проницательный взгляд на то, почему многие функции C имеют смысл: http://steve.yegge.googlepages.com/tour-de-babel#C

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

C++ делает указатели немного запутанными, поскольку иногда управляет ими за вас и скрывает их эффект в виде «ссылок». Если вы используете прямой язык C, потребность в указателях гораздо более очевидна: нет другого способа выполнить вызов по ссылке, это лучший способ сохранить строку, это лучший способ перебрать массив и т. д.

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

В старые времена DOS вы могли напрямую обращаться к видеопамяти видеокарты, объявляя указатель на:

unsigned char *pVideoMemory = (unsigned char *)0xA0000000;

Многие встроенные устройства до сих пор используют эту технику.

• Зачем использовать указатели вместо обычных переменных?

Короткий ответ: не надо. ;-) Указатели следует использовать там, где больше ничего нельзя использовать. Это либо из-за отсутствия соответствующей функциональности, отсутствия типов данных, либо из-за чистой производительности. Подробнее ниже ...

• Когда и где использовать указатели?

Краткий ответ: там, где вы больше ничего не можете использовать. В C нет поддержки сложных типов данных, таких как строка. Также нет способа передать переменную «по ссылке» в функцию. Вот где вам нужно использовать указатели. Также вы можете заставить их указывать практически на что угодно, связанные списки, элементы структур и так далее. Но не будем здесь вдаваться в подробности.

• Как использовать указатели с массивами?

Приложив немного усилий и много путаницы. ;-) Если мы говорим о простых типах данных, таких как int и char, разница между массивом и указателем небольшая. Эти объявления очень похожи (но не одинаковы - например, sizeof вернет разные значения):

char* a = "Hello";
char a[] = "Hello";

Вы можете получить доступ к любому элементу в массиве следующим образом

printf("Second char is: %c", a[1]);

Индекс 1, поскольку массив начинается с элемента 0. :-)

Или вы могли бы сделать то же самое

printf("Second char is: %c", *(a+1));

Оператор указателя (*) необходим, поскольку мы сообщаем printf, что хотим напечатать символ. Без * было бы напечатано символьное представление самого адреса памяти. Теперь мы используем самого персонажа. Если бы мы использовали% s вместо% c, мы бы попросили printf распечатать содержимое адреса памяти, на который указывает 'a' плюс один (в этом примере выше), и нам бы не пришлось ставить * спереди:

printf("Second char is: %s", (a+1)); /* WRONG */

Но это не просто напечатало бы второй символ, а вместо этого все символы в следующих адресах памяти, пока не был бы найден нулевой символ (\ 0). И здесь все становится опасным. Что, если вы случайно попытаетесь напечатать переменную типа integer вместо указателя char с помощью программы форматирования% s?

char* a = "Hello";
int b = 120;
printf("Second char is: %s", b);

Это напечатает все, что найдено по адресу памяти 120, и продолжит печать, пока не будет найден нулевой символ. Выполнять этот оператор printf неправильно и незаконно, но он, вероятно, все равно будет работать, поскольку во многих средах указатель фактически имеет тип int. Представьте себе проблемы, которые вы могли бы вызвать, если бы вместо этого использовали sprintf () и назначили таким образом слишком длинный «массив символов» другой переменной, для которой было выделено только определенное ограниченное пространство. Скорее всего, вы закончите записывать что-то еще в памяти и вызвать сбой вашей программы (если вам повезет).

Да, и если вы не присваиваете строковое значение массиву / указателю char при его объявлении, вы ДОЛЖНЫ выделить ему достаточный объем памяти, прежде чем присвоить ему значение. Использование malloc, calloc или подобных. Это потому, что вы объявили только один элемент в своем массиве / один адрес памяти, на который нужно указывать. Итак, вот несколько примеров:

char* x;
/* Allocate 6 bytes of memory for me and point x to the first of them. */
x = (char*) malloc(6);
x[0] = 'H';
x[1] = 'e';
x[2] = 'l';
x[3] = 'l';
x[4] = 'o';
x[5] = '\0';
printf("String \"%s\" at address: %d\n", x, x);
/* Delete the allocation (reservation) of the memory. */
/* The char pointer x is still pointing to this address in memory though! */
free(x);
/* Same as malloc but here the allocated space is filled with null characters!*/
x = (char *) calloc(6, sizeof(x));
x[0] = 'H';
x[1] = 'e';
x[2] = 'l';
x[3] = 'l';
x[4] = 'o';
x[5] = '\0';
printf("String \"%s\" at address: %d\n", x, x);
/* And delete the allocation again... */
free(x);
/* We can set the size at declaration time as well */
char xx[6];
xx[0] = 'H';
xx[1] = 'e';
xx[2] = 'l';
xx[3] = 'l';
xx[4] = 'o';
xx[5] = '\0';
printf("String \"%s\" at address: %d\n", xx, xx);

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

В java и C# все ссылки на объекты являются указателями, а в C++ у вас больше контроля над тем, куда вы указываете. Помните, что великая сила влечет за собой большую ответственность.

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

• В некоторых случаях указатели на функции требуются для использования функций из общей библиотеки (.DLL или .so). Это включает выполнение работы на разных языках, где часто предоставляется интерфейс DLL.
• Создание компиляторов
• Создание научных калькуляторов, где у вас есть массив, векторная или строковая карта указателей на функции?
• Попытка изменить видеопамять напрямую - создание собственного графического пакета
• Делаем API!
• Структуры данных - указатели узловых ссылок для особых деревьев, которые вы создаете

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

Вот мой ответ, и я не обещаю быть экспертом, но я обнаружил, что указатели отлично подходят для одной из моих библиотек, которую я пытаюсь написать. В этой библиотеке (это графический API с OpenGL :-)) вы можете создать треугольник с переданными в него объектами вершин. Метод рисования берет эти треугольные объекты и ... рисует их на основе созданных мной вершинных объектов. Что ж, все в порядке.

Но что, если я изменю координату вершины? Переместите это или что-то с помощью moveX () в классе вершин? Хорошо, хорошо, теперь мне нужно обновить треугольник, добавление дополнительных методов и производительности тратится зря, потому что мне приходится обновлять треугольник каждый раз, когда перемещается вершина. Все еще не имеет большого значения, но не так уж и хорошо.

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

С указателями вам не нужно обновлять треугольники.

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

Необходимость указателей на языке C описана здесь

Основная идея заключается в том, что многие ограничения в языке (например, использование массивов, строк и изменение нескольких переменных в функциях) могут быть сняты, манипулируя местоположением данных в памяти. Чтобы преодолеть эти ограничения, в C.

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

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

В C++, если вы хотите использовать подтип полиморфизм, вы имеют используете указатели. Смотрите этот пост: Полиморфизм C++ без указателей.

На самом деле, если подумать, это имеет смысл. Когда вы используете полиморфизм подтипа, в конечном итоге вы не знаете заранее, реализация метода какого класса или подкласса будет вызвана, потому что вы не знаете, что это за класс на самом деле.

Идея наличия переменной, содержащей объект неизвестного класса, несовместима с режимом хранения объектов в стеке по умолчанию (без указателя) C++, где объем выделенного пространства напрямую соответствует классу. Примечание: если в классе 5 полей экземпляров вместо 3, потребуется выделить больше места.

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

Проблема с конструкциями C++, которые люди обычно используют для замены указателей, очень зависит от набора инструментов, который вы используете, что нормально, когда у вас есть весь необходимый контроль над исходным кодом, однако, если вы скомпилируете статическую библиотеку, например, с Visual Studio 2008 и попробуйте использовать его в Visual Studio 2010, вы получите массу ошибок компоновщика, потому что новый проект связан с более новой версией STL, которая не имеет обратной совместимости. Все становится еще хуже, если вы компилируете DLL и даете библиотеку импорта, которую люди используют в другом наборе инструментов, потому что в этом случае ваша программа рано или поздно выйдет из строя без видимой причины.

Итак, с целью перемещения больших наборов данных из одной библиотеки в другую вы можете рассмотреть возможность предоставления указателя на массив функции, которая должна копировать данные, если вы не хотите заставлять других использовать те же инструменты, которые вы используете. . Хорошая часть этого заключается в том, что это даже не обязательно должен быть массив в стиле C, вы можете использовать std :: vector и указать указатель, указав, например, адрес первого элемента & vector [0], и использовать std :: vector для внутреннего управления массивом.

Еще одна веская причина для использования указателей в C++ снова относится к библиотекам, подумайте о наличии библиотеки DLL, которая не может быть загружена при запуске вашей программы, поэтому, если вы используете библиотеку импорта, зависимость не удовлетворяется и программа дает сбой. Это имеет место, например, когда вы предоставляете публичный api в dll вместе со своим приложением и хотите получить к нему доступ из других приложений. В этом случае, чтобы использовать API, вам необходимо загрузить dll из ее местоположения (обычно это ключ реестра), а затем вам нужно использовать указатель на функцию, чтобы иметь возможность вызывать функции внутри DLL. Иногда люди, которые создают API, достаточно любезны, чтобы предоставить вам файл .h, содержащий вспомогательные функции для автоматизации этого процесса и предоставить вам все необходимые указатели функций, но если нет, вы можете использовать LoadLibrary и GetProcAddress в окнах и dlopen и dlsym в unix, чтобы получить их (учитывая, что вы знаете всю сигнатуру функции).

Позвольте мне попытаться ответить и на это.

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

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

Зачем использовать указатели вместо обычных переменных? Ответ становится яснее, когда вы имеете дело со сложными типами, такими как классы, структуры и массивы. Если бы вы использовали обычную переменную, вы могли бы сделать копию (компиляторы достаточно умны, чтобы предотвратить это в некоторых ситуациях, и C++ 11 тоже помогает, но мы пока воздержимся от этого обсуждения).

Что произойдет, если вы захотите изменить исходное значение? Вы можете использовать что-то вроде этого:

MyType a; //let's ignore what MyType actually is right now.
a = modify(a); 

Это будет работать нормально, и если вы точно не знаете, для чего используете указатели, вам не следует их использовать. Остерегайтесь причины «они, наверное, быстрее». Запустите свои собственные тесты, и если они действительно быстрее, то используйте их.

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

MyType *p = NULL; //empty pointer
if (p)
{
    //we never reach here, because the pointer points to nothing
}
//now, let's allocate some memory
p = new MyType[50000];
if (p) //if the memory was allocated, this test will pass
{
    //we can do something with our allocated array
    for(size_t i=0; i!=50000; i++)
    {
        MyType &v = *(p+i); //get a reference to the ith object
        //do something with it
        //...
    }
    delete[] p; //we're done. de-allocate the memory
}

Это ключ к тому, почему вы должны использовать указатели - ссылки предполагают, что элемент, на который вы ссылаетесь, уже существует. Указатель - нет.

Другая причина, по которой вы должны использовать указатели (или, по крайней мере, в конечном итоге иметь с ними дело), ​​заключается в том, что они являются типом данных, который существовал до ссылок. Поэтому, если вы в конечном итоге используете библиотеки для выполнения тех вещей, которые, как вы знаете, у них лучше, вы обнаружите, что многие из этих библиотек используют указатели повсюду просто из-за того, как долго они существуют (много из них были написаны до C++).

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

С точки зрения ремонтопригодности, я должен также упомянуть, что когда вы используете указатели, вам нужно либо проверить их действительность и обработать случай, когда они недействительны, либо просто предположить, что они действительны, и принять тот факт, что ваш программа выйдет из строя или хуже того, КОГДА это предположение нарушится. Другими словами, ваш выбор с указателями - либо усложнить код, либо увеличить усилия по обслуживанию, когда что-то ломается., и вы пытаетесь отследить ошибку, которая принадлежит к целому классу ошибок, которые вводят указатели, например, повреждение памяти.

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

Просто запомните эту разницу: Ссылка - это, по сути, действительный указатель. Указатель не всегда действителен.

Я говорю, что создать недействительную ссылку невозможно? Нет. Это вполне возможно, потому что C++ позволяет делать почти все. Просто сделать это непреднамеренно сложнее, и вы удивитесь, сколько ошибок было непреднамеренно :)