Дороговкази в C #

Наша взаимовыгодная связь https://banwar.org/

Мова C # також підтримує покажчики (pointer), однак кілька обмежено. Обмеженість полягає в тому, що застосування покажчиків не заохочують, оскільки справедливо вважається, що це може вплинути на надійність як коду, так і середовища виконання в цілому.

Покажчик - це всього лише звичайна змінна, яка містить в собі адресу пам'яті, в якій міститься змінна будь-якого типу (адреса змінної). Інше обмеження C # - покажчики можуть бути оголошені тільки для утримання адреси змінної і масиву. На відміну від посилальних типів (reference types), типи вказівників (pointer types) не відслідковуються механізмом збору сміття за замовчуванням (default garbage collection). З тієї ж самої причини вказівниками заборонено вказувати на контрольний тип (reference type) або навіть на тип структури, яка містить в собі контрольний тип. Можна сказати, що покажчики можуть вказувати тільки на некеровані типи (unmanaged types), які включають в себе всі базові типи даних (basic data types), типи перерахування (enum types), інші типи вказівників і структури, які містять тільки некеровані типи.

[Оголошення покажчика]

Основна форма оголошення змінної покажчика наступна:

type * variable_name;

Тут зірочка * означає оператор разименованія (de-reference operator). Наприклад, рядок

int * ptr;

оголошує змінну покажчика ptr, яка може тримати в собі адресу змінної типу int. Зворотний оператор генерування посилання (reference operator, &) може використовуватися для отримання адреси змінної. Наприклад, у нас є змінна

int x = 100;

Оператор & x дасть нам адресу змінної x, який ми можемо привласнити змінної покажчика.

int * ptr = & x; Console. WriteLine ((int) ptr); // З'явиться адресу пам'яті змінної. Console. WriteLine (* ptr); // З'явиться значення змінної.

Тут ми розглянули звичайне просте використання покажчиків, що застосовується на мовах C і C ++. Мовою C # все відбувається схожим чином, проте є деякі відмінності.

[Небезпечний код (Unsafe Code)]

Правилами мови C # визначено, що оператори можуть виконуватися або в безпечному (safe), або в небезпечному (unsafe) контексті. Оператори, процедури і функції, помічені як небезпечні, запускаються поза галузі управління пам'яттю за допомогою збирача сміття (Garbage Collector). Пам'ятайте, що будь-який код C #, що використовує покажчики, вимагає для виконання небезпечного контексту.

Для того, щоб позначити небезпечний контекст (т. Е. Код), використовується ключове слово unsafe. Ми можемо використовувати unsafe двома різними способами. Ключове слово unsafe може використовуватися як модифікатор методу, властивості, конструктора, і т. Д. Наприклад:

using System; class MyClass {public unsafe void Method () {int x = 10; int y = 20; int * ptr1 = & x; int * ptr2 = & y; Console. WriteLine ((int) ptr1); Console. WriteLine ((int) ptr2); Console. WriteLine (* ptr1); Console. WriteLine (* ptr2); }} Class MyClient {public static void Main () {MyClass mc = new MyClass (); mc. Method (); }}

Крім того, ключове слово unsafe може також використовуватися, щоб позначити групу операторів як небезпечну:

using System; class MyClass {public void Method () {unsafe {int x = 10; int y = 20; int * ptr1 = & x; int * ptr2 = & y; Console. WriteLine ((int) ptr1); Console. WriteLine ((int) ptr2); Console. WriteLine (* ptr1); Console. WriteLine (* ptr2); }}} Class MyClient {public static void Main () {MyClass mc = new MyClass (); mc. Method (); }}

