Introducción a los punteros en C #
Los punteros se definen como una variable que contiene la dirección de memoria de otra variable. Los punteros en C # se usan cuando hay una declaración que no es segura y está marcada por una palabra clave insegura. Esos tipos de declaraciones no tienen el control de los recolectores de basura y utilizan variables de puntero.
Sintaxis: los punteros se pueden declarar como
type *var name;
int* a;
Aquí * se llama operador de desreferencia y a es la variable que contiene la dirección de tipo int.
Ejemplo
int *p = & x; // where &x is the memory address of x
Console.WriteLine((int)p) // displaying memory address
Console.WriteLine(*p) // displaying value at memory address
¿Cómo funcionan los punteros en C #?
A continuación se muestran los ejemplos que muestran cómo funciona en C #.
Punteros en C # - Ejemplo # 1
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace Pointers
(
class Demo
(
public void Method()
(
unsafe
(
int a = 40;
int b = 20;
int* ptr1 = &a;
int* ptr2 = &b;
Console.WriteLine(*ptr1); // displaying the value
Console.WriteLine(*ptr2); // displaying the value
Console.WriteLine((int)ptr1); // displaying the address
Console.WriteLine((int)ptr2); // displaying the address
)
)
)
class Example
(
// main method
public static void Main()
(
Demo d = new Demo();
d.Method();
)
)
)
Hay diferentes formas de ejecutar declaraciones como inseguras, como un Modificador, un constructor, etc. En el ejemplo anterior, un grupo de declaraciones se marca como inseguro. En el código anterior, hay dos variables a y b con valores 40 y 20 respectivamente y los punteros contienen sus direcciones. Console.WriteLine () se utiliza para mostrar los valores y las direcciones de las variables.
Salida:
Punteros en C # - Ejemplo # 2
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace Pointers
(
class Demo
(
public unsafe void Method()
(
int a = 50;
int b = 20;
int* ptr1 = &a;
int* ptr2 = &b;
Console.WriteLine(*ptr1); // displaying the value
Console.WriteLine(*ptr2); // displaying the value
Console.WriteLine((int)ptr1); // displaying the address
Console.WriteLine((int)ptr2); // displaying the address
)
)
class Example
(
// main method
public static void Main()
(
Demo d = new Demo();
d.Method();
)
)
)
En el ejemplo anterior, inseguro se usa con el método que tiene dos variables ayb con valores 50 y 20 respectivamente. Los punteros * ptr1 y * ptr2 apuntan a sus direcciones de memoria.
Salida:
Punteros en C # - Ejemplo # 3
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace Pointers
(
class Demo
(
public unsafe static void Main()
(
int() array = ( 10, 20, 30, 40, 50 ); // declaring array
fixed (int* ptr = array) // fixed for pinning the object
/* let us have array address in pointer */
for (int i = 0; i < 5; i++)
(
Console.WriteLine("Value of array((0))=(1)", i, *(ptr + i));
Console.WriteLine("Address of array((0))=(1)", i, (int)(ptr + i));
Console.ReadKey();
)
)
)
)
En el código anterior, se define una matriz que consta de cinco elementos y Console.WriteLine () se usa para mostrar el valor de los elementos de la matriz y la dirección de los elementos de la matriz. Hay un concepto en C # que se conoce como la fijación de un objeto. En el código anterior, se usa una declaración fija para fijar objetos para que el recolector de basura no permita que el objeto se mueva y lo "ancle". Puede afectar la eficiencia del tiempo de ejecución.
Salida:
Punteros en C # - Ejemplo # 4
using System;
namespace Pointers
(
// Struct employee
struct Employee
(
// members
// employee id and salary
public int empid;
public double salary;
// Constructor to initialize values
public Employee(int e, double s)
(
empid = e;
salary = s;
)
); // end of struct
class Program
(
// Main Method
static void Main(string() args)
(
// unsafe so as to use pointers
unsafe
(
// Declaring two employee Variables
Employee E1 = new Employee(798, 30000);
Employee E2 = new Employee(799, 31000);
// Declaring two employee pointers
// and initializing them with addresses
// of E1 and E2
Employee* E1_ptr = &E1;
Employee* E2_ptr = &E2;
// Displaying details of employees using pointers
// Using the arrow ( -> ) operator
Console.WriteLine("Details of Employee 1");
Console.WriteLine("Employee Id: (0) Salary: (1)",
E1_ptr->empid, E1_ptr->salary);
Console.WriteLine("Details of Employee 2");
Console.WriteLine("Employee Id: (0) Salary: (1)",
E2_ptr->empid, E2_ptr->salary);
) // end unsafe
) // end main
) // end class
)
En el ejemplo anterior, la estructura del empleado con los miembros de identificación y salario del empleado y el constructor de parámetros para inicializar los valores. Los punteros apuntan a estructuras que contienen un tipo de valor primitivo en lugar de estructuras que contienen un tipo de referencia. En el método principal, hay dos variables de empleado y punteros de empleado que se inicializan con las direcciones E1 y E2. Console.WriteLine () se utiliza para mostrar los detalles del empleado mediante punteros.
Salida:
Punteros en C # - Ejemplo # 5
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace Pointers
(
class Demo
(
public static void Main()
(
unsafe
(
int* arr = stackalloc int(6); // declaring array
arr(0) = 10;
arr(1) = 20;
arr(2) = 30;
arr(3) = 40;
arr(4) = 50;
arr(5) = 60;
for (int i = 0; i < 6; i++)
(
Console.WriteLine($"Value at (i): (arr(i))");
Console.ReadKey();
)
)
)
)
)
En el código anterior, se usa la palabra clave stackalloc, en la que se asigna memoria en la pila. La memoria ejecutada en el bloque de pila se crea durante la ejecución del método. stackalloc tiene un mejor rendimiento y no es necesario anclar la matriz. Es mejor que la matriz asignada en el montón, ya que no hay necesidad de liberarla porque se libera automáticamente cuando vuelve el método.
Salida:
En punteros, las conversiones son de tipo implícito y explícito. Un tipo implícito de conversión es como cualquier tipo de puntero para anular * y nulo para cualquier tipo de puntero. En tipo explícito, las conversiones son de byte, sbyte, ushort, short, uint, int, ulong, long a cualquier tipo de puntero o viceversa y de un puntero a otro.
Conclusión: punteros en C #
Por lo tanto, los punteros se utilizan para apuntar las direcciones de memoria y ejecutarlas con un código de instrucciones inseguro. Solo se usa en un entorno no administrado y el recolector de basura no lo rastrea. Los punteros se usan en una pila, cola, etc.
Artículos recomendados
Esta es una guía de punteros en C #. Aquí discutimos Introducción y cómo funciona el puntero en C # junto con varios Ejemplos. También puede consultar los siguientes artículos para obtener más información.
- Usos de C #
- Punteros en C ++
- C # vs rendimiento de Java
- ¿Qué es la C?