Какое использование константных указателей (в отличие от указателей на константные объекты)?

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

Например, у меня есть 32-битный процессор MIP с маленький ЖК-дисплей, прикрепленный к нему. Мне нужно записать данные ЖК-дисплея в определенный порт памяти, которые затем отправляются на контроллер ЖК-дисплея.

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

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

Примером для программ для ПК может быть: если вы разрабатываете игры для DOS VGA (в Интернете есть учебные пособия, которые интересно пройти, чтобы изучить базовую низкоуровневую графику), тогда вам необходимо выполнить запись в память VGA, на которую можно ссылаться как на смещение. из константного указателя.

-Адам

Это позволяет защитить указатель от изменения. Это означает, что вы можете защитить свои предположения, основываясь на том, что указатель никогда не меняется, или от непреднамеренного изменения, например:

int* const p = &i;

...

p++;     /* Compiler error, oops you meant */
(*p)++;  /* Increment the number */

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

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

Одно из применений - это низкоуровневый код (драйвер устройства или встроенный), где вам нужно ссылаться на конкретный адрес, который сопоставлен с устройством ввода / вывода, например, с аппаратным контактом. Некоторые языки позволяют связывать переменные по определенным адресам (например, в Ada есть use at). В C наиболее идиоматический способ сделать это - объявить постоянный указатель. Обратите внимание, что такие употребления также должны иметь квалификатор volatile.

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

Я всегда использовал их, когда хотел избежать непреднамеренного изменения указателя (например, арифметические операции с указателем или внутри функции). Вы также можете использовать их для шаблонов Singleton.

'this' - это жестко запрограммированный указатель на константу.

То же, что и "const int" ... если компилятор знает, что он не изменится, это могут быть предположения оптимизации, основанные на этом.

struct MyClass
{
    char* const ptr;
    MyClass(char* str) :ptr(str) {}

    void SomeFunc(MyOtherClass moc)
    {
         for(int i=0; i < 100; ++i)
         { 
                 printf("%c", ptr[i]);
                 moc.SomeOtherFunc(this);
         }
    }
}

Теперь компилятор мог бы немного оптимизировать этот цикл - при условии, что он знает, что SomeOtherFunc () не изменяет значение ptr. С константой компилятор знает это и может делать предположения. Без него компилятор должен предположить, что SomeOtherFunc изменит ptr.

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

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

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

Думайте о типе * и константном типе * как о самих типах. Затем вы можете понять, почему вам может понадобиться константа этих типов.

всегда думайте об указателе как об int. это означает, что

object* var;

на самом деле можно рассматривать как

int var;

Итак, константный указатель просто означает, что:

const object* var;

становится

const int var;

и, следовательно, вы не можете изменить адрес, на который указывает указатель, и все. Чтобы предотвратить изменение данных, u должен сделать его указателем на константный объект.