Инструменты пользователя

Инструменты сайта


examination:oop:question19

19. Указатели: семантика типа, описание переменных, операции и функции для обработки значений. Указатели и векторы. Приемы программирования.

Ни слова про векторы

Указатель – это производный тип, который представляет собой адрес какого-либо значения. В языке Си++ используется понятие адреса переменных. Работа с адресами досталась Си++ в наследство от языка Си.

int x;      //Предположим, что в программе определена переменная типа int
 
int* xptr;  //Можно определить переменную типа "указатель" на целое число
 
xptr = &x;  //B присвоить переменной xptr адрес переменной x

Операция &, примененная к переменной, – это операция взятия адреса. Операция *, примененная к адресу, – это операция обращения по адресу . Таким образом, два оператора эквивалентны:

int y = x;      // присвоить переменной y значение x
int y = *xptr;  // присвоить переменной y значение, 
                // находящееся по адресу xptr

С помощью операции обращения по адресу можно записывать значения:

*xptr = 10;  // записать число 10 по адресу xptr

После выполнения этого оператора значение переменной x станет равным 10, поскольку xptr указывает на переменную x.

Указатель – это не просто адрес, а адрес величины определенного типа. Указатель xptr – адрес целой величины. Определить адреса величин других типов можно следующим образом:

unsigned long* lPtr;    // указатель на целое число без знака
char* cp;               // указатель на байт
Complex* p;             // указатель на объект класса Complex

Если указатель ссылается на объект некоторого класса, то операция обращения к атрибуту класса вместо точки обозначается « → », например p→real.

void Complex::Add(Complex x)
{
  this->real = this->real + x.real;
  this->imaginary = this->imaginary + 
                          x.imaginary;
}

то this – это указатель на текущий объект, т.е. объект, который выполняет метод Add. Запись this→ означает обращение к атрибуту текущего объекта.

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

int foo(long x);
int bar(long x);

можно определить переменную типа указатель на функцию и вызывать эти функции не напрямую, а косвенно, через указатель:

int (*functptr)(long x);
functptr = &foo;
(*functptr)(2);
functptr = &bar;
(*functptr)(4);

Для чего нужны указатели?

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

int* hardwareRegister =0x80000;
*hardwareRegister =12;

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

struct TempResults {
     double x1;
     double x2;
} tempArea;
  // Функция calc возвращает истину, если 
  // вычисления были успешны, и ложь – при 
  // наличии ошибки. Вычисленные результаты 
  // записываются на место аргументов по 
  // адресу, переданному в указателе trPtr
bool
calc(TempResults* trPtr)
{
     // вычисления
     if (noerrors) {
          trPtr->x1 = res1;
          trPtr->x2 = res2;
          return true;
     } else {
          return false;
     }
}
void
fun1(void)
{
     . . .
     TempResults tr;
     tr.x1 = 3.4;
     tr.x2 = 5.4;
     if (calc(&tr) == false) {
          // обработка ошибки
     }
     . . .
}

В приведенном примере проиллюстрированы сразу две возможности использования указателей: передача адреса общей памяти и возможность функции иметь более одного значения в качестве результата.

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

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

Адресная арифметика

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

int x = 10;
int y = 10;
int* xptr = &x;
int* yptr = &y;
 
// сравниваем указатели (получаем ложь)
if (xptr == yptr) {
    cout << "Указатели равны" << endl;
} else {
    cout << "Указатели не равны" << endl;
}
 
// сравниваем значения, на которые указывают указатели (получаем истину)
if (*xptr == *yptr) {
     cout << "Значения равны" << endl;
} else {
     cout << "Значения не равны" << endl;
}

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

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

Размер памяти, выделяемой для числа типа long и для char, различен. Поэтому адрес при увеличении xPtr и cp тоже изменяется по-разному. Однако и в том, и в другом случае увеличение указателя на единицу означает переход к следующей в памяти величине того же типа. Прибавление или вычитание любого целого числа работает по тому же принципу, что и увеличение на единицу. Указатель сдвигается вперед (при прибавлении положительного числа) или назад (при вычитании положительного числа) на соответствующее количество объектов того типа, на который показывает указатель. Вообще говоря, неважно, объекты какого типа на самом деле находятся в памяти — адрес просто увеличивается или уменьшается на необходимую величину. На самом деле значение указателя ptr всегда изменяется на число, кратное sizeof(*ptr).

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

Связь между массивами и указателями (надо ли это?)

Между указателями и массивами существует определенная связь. Предположим, имеется массив из 100 целых чисел. Запишем двумя способами программу суммирования элементов этого массива:

long array[100];
long sum = 0;
for (int i = 0; i < 100; i++)
     sum += array[i];

То же самое можно сделать с помощью указателей:

long array[100];
long sum = 0;
for (long* ptr = &array[0]; 
     ptr < &array[99] + 1; ptr++)
     sum += *ptr;

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

for (long* ptr = array; 
     ptr < &array[99] + 1; ptr++)
     sum += *ptr;

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

При использовании многомерных массивов указатели позволяют обращаться к срезам или подмассивам. Если мы объявим трехмерный массив exmpl:

long exmpl[5][6][7]

то выражение вида exmpl[1][1][2] – это целое число, exmpl[1][1] – вектор целых чисел ( адрес первого элемента вектора, т.е. имеет тип *long ),exmpl[1] – двухмерная матрица или указатель на вектор (тип (*long)[7] ). Таким образом, задавая не все индексы массива, мы получаем указатели на массивы меньшей размерности.

Бестиповый (нетипизированный) указатель

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

void* ptr;

Для указателя на тип void не определена операция →, не определена операция обращения по адресу *, не определена адресная арифметика. Использование безтиповых указателей ограничено работой с памятью при использовании ряда системных функций, передачей адресов в функции, написанные на языках программирования более низкого уровня, например на ассемблере.

В программе на языке Си++ безтиповый указатель может применяться там, где адрес интерпретируется по-разному, в зависимости от каких-либо динамически вычисляемых условий. Например, приведенная ниже функция будет печатать целое число, содержащееся в одном, двух или четырех байтах, расположенных по передаваемому адресу:

void printbytes(void* ptr, int nbytes)
{
  if (nbytes == 1) {
     char* cptr = (char*)ptr;
     cout << *cptr;
  } else if (nbytes == 2) {
     short* sptr = (short*)ptr;
     cout << *sptr;
  } else if (nbytes == 4) {
     long* lptr = (long*)ptr;
     cout << *lptr;
  } else {
     cout << "Неверное значение аргумента";
  }
}

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

Нулевой указатель

В программах на языке Си++ значение указателя, равное нулю, используется в качестве «неопределенного» значения. Например, если какая-то функция вычисляет значение указателя, то чаще всего нулевое значение возвращается в случае ошибки.

long* foo(void);
//. . .
long* resPtr;
if ((resPtr = foo()) != 0) {
          // использовать результат
} else {
          // ошибка
}

В языке Си++ определена символическая константа NULL для обозначения нулевого значения указателя. Такое использование нулевого указателя было основано на том, что по адресу 0 данные программы располагаться не могут, он зарезервирован операционной системой для своих нужд. Однако во многом нулевой указатель – просто удобное соглашение, которого все придерживаются.

examination/oop/question19.txt · Последние изменения: 2014/01/15 08:22 (внешнее изменение)