Your SlideShare is downloading. ×
0
Unsafe
• Unsafe code often involves the use of
pointers.
• Unsafe code and pointers enable C# to be
used to create applications t...
• Unsafe code is not code that is poorly written; it
is code that does not execute under the full
management of the common...
• Because a pointer can point anywhere in
memory, it is possible to misuse a pointer.
• It is also easy to introduce a cod...
Declaring a Pointer
• Pointer variables must be declared as such.
type * var-name ;
• type is the pointer’s referent type....
• If you come from a C/C++ background, then
you need to be aware of an important
difference between the way C# and C/C++
d...
• in C#, the * is distributive and the declaration
int* p, q;
• creates two pointer variables.
• Thus, in C# it is the sam...
• Two operators are used with pointers: * and
&.
• The & is a unary operator that returns the
memory address of its operan...
• The second operator is *, and it is the
complement of &.
• it refers to the value of the variable pointed
to by a pointe...
unsafe
• Any code that uses pointers must be marked
as unsafe by using the unsafe keyword.
• You can mark types (such as c...
// Mark Main as unsafe.

unsafe static void Main() {
int count = 99;
int* p; // create an int pointer
p = &count; // put a...
Using fixed
• The fixed keyword can be used only in an
unsafe context.
• The fixed modifier is often used when working
wit...
• Using pointers in C# require much more
attention then in C++. That is because of
garbage collector (g.c.) which can run ...
•
•
•
•

using System;
class Test {
public int num;
public Test(int i) { num = i; }

•}
• class FixedCode {
• // Mark Main...
Test o = new Test(19);
fixed (int* p = &o.num) {
Console.WriteLine("Initial value of o.num is " + *p);
*p = 10;
Console.Wr...
Upcoming SlideShare
Loading in...5
×

Unsafe

234

Published on

Published in: Education, Technology
0 Comments
1 Like
Statistics
Notes
  • Be the first to comment

No Downloads
Views
Total Views
234
On Slideshare
0
From Embeds
0
Number of Embeds
0
Actions
Shares
0
Downloads
4
Comments
0
Likes
1
Embeds 0
No embeds

No notes for slide

Transcript of "Unsafe"

  1. 1. Unsafe
  2. 2. • Unsafe code often involves the use of pointers. • Unsafe code and pointers enable C# to be used to create applications that one might normally associate with C++: highperformance, systems code. • the inclusion of unsafe code and pointers gives C# capabilities that are lacking in Java.
  3. 3. • Unsafe code is not code that is poorly written; it is code that does not execute under the full management of the common language runtime (CLR). • C# is normally used to create managed code. • It is possible, however, to write code that does not execute under the full control of the CLR. This unmanaged code is not subject to the same controls and constraints as managed code, so it is called “unsafe”. • it is not possible to verify that it won’t perform some type of harmful action.
  4. 4. • Because a pointer can point anywhere in memory, it is possible to misuse a pointer. • It is also easy to introduce a coding error when using pointers. This is why C# does not support pointers when creating managed code. • C# does allow you to create and use pointers. However, all pointer operations must be marked as unsafe since they execute outside the managed context.
  5. 5. Declaring a Pointer • Pointer variables must be declared as such. type * var-name ; • type is the pointer’s referent type. • var-name is the name of the pointer variable. • example. To declare ip to be a pointer to an int, use this declaration: int* ip;
  6. 6. • If you come from a C/C++ background, then you need to be aware of an important difference between the way C# and C/C++ declare pointers. • When you declare a pointer type in C/C++, the * is not distributive over a list of variables in a declaration. • Thus, in C/C++, this statement int* p, q;
  7. 7. • in C#, the * is distributive and the declaration int* p, q; • creates two pointer variables. • Thus, in C# it is the same as these two declarations: int* p; int* q;
  8. 8. • Two operators are used with pointers: * and &. • The & is a unary operator that returns the memory address of its operand. • int* ip; • int num = 10; • ip = # • puts into ip the memory address of the variable num. • ip does not contain the value 10.
  9. 9. • The second operator is *, and it is the complement of &. • it refers to the value of the variable pointed to by a pointer. • ip = # • int val = *ip; • will place into val the value 10, which is the value of num, which is pointed to by ip .
  10. 10. unsafe • Any code that uses pointers must be marked as unsafe by using the unsafe keyword. • You can mark types (such as classes and structures), members (such as methods and operators), or individual blocks of code as unsafe. • using System; • class UnsafeCode {
  11. 11. // Mark Main as unsafe. unsafe static void Main() { int count = 99; int* p; // create an int pointer p = &count; // put address of count into p Console.WriteLine("Initial value of count is " +*p); *p = 10; // assign 10 to count via p Console.WriteLine("New value of count is " + *p); }}
  12. 12. Using fixed • The fixed keyword can be used only in an unsafe context. • The fixed modifier is often used when working with pointers. • It prevents a variable from being moved by the garbage collector. • This is needed when a pointer refers to a field in a class object.
  13. 13. • Using pointers in C# require much more attention then in C++. That is because of garbage collector (g.c.) which can run memory cleaning. During cleaning, g.c. can change physical position of the objects. If g.c. changes position of an object the pointer will point at wrong place in memory. To avoid such problems (connected with garbage collector) C# contains 'fixed' keyword. It informs system not to relocate an object by the garbage collector.
  14. 14. • • • • using System; class Test { public int num; public Test(int i) { num = i; } •} • class FixedCode { • // Mark Main as unsafe. • unsafe static void Main() {
  15. 15. Test o = new Test(19); fixed (int* p = &o.num) { Console.WriteLine("Initial value of o.num is " + *p); *p = 10; Console.WriteLine("New value of o.num is " + *p); } } • fixed prevents o from being moved. Because p points to o.num , if o were moved, then p would point to an invalid location.
  1. A particular slide catching your eye?

    Clipping is a handy way to collect important slides you want to go back to later.

×