В языке C# указатели объявляются и используются таким же образом, как и в C/C++. Если вы знаете, как пользоваться ими в C/C++, то вам нетрудно будет сделать это и в С#. Но не забывайте, что главное назначение C# — создание управляемого кода. А спо собность этого языка программирования поддерживать неуправляемый код следует использовать для решения лишь особого рода задач. Это, скорее, исключение, чем правило для программирования на С#. По существу, для компилирования неуправ ляемого кода следует использовать параметр компилятора /unsafe.
Указатели составляют основу небезопасного кода, поэтому мы начнем его рассмо трение именно с них. Основы применения указателей
Указатель представляет собой переменную, хранящую адрес какого-нибудь другого объекта, например другой переменной. Так, если в переменной х хранится адрес пере менной у, то говорят, что переменная х указывает на переменную у. Когда указатель указывает на переменную, то значение этой переменной может быть получено или изменено по указателю. Такие операции с указателями называют непрямой адресацией. Объявление указателя
Переменные-указатели должны быть объявлены как таковые. Ниже приведена об щая форма объявления переменной-указателя: тип* имя_переменной;
где тип обозначает соотносимый тип, который не должен быть ссылочным. Это озна чает, что в C# нельзя объявить указатель на объект определенного класса. Соотноси мый тип указателя иногда еще называют базовым. Обратите внимание на положение знака * в объявлении указателя. Он должен следовать после наименования типа. А имя_переменной обозначает конкретное имя указателя-переменной.
Обратимся к конкретному примеру. Для того чтобы сделать переменную ip указа телем на значение типа int, необходимо объявить ее следующим образом. int* ip;
А указатель типа float объявляется так, как показано ниже. float* fp;
Вообще говоря, если в операторе объявления после имени типа следует знак *, то это означает, что создается переменная типа указателя.
Тип данных, на которые будет указывать сам указатель, зависит от его соотносимого типа. Поэтому в приведенных выше примерах переменная ip может служить для ука зания на значение типа int, а переменная fp — для указания на значение типа float. Следует, однако, иметь в виду, что указателю ничто не мешает указывать на что угодно. Именно поэтому указатели потенциально небезопасны.
Если у вас есть опыт программирования на С/С++, то вы должны ясно понимать главное отличие в объявлении указателей в 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: " + *р); *р = 10; // присвоить значение 10 переменной count, // на которую указывает переменная р Console.WriteLine("Новое значение переменной count: " + *р); } }
Эта программа дает следующий результат. Исходное значение переменной 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 о = new Test(19); fixed (int* p = &o.num) { // использовать модификатор fixed для размещения // адреса переменной экземпляр о.num в переменной р Console.WriteLine("Исходное значение переменной о.num: " + *р); *р = 10; // присвоить значение 10 переменной count, // на которую указывает переменная р Console.WriteLine("Новое значение переменной о.num: " + *р); } } }
Вот к какому результату приводит выполнение этой программы. Исходное значение переменной о.num: 19 Новое значение переменной о.num: 10
В данном примере модификатор fixed препятствует удалению объекта о. А по скольку переменная р указывает на переменную экземпляра о.num, то она будет ука зывать на недостоверную область памяти, если удалить объект о. Доступ к членам структуры с помощью указателя
Указатель может указывать на объект типа структуры при условии, что структура не содержит ссылочные типы данных. Для доступа к члену структуры с помощью ука зателя следует использовать оператор-стрелку (->), а не оператор-точку (.). Напри мер, доступ к членам структуры struct MyStruct { public int a; public int b; public int Sum() { return a + b; } }
осуществляется следующим образом. MyStruct о = new MyStruct(); MyStruct* p; // объявить указатель p = &o; p->a = 10; // использовать оператор -> p->b = 20; // использовать оператор -> Console.WriteLine("Сумма равна " + p->Sum()); Арифметические операции над указателями
Над указателями можно выполнять только четыре арифметические операции: ++, --, + и -. Для того чтобы стало понятнее, что именно происходит в арифметических операциях над указателями, рассмотрим сначала простой пример. Допустим, что пе ременная p1 является указателем с текущим значением 2000, т.е. она содержит адрес