C# 4.0: полное руководство - Герберт Шилдт

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

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

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

Объявление указателя

Переменные-указатели должны быть объявлены как таковые. Ниже приведена общая форма объявления переменной-указателя:

тип* имя_переменной;

где тип обозначает соотносимый тип, который не должен быть ссылочным. Это означает, что в C# нельзя объявить указатель на объект определенного класса. Соотносимый тип указателя иногда еще называют базовым. Обратите внимание на положение знака * в объявлении указателя. Он должен следовать после наименования типа. А имя_переменной обозначает конкретное имя указателя-переменной.

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

int* ip;

А указатель типа float объявляется так, как показано ниже.

float* fp;

Вообще говоря, если в операторе объявления после имени типа следует знак *, то это означает, что создается переменная типа указателя.

Тип данных, на которые будет указывать сам указатель, зависит от его соотносимого типа. Поэтому в приведенных выше примерах переменная ip может служить для указания на значение типа int, а переменная fp — для указания на значение типа float. Следует, однако, иметь в виду, что указателю ничто не мешает указывать на что угодно. Именно поэтому указатели потенциально небезопасны.

Если у вас есть опыт программирования на C/C++, то вы должны ясно понимать главное отличие в объявлении указателей в C# и C/C++. При объявлении указателя в C/C++ знак * не разделяет список переменных в объявлении. Поэтому в следующей строке кода:

int* р, q;

объявляется указатель р типа int и переменная q типа int. Это равнозначно двум следующим объявлениям.

int* р;

int q;

А в C# знак * является разделительным, и поэтому в объявлении

int* р, q;

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

int* р;

int* q;

Это главное отличие следует иметь в виду при переносе кода C/C++ на С#.

Операторы * и & в указателях

В указателях применяются два оператора: * и &. Оператор & является унарным и возвращает адрес памяти своего операнда. (Напомним, что для унарного оператора требуется единственный операнд.) Например, в следующем фрагменте кода:

int* ip;

int num = 10;

ip = #

в переменной ip сохраняется адрес памяти переменной num. Это адрес расположения переменной num в оперативной памяти компьютера. Он не имеет никакого отношения к значению переменной num. Поэтому в переменной ip содержится не значение 10, являющееся исходным для переменной num, а конкретный адрес, по которому эта переменная хранится в оперативной памяти. Операцию & можно рассматривать как возврат адреса той переменной, перед которой она указывается. Таким образом, приведенное выше присваивание словами можно описать так: "Переменная ip получает адрес переменной num."

Второй оператор, *, является дополнением оператора &. Этот унарный оператор находит значение переменной, расположенной по адресу, на который указывает его операнд. Следовательно, этот оператор обращается к значению переменной, на которую указывает соответствующий указатель. Так, если переменная ip содержит адрес памяти переменной num, как показано в предыдущем примере, то в следующей строке кода:

int val = *ip;

в переменной val сохраняется значение 10 переменной num, на которую указывает переменная ip. Операцию * можно рассматривать как получение значения по адресу. Поэтому приведенный выше оператор присваивания описывается словами следующим образом: "Переменная val получает значение по адресу, хранящемуся в переменной ip."

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

*ip = 100;

В данном примере значение 100 присваивается переменной, на которую указывает переменная ip, т.е. переменной num. Поэтому приведенный выше оператор присваивания описывается словами следующим образом: "Разместить значение 100 по адресу, хранящемуся в переменной ip."

Применение ключевого слова unsafe

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

// Продемонстрировать применение указателей и ключевого слова unsafe.

using System;

class UnsafeCode {

  // Пометить метод Main() как небезопасный,

  unsafe static void Main() {

    int count = 99;

    int* p; // создать указатель типа int

    p = &count; // поместить адрес переменной count в переменной р

    Console.WriteLine("Исходное значение переменной count: " + *p);

    *p = 10; // присвоить значение 10 переменной count,

    // на которую указывает переменная р

    Console.WriteLine("Новое значение переменной count: " + *p);

  }

}

Эта программа дает следующий результат.

Исходное значение переменной count: 99

Новое значение переменной count: 10

Применение модификатора fixed

В работе с указателями нередко используется модификатор fixed, который препятствует удалению управляемой переменной средствами "сборки мусора". Потребность в этом возникает, например, в том случае, если указатель обращается к полю в объекте определенного класса. А поскольку указателю ничего не известно о действиях системы "сборки мусора", то он будет указывать не на тот объект, если удалить нужный объект. Ниже приведена общая форма модификатора fixed:

fixed (тип* р = &фиксированный_объект) {

// использовать фиксированный объект

}

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

Ниже приведен пример применения модификатора fixed.

// Продемонстрировать применение оператора fixed.

using System;

class Test {

  public int num;

  public Test(int i) {

    num = i;

  }

}

class FixedCode {

  // Пометить метод Main() как небезопасный,

  unsafe static void Main() {

    Test o = new Test(19);

    fixed (int* p = &o.num) {