Применение ключевого слова 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) {
Использовать модификатор fixed для размещения
Адреса переменной экземпляр о.num в переменной р
Console.WriteLine("Исходное значение переменной о.num: " + *p);
*p = 10; // присвоить значение 10 переменной count,
|
|
|
На которую указывает переменная р
Console.WriteLine("Новое значение переменной о.num: " + *p);
}
}
}
Вот к какому результату приводит выполнение этой программы.
Исходное значение переменной о.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, т.е. она содержит адрес 2000. После выполнения выражения
|
|
|
p1++;
переменная p1 будет содержать значение 2004, а не 2001! Дело в том, что после каждого инкрементирования переменная p1 указывает на следующее значение типа int. А поскольку тип int представлен в C# 4 байтами, то в результате инкрементирования значение переменной p1 увеличивается на 4. Справедливо и обратное: при каждом декрементировании переменной p1 ее значение уменьшается на 4. Например выражение
p1--;
приводит к тому, что значение переменной p1 становится равным 1996, если раньше оно было равно 2000!
Все сказанное выше можно обобщить: после каждого инкрементирования указатель будет указывать на область памяти, где хранится следующий элемент его соотносимого типа, а после каждого декрементирования указатель будет указывать на область памяти, где хранится предыдущий элемент его соотносимого типа.
Арифметические операции над указателями не ограничиваются только инкрементированием и декрементированием. К указателям можно добавлять и вычитать из них целые значения. Так, после вычисления следующего выражения:
|
|
|
p1 = p1 + 9;
переменная p1 будет указывать на девятый элемент ее соотносимого типа по отношению к элементу, на который она указывает в настоящий момент.
Если складывать указатели нельзя, то разрешается вычитать один указатель из другого, при условии, что оба указателя имеют один и тот же соотносимый тип. Результатом такой операции окажется количество элементов соотносимого типа, которые разделяют оба указателя.
Кроме сложения и вычитания целого числа из указателя, а также вычитания двух указателей, другие арифметические операции над указателями не разрешаются. В частности, к указателям нельзя добавлять или вычитать из них значения типа float или double. Не допускаются также арифметические операции над указателями типа void*.
Для того чтобы проверить на практике результаты арифметических операций над указателями, выполните приведенную ниже короткую программу, где выводятся физические адреса, на которые указывает целочисленный указатель (ip) и указатель с плавающей точкой одинарной точности (fp). Понаблюдайте за изменениями каждого из этих указателей по отношению к их соотносимым типам на каждом шаге цикла.
// Продемонстрировать результаты арифметических операций над указателями.
using System;
class PtrArithDemo {
unsafe static void Main() {
int x;
int i;
double d;
int* ip = &i;
double* fp = &d;
Console.WriteLine("int double\n");
for(x=0; x < 10; x++) {
Console.WriteLine((uint) (ip) + " " + (uint) (fp));
ip++;
fp++;
}
}
}
Ниже приведен примерный результат выполнения данной программы. У вас он может оказаться иным, хотя промежутки между выводимыми значения должны быть такими же самыми.
Int double
1243464 1243468
1243468 1243476
1243472 1243484
1243476 1243492
1243480 1243500
1243484 1243508
1243488 1243516
1243492 1243524
1243496 1243532
1243500 1243540
Как следует из приведенного выше результата, арифметические операции выполняются над указателями относительно их соотносимого типа. Так, значения типа int занимают в памяти 4 байта, а значения типа double — 8 байтов, и поэтому их адреса изменяются с приращением именно на эти величины.
Сравнение указателей
Указатели можно сравнивать с помощью таких операторов отношения, как ==, < и >. Но для того чтобы результат сравнения указателей оказался содержательным, оба указателя должны быть каким-то образом связаны друг с другом. Так, если переменные p1 и р2 являются указателями на две разные и не связанные вместе переменные, то любое их сравнение, как правило, не имеет никакого смысла. Но если переменные p1 и р2 указывают на связанные вместе переменные, например на элементы одного массива, то их сравнение может иметь определенный смысл.
Указатели и массивы
В C# указатели и массивы связаны друг с другом. Например, при указании имени массива без индекса в операторе с модификатором fixed формируется указатель на начало массива. В качестве примера рассмотрим следующую программу.
/* Указание имени массива без индекса приводит к формированию указателя на начало массива. */
using System;
class PtrArray {
unsafe static void Main() {
int[] nums = new int[10];
fixed(int* p = &nums[0], p2 = nums) {
if(p == p2)
Console.WriteLine("Указатели p и p2 содержат " +
"один и тот же адрес.");
}
}
}
Ниже приведен результат выполнения этой программы.
Дата добавления: 2019-02-12; просмотров: 505; Мы поможем в написании вашей работы! |
Мы поможем в написании ваших работ!