[Прикріплення об'єкта (Pinning an Object)]

Складальник сміття C # може перемістити об'єкти в пам'яті відповідно до алгоритму процесу збирання сміття. Мова C # надає спеціальне ключове слово fixed, щоб вказати збирачеві сміття не переміщувати об'єкт. Це означає, що позиція змінної в пам'яті в пам'яті фіксується, щоб на неї міг посилатися покажчик. На C # це називається прикріпленням (pinning).

Функціонал оператора fixed зазвичай реалізований шляхом генерації таблиць, що описують для збирача сміття, які об'єкти в яких областях виконуваного коду повинні залишатися фіксованими. Таким чином, поки процес збору сміття не зустрічається під час виконання операторів fixed, втрати ресурсів на них виявляються досить незначними. Однак, коли збирач сміття зустрічає fixed, то фіксовані об'єкти можуть привести до утворення фрагментації купи (heap). Т. е. В купі можуть з'явитися невикористовувані "дірки". Отже, об'єкти повинні використовувати fixed тільки тоді, коли це абсолютно необхідно, і тільки на найменший, наскільки це можливо, проміжок часу виконання коду.

[Покажчики та методи (Pointers & Methods)]

Покажчики можуть бути передані в метод як аргументи. Методи також можуть повернути покажчик. приклад:

using System; class MyClass {public unsafe void Method () {int x = 10; int y = 20; int * sum = swap (& x, & y); Console. WriteLine (* sum); } Public unsafe int * swap (int * x, int * y) {int sum; sum = * x + * y; return & sum; }} Class MyClient {public static void Main () {MyClass mc = new MyClass (); mc. Method (); }}

[Покажчики та перетворення типу (Pointers & Conversions)]

Типи покажчиків в C # не успадковуються від об'єкта, і немає існуючих перетворень між типами покажчика і об'єктами. Це означає, що boxing і un-boxing не підтримує покажчиками. Однак C # підтримує перетворення між різними типами покажчиків, типами покажчиків (pointer types) і цілочисельними типами (integral types).

C # підтримує і неявні (implicit), і явні (explicit) перетворення покажчика в небезпечному контексті. Є неявні перетворення типу:

1. З типу покажчика на будь-який тип до типу покажчика на тип void *.
2. З типу null до будь-якого іншого типу покажчика.

Оператор перетворення типу cast operator () необхідний для будь-яких явних перетворень типу. Є явні перетворення типу:

1. З будь-якого типу покажчика на будь-який інший тип покажчика.
2. З типів sbyte, byte, short, ushort, int, uint, long, ulong до будь-якого іншого типу покажчика.
3. З будь-якого типу покажчика до типам sbyte, byte, short, ushort, int, uint, long, ulong.

приклад:

char c = 'R'; char * pc = & c; void * pv = pc; // неявне перетворення int * pi = (int *) pv; // явне перетворення оператором кастингу

[Арифметика покажчиків (Pointer Arithmetic)]

У небезпечному контексті, оператори ++ і - можуть бути включені до змінної покажчика всіх типів, за винятком типу void *. Таким чином, для кожного типу покажчика T * наступні оператори будуть неявно перевантажені (implicitly overloaded).

T * operator ++ (T * x);
T * operator - (T * x);

Оператор ++ додає sizeof (T) до адресою, що міститься в змінній покажчика, і оператор - віднімає sizeof (T) з цієї адреси для змінної покажчика на тип T *.

In an un-safe context a constant can be added or subtracted from a pointer variable. Similarly a pointer variable can be subtracted from another pointer variable. But it is not possible to add two pointer variables in C #.

У небезпечному контексті оператори ==,! =, <,>, <=,> = Можуть також бути використовуватися зі значеннями покажчиків на всі типи. Множення і ділення змінної покажчика на константу або іншу зміну-покажчик не підтримуються в C #.

[Виділення пам'яті стека (Stack Allocation)]

У небезпечному контексті локальні визначення змінних можуть включати ініціалізатор виділення стека (stack allocation initialiser), який виділяє пам'ять з стека викликів (call stack).

Оператор stackalloc T [E] вимагає T як необроблюваних (unmanaged) тип і E як вираз типу int. Вищевказана конструкція виділяє E * sizeof (T) байт з стека і генерує покажчик типу T * на новий виділений блок. Якщо E негативно, то викидається виключення System.OverFlowException. Якщо недостатньо пам'яті, то спрацьовує виняток System.StackOverflowException.

Вміст щойно виділеної пам'яті є невизначеним. Немає способу неявного звільнення пам'яті, виділеної через stackalloc. Замість цього весь блок пам'яті стека автоматично звільняється після повернення з функції.

[Покажчики та масиви (Pointers & Arrays)]

У C # може бути отриманий доступ до елементів масиву за допомогою використанням нотацій покажчика.

using System; class MyClass {public unsafe void Method () {int [] iArray = new int [10]; for (int count = 0; count <10; count ++) {iArray [count] = count * count; } Fixed (int * ptr = iArray) Display (ptr); //Console.WriteLine(*(ptr+2)); //Console.WriteLine((int)ptr); } Public unsafe void Display (int * pt) {for (int i = 0; i <14; i ++) {Console. WriteLine (* (pt + i)); }}} Class MyClient {public static void Main () {MyClass mc = new MyClass (); mc. Method (); }}

[Покажчики та структури (Pointers & Structures)]

Всі структури C # мають тип змінної. На структуру теж може бути заданий покажчик тільки в тому випадку, якщо структура як своїх полів містить тільки типи у вигляді значення. приклад:

using System; struct MyStruct {public int x; public int y; public void SetXY (int i, int j) {x = i; y = j; } Public void ShowXY () {Console. WriteLine (x); Console. WriteLine (y); }} Class MyClient {public unsafe static void Main () {MyStruct ms = new MyStruct (); MyStruct * ms1 = & ms; ms1 -> SetXY (10, 20); ms1 -> ShowXY (); }}

[Висновки]

1. Функції або процедури C #, якщо вони використовують покажчики, повинні мати атрибут unsafe.

private unsafe void DecodeALSEN (TAlsenStr * dst, pmi_ext_proto. TAnswRaw src) {byte pktnum = extproto. PacketNum (src); if (0 == pktnum) {dst -> CentralFrequency = src. alsen0 .freq; dst -> ValueRMS = src. alsen0 .rms; } Else if (1 == pktnum) {dst -> CodeChannel1 = src. alsen1 .CodeChannel1; dst -> CodeChannel2 = src. alsen1 .CodeChannel2; }}

2. Проект C #, в якому є небезпечний (unsafe) код, повинен мати відповідний дозвіл в настройках (відповідає опції компілятора / unsafe).

3. Отримання покажчика від об'єкта можливо лише в тому випадку, якщо він визначений з атрибутом fixed.

fixed (TAlsenStr * pntAlsen = & sdata. ALSEN) DecodeALSEN (pntAlsen, cbtmp);