программирование. Руководство su P# a n Reference в herbert schildt полное руководство с 0 герберт шилдт
 Скачать 3.32 Mb.
|
|
ГЛАВА 20 Небезопасный код, указатели, обнуляемые типы и разные ключевые слова В этой главе рассматривается средство языка С#, которое обычно захватывает программистов врасплох. Это небезопасный код. В таком коде зачастую используются указатели. Совместно с небезопасным кодом указатели позволяют разрабатывать на C# приложения, которые обычно связываются с языком C++, высокой производительностью и системным кодом. Более того, благодаря включению небезопасного кода и указателей в состав C# в этом языке появились возможности, которые отсутствуют в Java. В этой главе рассматриваются также обнуляемые типы, определения частичных классов и методов, буферы фиксированного размера. И в заключение этой главы представлен ряд ключевых слов, не упоминавшихся в предыдущих главах. Небезопасный код В C# разрешается писать так называемый "небезопасный" код. В этом странном на первый взгляд утверждении нет на самом деле ничего необычного. Небезопасным считается не плохо написанный код, а такой код, который не может быть выполнен под полным управлением в общеязыковой исполняющей среде (CLR). Как пояснялось в главе 1, результатом программирования на C# обычно является управляемый код. Тем не менее этот язык программирования допускает написание кода, который не выполняется под полным управлением в среде CLR. Такой неуправляемый код не подчиняется тем же самым средствам управления и ограничениям, что и управляемый код, и называется он небезопасным потому, что нельзя никак проверить, не выполняет ли он какое‑нибудь опасное действие. Следовательно, термин небезопасный совсем не означает, что коду присущи какие‑то изъяны. Это просто означает, что код может выполнять действия, которые не подлежат контролю в управляемой среде. Если небезопасный код может вызвать осложнения, то зачем вообще создавать такой код? Дело в том, что управляемый код не позволяет использовать указатели. Если у вас имеется некоторый опыт программирования на С или C++, то вам должно быть известно, что указатели представляют собой переменные, предназначенные для хранения адресов других объектов, т.е. они в какой‑то степени похожи на ссылки в С#. Главное отличие указателя заключается в том, что он мпжет указывать на любую область памяти, тогда как ссылка всегда указывает на объект своего типа. Но поскольку указатель способен указывать практически на любую область памяти, то существует большая вероятность его неправильного использования. Кроме того, используя указатели, легко допустить программные ошибки. Именно поэтому указатели не поддерживаются при создании управляемого кода в С#. А поскольку указатели все‑таки полезны и необходимы для некоторых видов программирования (например, утилит системного уровня), в C# разрешается создавать и использовать их. Но при этом все операции с указателями должны быть помечены как небезопасные, потому что они выполняются вне управляемой среды. В языке C# указатели объявляются и используются таким же образом, как и в С/С‑н‑. Если вы знаете, как пользоваться ими в С/С‑н‑, то вам нетрудно будет сделать это и в С#. Но не забывайте, что главное назначение C# – создание управляемого кода. А способность этого языка программирования поддерживать неуправляемый код следует использовать для решения лишь особого рода задач. Это, скорее, исключение, чем правило для программирования на С#. По существу, для компилирования неуправляемого кода следует использовать параметр компилятора /unsafe. Указатели составляют основу небезопасного кода, поэтому мы начнем его рассмотрение именно с них. Основы применения указателей Указатель представляет собой переменную, хранящую адрес какого‑нибудь другого объекта, например другой переменной. Так, если в переменной х хранится адрес переменной у, то говорят, что переменная х указывает на переменную у. Когда указатель указывает на переменную, то значение этой переменной может быть получено или изменено по указателю. Такие операции с указателями называют непрямой адресацией. Объявление указателя Переменные‑указатели должны быть объявлены как таковые. Ниже приведена общая форма объявления переменной‑указателя: тип * имя_переменной ; где тип обозначает соотносимый тип, который не должен быть ссылочным. Это означает, что в 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: " + *р) ; *р = 10; // присвоить значение 10 переменной count, // на которую указывает переменная р Console.WriteLine("Новое значение переменной count: " + *р); Эта программа дает следующий результат. Исходное значение переменной count: 99 Новое значение переменной count: 10 Применение модификатора fixed В работе с указателями нередко используется модификатор fixed, который препятствует удалению управляемой переменной средствами "сборки мусора'7. Потребность в этом возникает, например, в том случае, если указатель обращается к полю в объекте определенного класса. А поскольку указателю ничего не известно о действиях системы "сборки мусора", то он будет указывать не на тот объект, если удалить нужный объект. Ниже приведена общая форма модификатора 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()); Арифметические операции над указателями Над указателями можно выполнять только четыре арифметические операции: ++, –, + и ‑. Для того чтобы стало понятнее, что именно происходит в арифметических операциях над указателями, рассмотрим сначала простой пример. Допустим, что переменная pi является указателем с текущим значением 2000, т.е. она содержит адрес 2000. После выполнения выражения pl++; переменная pi будет содержать значение 2004, а не 2001! Дело в том, что после каждого инкрементирования переменная pi указывает на следующее значение типа int. А поскольку тип int представлен в C# 4 байтами, то в результате инкрементирования значение переменной pi увеличивается на 4. Справедливо и обратное: при каждом декрементировании переменной pi ее значение уменьшается на 4. Например выражение pl–; приводит к тому, что значение переменной pl становится равным 1996, если раньше оно было равно 2000! Все сказанное выше можно обобщить: после каждого инкрементирования указатель будет указывать на область памяти, где хранится следующий элемент его соотносимого типа, а после каждого декрементирования указатель будет указывать на область памяти, где хранится предыдущий элемент его соотносимого типа. Арифметические операции над указателями не ограничиваются только инкрементированием и декрементированием. К указателям можно добавлять и вычитать из них целые значения. Так, после вычисления следующего выражения: pi = pi + 9; , переменная pi будет указывать на девятый элемент ее соотносимого типа по отношению к элементу, на который она указывает в настоящий момент. Если складывать указатели нельзя, то разрешается вычитать один указатель из другого, при условии, что оба указателя имеют один и тот же соотносимый тип. Результатом такой операции окажется количество элементов соотносимого типа, которые разделяют оба указателя. Кроме сложения и вычитания целого числа из указателя, а также вычитания двух указателей, другие арифметические операции над указателями не разрешаются. В частности, к указателям нельзя добавлять или вычитать из них значения типа 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 байтов, и поэтому их адреса изменяются с приращением именно на эти величины. Сравнение указателей Указатели можно сравнивать с помощью таких операторов отношения, как ==, < и >. Но для того чтобы результат сравнения указателей оказался содержательным, оба указателя должны быть каким‑то образом связаны друг с другом. Так, если переменные pi и р 2 являются указателями на две разные и не связанные вместе переменные, то любое их сравнение, как правило, не имеет никакого смысла. Но если переменные pi и р 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 содержат " + "один и тот же адрес."); } } } Ниже приведен результат выполнения этой программы. Указатели р и р2 содержат один и тот же адрес Как следует из приведенного выше результата, выражения &nums[0] И nums оказываются одинаковыми. Но поскольку вторая форма более лаконична, то она чаще используется в программировании, когда требуется указатель на начало массива. Индексирование указателей Когда указатель обращается к массиву, его можно индексировать как сам массив. Такой синтаксис служит более удобной в некоторых случаях альтернативой арифметическим операциям над указателями. Рассмотрим следующий пример программы. // Проиндексировать указатель как массив. using System; class PtrlndexDemo { unsafe static void Main() { int[] nums = new int [10]; // Проиндексировать указатель. Console.WriteLine("Индексирование указателя как массива."); fixed (int* p = nums) { for(int i=0; i < 10; i++) p[i] = i; // индексировать указатель как массив forjint i=0; i < 10; i++) Console.WriteLine("p[{0}]: {1} ", i, p[i]); } // Использовать арифметические операции над указателями. Console.WriteLine("ХпПрименение арифметических " + "операций над указателями."); fixed (int* р = nums) { for(int i=0; i < 10; i++) * (p+i) = i; // использовать арифметическую операцию над указателем for(int i=0; i < 10; i++) Console.WriteLine("*(p+{0}): {1} ", i, *(p+i)); } } } Ниже приведен результат выполнения этой программы. Индексирование указателя как массива. Р[9] : 9 Применение арифметических операций над указателями. *(р+0) : 0 *(P+1) : 1 *(р+2) : 2 *(р+3) : 3 *(р+4) : 4 * (р+5) : 5 * (р+6) : 6 * (р+7) : 7 *(р+8): 8 * (р+9) : 9 Как следует из результата выполнения приведенной выше программы, общая форма выражения с указателем * (ptr + i) может быть заменена следующим синтаксисом индексирования массива. ptr[i] Что касается индексирования указателей, то необходимо иметь в виду следующее. Во‑первых, при таком индексировании контроль границ массива не осуществляется. Поэтому указатель может обращаться к элементу вне границ массива. И во‑вторых, для указателя не предусмотрено свойство Length, определяющее длину массива. Поэтому, если используется указатель, длина массива зарайее неизвестна. Указатели и строки Символьные строки реализованы в C# в вид^объектов. Тем не менее отдельные символы в строке могут быть доступны по указателю. Для этого указателю типа char* присваивается адрес начала символьной строки в следующем операторе с модификатором fixed. fixed(char* р = str) { // ... После выполнения оператора с модификатором fixed переменная р будет указывать на начало массива символов, составляющих строку. Этот массив оканчивается символом конца строки, т.е. нулевым символом. Поэтому данное обстоятельство можно использовать для проверки конца массива. В C/C++ строки реализуются в виде массивов, оканчивающихся символом конца строки, а следовательно, получив указатель типа char* на строку, ею можно манипулировать таким же образом, как и в C/C++. Ниже приведена программа, демонстрирующая доступ к символьной строке по указателю типа char*. // Использовать модификатор fixed для получения // указателя на начало строки. using System; class FixedString { unsafe static void Main() { string str = "это тест"; // Получить указатель р на начало строки str. fixed(char* р = str) { // Вывести содержимое строки str по указателю р. for(int i=0; p[i] != 0; i++) Console.Write(p[i]); Console.WriteLine(); } } Эта программа дает следующий результат. это тест Многоуровневая непрямая адресация Один указатель может указывать на другой, а тот, свою очередь, – на целевое значение. Это так называемая многоуровневая непрямая адресация , или применение указателей на указатели. Такое применение указателей может показаться, на первый взгляд, запутанным. Для прояснения принципа многоуровневой непрямой адресации обратимся за помощью к рис. 20.1. Как видите, значением обычного указателя является адрес переменной, содержащей требуемое значение. Если же применяется указатель на указатель, то первый из них содержит адрес второго, указывающего на переменную, содержащую требуемое значение. Указатель Переменная адрес ‑► значение Одноуровневая непрямая адресация Указатель Указатель Переменная адрес ‑► адрес ‑► значение Многоуровневая непрямая адресация Рис. 20.1. Одно‑ и многоуровневая непрямая адресация Многоуровневая непрямая адресация может быть продолжена до любого предела, но потребность более чем в двух уровнях адресации по указателям возникает крайне редко. На самом деле чрезмерная непрямая адресация очень трудно прослеживается и чревата ошибками. Переменная, являющаяся указателем на указатель, должна быть объявлена как таковая. Для этого достаточно указать дополнительный знак * после имени типа переменной. Например, в следующем объявлении компилятор уведомляется о том, что переменная q является указателем на указатель и относится к типу int. int** q; Следует, однако, иметь в виду, что переменная q является указателем не на целое значение, а на указатель типа int. Для доступа к целевому значению, косвенно адресуемому по указателю на указатель, следует дважды применить оператор *, как в приведенном ниже примере. using System; class Multiplelndirect { unsafe static void Main() { int x; // содержит значение типа int int* p; // содержит указатель типа int int** q; // содержит указатель на указатель типа int х = 10; р = &х; // поместить адрес переменной х в переменной р q = &р; // поместить адрес переменной р в переменной q Console.WriteLine(**q); // вывести значение переменной х } } Результатом выполнения этой программы будет выведенное на экран значение 10 переменной х. В данной программе переменная р объявляется как указатель на значение типа int, а переменная q – как указатель на указатель типа int. И последнее замечание: не путайте многоуровневую непрямую адресацию со структурами данных высокого уровня, в том числе связными списками, так как это совершенно разные понятия. Массивы указателей Указатели могут быть организованы в массивы, как и любой другой тип данных. Ниже приведен пример объявления массива указателей типа int длиной в три элемента. int * [] ptrs = new int * [3]; Для того чтобы присвоить адрес переменной var типа int третьему элементу массива указателей, достаточно написать следующую строку кода. ptrs[2] = &var; А для того чтобы обнаружить значение переменной var, достаточно написать приведенную ниже строку кода. *ptrs[2] Оператор sizeof Во время работы с небезопасным кодом иногда полезно знать размер в байтах одного из встроенных в C# типов значений. Для получения этой информации служит оператор sizeof. Ниже приведена его общая форма: sizeof (тип) где тип обозначает тот тип, размер которого требуется получить. Вообще говоря, оператор sizeof предназначен главным образом для особых случаев и, в частности, для работы со смешанным кодом: управляемым и неуправляемым. Оператор stackalloc Для распределения памяти, выделенной под стек, служит оператор stackalloc. Им можно пользоваться лишь при инициализации локальных переменных. Ниже приведена общая форма этого оператора: тип *р = stackalloc тип [размер] где р обозначает указатель, получающий адрес области памяти, достаточной для хранения объектов, имеющих указанный тип, в количестве, которое обозначает размер. Если же в стеке недостаточно места для распределения памяти, то генерируется исключение System. StackOverflowException. И наконец, оператор stackalloc можно использовать только в небезопасном коде. Как правило, память для объектов выделяется из кучи – динамически распределяемой свободной области памяти. А выделение памяти из стека является исключением. Ведь переменные, располагаемые в стеке, не удаляются средствами "сборки мусора", а существуют только в течение времени выполнения метода, в котором они объявляются. После возврата из метода выделенная память освобождается. Преимущество применения оператора stackalloc заключается, в частности, в том, что в этом случае не нужно беспокоиться об очистке памяти средствами "сборки мусора". Ниже приведен пример применения оператора stackalloc* // Продемонстрировать применение оператора stackalloc. using System; class UseStackAlloc { unsafe static void Main() { int* ptrs = stackalloc int[3]; ptrs[0] = 1; ptrs[1] = 2; ptrs[2] = 3; for(int i=0; i < 3; i++) Console.WriteLine(ptrs[i]); } } Вот к какому результату приводит выполнение кода из данного примера. 1 2 3 Создание буферов фиксированного размера Ключевое слово fixed находит еще одно применение при создании одномерных массивов фиксированного размера. В документации на C# такие массивы называются буферами фиксированного размера. Такие буферы всегда являются членами структуры. Они предназначены для создания структуры, в которой содержатся элементы массива, образующйе буфер. Когда элемент массива включается в состав структуры, в ней, как правило, хранится лишь ссылка на этот массив. Используя буфер фиксированного размера, в структуре можно разместить весь массив. В итоге получается структура, пригодная в тех случаях, когда'важен ее размер, как, например, в многоязыковом программировании, при согласовании данных, созданных вне программы на С#, или же когда требуется неуправляемая структура, содержащая массив. Но буферы фиксированного размера можно использовать только в небезопасном коде. Для создания буфера фиксированного размера служит следующая общая форма: fixed тип имя_буфера[размер ]; где тип обозначает тип данных массива; имя_буфера – конкретное имя буфера фиксированного размера; размер – количество элементов, образующих буфер. Буферы фиксированного размера могут указываться только в структуре. Для того чтобы стала очевиднее польза от буферов фиксированного размера, рассмотрим ситуацию, в которой программе ведения счетов, написанной на C++, требуется передать информацию о банковском счете. Допустим также, что учетная запись каждого счета организована так, как показано ниже. Name Строка длиной 80 байтов, состоящая из 8‑разрядных символов в коде ASCII Balance Числовое значение типа double длиной 8 байтов ID Числовое значение типа long длиной 8 байтов В программе на C++ каждая структура содержит массив Name, тогда как в программе на C# в такой структуре хранится лишь ссылка на массив. Поэтому для правильного представления данных из этой структуры в C# требуется буфер фиксированного размера, как показано ниже. // Использовать буфер фиксированного‑размера. unsafe struct FixedBankRecord { public fixed byte Name[80]; // создать буфер фиксированного размера public double Balance; public long ID; } Когда буфер фиксированного размера используется вместо массива Name, каждый экземпляр структуры FixedBankRecord будет содержать все 80 байтов массива Name. Именно таким образом структура и организована в программе на C++. Следовательно, общий размер структуры FixedBankRecord окажется равным 96, т.е. сумме ее членов. Ниже приведена программа, демонстрирующая этот факт. // Продемонстрировать применение буфера фиксированного размера, using System; // Создать буфер фиксированного размера, unsafe struct FixedBankRecord { public fixed byte Name[80]; public double Balance; public long ID; } class FixedSizeBuffer { // Пометить метод Main() как небезопасный, unsafe static void Main() { Console.WriteLine("Размер структуры FixedBankRecord: " + sizeof(FixedBankRecord)); } } Эта программа дает следующий результат. Размер структуры FixedBankRecord: 96 Размер структуры FixedBankRecord оказывается в точности равным сумме ее членов, но так бывает далеко не всегда со структурами, содержащими буферы фиксированного размера. Ради повышения эффективности кода общая длина структуры может быть увеличена для выравнивания по четной границе, например по границе слова. Поэтому общая длина структуры может оказаться на несколько байтов больше, чем сумма ее членов, даже если в ней содержатся буферы фиксированного размера. Как правило, аналогичное выравнивание длины структуры происходит и в C++. Следует, однако, иметь в виду возможные отличия в этом отношении. И наконец, обратите внимание на то, как в данной программе создается буфер фиксированного размера вместо массива Name. public fixed byte Name[80]; // создать буфер фиксированного размера Как видите, размер массива указывается после его имени. Такое обозначение обычно принято в C++ и отличается в объявлениях массивов в С#. В данном операторе распределяется по 80 байтов памяти в пределах каждого объекта типа FixedBankRecord. Обнуляемые типы Начиная с версии 2.0, в C# внедрено средство, обеспечивающее изящное решение типичной и не очень приятной задачи распознавания и обработки полей, не содержащих значения, т.е. неинициализированных полей. Это средство называется обнуляемым типом. Для того чтобы стала более понятной суть данной задачи, рассмотрим пример простой базы данных заказчиков, в которой хранится запись с именем, адресом, идентификационным номером заказчика, номером счета‑фактуры и текущим остатком на счету. В подобной ситуации может быть вполне создан элемент данных заказчика, вко‑тором одно или несколько полей не инициализированы. Например, заказчик может просто запросить каталог продукции, и в этом случае номер счета‑фактуры не потребуется, а значит, его поле окажется неиспользованным. Раньше для обработки неиспользуемых полей приходилось применять заполняющие значения или дополнительные поля, которые просто указывали, используется поле или нет. Безусловно, заполняющие значения пригодны лишь в том случае, если они подставляются вместо значения, которое в противном случае окажется недействительным, но так бывает далеко не всегда. А дополнительные поля, указывающие, используется поле или нет, пригодны во всех случаях, но их ввод и обработка вручную доставляют немало хлопот. Оба эти затруднения позволяет преодолеть обнуляемый тип. Основы применения обнуляемых типов Обнуляемый тип – это особый вариант типа значения, представленный структурой. Помимо значений, определяемых базовым типом, обнуляемый тип позволяет хранить пустые значения (null). Следовательно, обнуляемый тип имеет такой же диапазон представления чисел и характеристики, как и его базовый тип. Он предоставляет дополнительную возможность обозначить значение, указывающее на то, что переменная данного типа не инициализирована. Обнуляемые типы являются объектами типа System. Nullable ПРИМЕЧАНИЕ Обнуляемые эквиваленты могут быть только у типов значений. Обнуляемый тип может быть указан двумя способами. Во‑первых, объекты типа Nullable System.Nullable System.Nullable И во‑вторых, обнуляемый тип объявляется более кратким и поэтому чаще используемым способом с указанием знака ? после имени базового типа. В приведенном ниже примере демонстрируется более распространенный способ объявления обнуляемых переменных типа int и bool. int? count; bool? done; Когда в коде применяются обнуляемые типы, создаваемый обнуляемый объект обычно выглядит следующим образом. int? count = null; В данной строке кода переменная count явно инициализируется пустым значением (null). Это вполне соответствует принятому правилу: прежде чем использовать переменную, ей нужно присвоить значение. В данном случае присваиваемое значение означает, что переменная не определена. Значение может быть присвоено обнуляемой переменной обычным образом, поскольку преобразование базового типа в обнуляемый определено заранее. Например, в следующей строке кода переменной count присваивается значение 100. count = 100; Определить, имеет переменная обнуляемого типа пустое или конкретное значение, можно двумя способами. Во‑первых, можно проверить переменную на пустое значение. Так, если переменная count объявлена так, как показано выше, то в следующей строке определяется, имеет ли эта переменная конкретное значение. if (count != null) // переменная имеет значение Если переменная count не является пустой, то она содержит конкретное значение. И во‑вторых, можно воспользоваться доступным только для чтения свойством HasValue типа Nullable bool HasValue Свойство HasValue возвращает логическое значение true, если экземпляр объекта, для которого оно вызывается, содержит конкретное значение, а иначе оно возвращает логическое значение false. Ниже приведен пример, в котором конкретное значение обнуляемого объекта count определяется вторым способом с помощью свойства HasValue. if(count.HasValue) // переменная имеет значение Если обнуляемый объект содержит конкретное значение, то получить это значение можно с помощью доступного только для чтения свойства Value типа Nullable Т Value Свойство Value возвращает экземпляр обнуляемого объекта, для которого оно вызывается. Если же попытаться получить с помощью этого свойства значение пустой переменной, то в итоге будет сгенерировано исключение System. InvalidOperationException. Кроме того, значение экземпляра обнуляемого объекта можно получить путем приведения к его базовому типу. В следующей программе демонстрируется основной механизм обращения с обнуляемым типом. // Продемонстрировать применение обнуляемого типа. using System; class NullableDemo { static void Main() { int? count = null; if (count.HasValue) Console.WriteLine("Переменная count имеет следующее значение: " + count.Value); else Console.WriteLine("У переменной count отсутствует значение"); count = 100; if(count.HasValue) Console.WriteLine("Переменная count имеет следующее значение: " + count. Va^lue) ; else Console.WriteLine("У переменной count отсутствует значение"); } } Вот к какому результату приводит выполнение этой программы. У переменной count отсутствует значение Переменная count имеет следующее значение: 100 Применение обнуляемых объектов в выражениях Обнуляемый объект может использоваться в тех выражениях, которые являются действительными для его базового типа. Более того, обнуляемые объекты могут сочетаться с необнуляемыми объектами в одном выражении. И это вполне допустимо благодаря предопределенному преобразованию базового типа в обнуляемый. Когда обнуляемые и необнуляемые типы сочетаются в одной операции, ее результатом становится значение обнуляемого типа. В приведенной ниже программе демонстрируется применение обнуляемых типов в выражениях. // Использовать обнуляемые объекты в выражениях. using System; class NullableDemo { static void Main() { int? count = null; int? result = null; int incr = 10; // переменная incr не является обнуляемой // переменная result содержит пустое значение, // переменная оказывается count пустой, result = count + incr; if(result.HasValue) Console.WriteLine("Переменная result имеет следующее значение: " + result.Value); else Console.WriteLine("У переменной result отсутствует значение"); // Теперь переменная count получает свое‘значение, и поэтому // переменная result будет содержать конкретное значение. count = 100; result = count + incr; if(result.HasValue) Console.WriteLine("Переменная result имеет следующее значение: " + result.Value); else Console.WriteLine("У переменной result отсутствует значение"); } } При выполнении этой программы получается следующий результат. У переменной result отсутствует значение Переменная result имеет следующее значение: 110 Оператор ?? Попытка преобразовать обнуляемый объект в его базовый тип путем приведения типов обычно приводит к генерированию исключения System. InvalidOperationException, если обнуляемый объект содержит пустое значение. Это может произойти, например, в том случае, если значение обнуляемого объекта присваивается переменной его базового типа с помощью приведения типов. Появления данного исключения можно избежать, если воспользоваться оператором ? ?, называемым нулеобъединяющим оператором. Этот оператор позволяет указать значение, которое будет использоваться по умолчанию, если обнуляемый объект содержит пустое значение. Он также исключает потребность в приведении типов. Ниже приведена общая форма оператора ??. обнуляемый_объект ?? значение_по_умолчанию Если обнуляемый_объект содержит конкретное значение, то результатом операции ? ? будет именно это значение. В противном случае результатом операции ? ? окажется значение_по_умолчанию. Например, в приведенном ниже фрагменте кода переменная balance содержит пустое значение. Вследствие этого переменной currentBalance присваивается значение 0 . 0, используемое по умолчанию, и тем самым устраняется причина для генерирования исключения. double? balance = null; double currentBalance; currentBalance = balance ?? 0.0; В следующем фрагменте кода переменной balance присваивается значение 123.75. double? balance = 123.75; double currentBalance; currentBalance = balance ?? 0.0; Теперь переменная currentBalance содержит значение 123.75 переменной balance. И еще одно замечание: выражение в правой части оператора ? ? вычисляется только в том случае, если выражение в левой его части не содержит значение. Этот факт демонстрируется в приведенной ниже программе. // Применение оператора ?? using System; class NullableDemo2 { // Возвратить нулевой остаток, static double GetZeroBalO { Console. WriteLine ("В методе GetZeroBalO."); return 0.0; } static void Main() { double? balance = 123.75; double currentBalance; // Здесь метод GetZeroBalO не вызывается, поскольку // переменная balance содержит конкретное значение. currentBalance = balance ?? GetZeroBalO; Console.WriteLine(currentBalance); } } В этой программе метод GetZeroBal () не вызывается, поскольку переменная balance содержит конкретное значение. Как пояснялось выше, если выражение в левой части оператора ? ? содержит конкретное значение, то выражение в правой его части не вычисляется. Обнуляемые объекты, операторы отношения и логические операторы Обнуляемые объекты могут использоваться в выражениях отношения таким же образом, как и соответствующие объекты необнуляемого типа. Но они должны подчиняться следующему дополнительному правилу: когда два обнуляемых объекта сравниваются в операциях сравнения <, >, <= или >=, то их результат будет ложным, если любой из обнуляемых объектов оказывается пустым, т.е. содержит значение null. В качестве примера рассмотрим следующий фрагмент кода. byte? lower = 16; byte? upper = null; // Здесь переменная lower определена, а переменная upper не определена, if(lower < upper) // ложно % В данном случае проверка того, что значение одной переменой меньше значения другой, дает ложный результат. Хотя это и не совсем очевидно, как, впрочем, и следующая проверка противоположного характера. if(lower > upper) // .. также ложно! Следовательно, если один или оба сравниваемых обнуляемых объекта оказываются пустыми, то результат их сравнения всегда будет ложным. Это фактически означает, что пустое значение (null) не участвует в отношении порядка. Тем не менее с помощью операторов == и ! = можно проверить, содержит ли обнуляемый объект пустое значение. Например, следующая проверка вполне допустима и дает истинный результат. if(upper == null) // ... Если в логическом выражении участвуют два объекта типа bool?, то его результат может иметь одно из трех следующих значений: true (истинное), false (ложное) или null (неопределенное). Ниже приведены результаты применения логических операторов & и | к объектам типа bool?. р Q P 1 Q P&Q true null true null false null null false null true true null null false null false null null null null И наконец, если логический оператор ! применяется к значению типа bool?, которое является пустым (null), то результат этой операции будет неопределенным (null). Частичные типы Начиная с версии 2.0, в C# появилась возможность разделять определение класса, структуры или интерфейса на две или более части с сохранением каждой из них в отдельном файле. Это делается с помощью контекстного ключевого слова partial. Все эти части объединяются вместе во время компиляции программы. Если модификатор partial используется для создания частичного типа, то он принимает следующую общую форму: |