Introdução aos ponteiros em C #
Ponteiros são definidos como uma variável que contém o endereço de memória de outra variável. Ponteiros em C # são usados sempre que houver uma declaração insegura e marcada por palavras-chave inseguras. Esses tipos de instruções não estão no controle de coletores de lixo e usam variáveis de ponteiro.
Sintaxe: os ponteiros podem ser declarados como
type *var name;
int* a;
Aqui * é chamado de operador de des-referência e a é a variável que contém o endereço do tipo int.
Exemplo
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
Como os ponteiros funcionam em c #?
Abaixo estão os exemplos que mostram como ele funciona em c #.
Ponteiros em C # - Exemplo # 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();
)
)
)
Existem diferentes maneiras de executar instruções como inseguras, como um modificador, construtor etc. No exemplo acima, um grupo de instruções é marcado como inseguro. No código acima, existem duas variáveis aeb com valores 40 e 20 respectivamente e os ponteiros contêm seus endereços. Console.WriteLine () é usado para exibir os valores e endereços das variáveis.
Resultado:
Ponteiros em C # - Exemplo # 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();
)
)
)
No exemplo acima, inseguro é usado com o método que possui duas variáveis aeb com valores 50 e 20, respectivamente. Os ponteiros * ptr1 e * ptr2 apontam para seus endereços de memória.
Resultado:
Ponteiros em C # - Exemplo # 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();
)
)
)
)
No código acima, é definida uma matriz que consiste em cinco elementos e Console.WriteLine () é usado para exibir o valor dos elementos da matriz e o endereço dos elementos da matriz. Existe um conceito em C # que é conhecido como Fixação de um objeto. No código acima, uma instrução fixa é usada para fixar objetos, para que o coletor de lixo não permita que o objeto se mova e o “fixe”. Isso pode afetar a eficiência do tempo de execução.
Resultado:
Ponteiros em C # - Exemplo # 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
)
No exemplo acima, estrutura do funcionário com a identificação e o salário dos funcionários e parametrize o construtor para inicializar os valores. Os ponteiros apontam para estruturas que contêm o tipo de valor primitivo em vez de estruturas que contêm o tipo de referência. No método principal, existem duas variáveis de funcionários e indicadores de funcionários que são inicializados com os endereços E1 e E2. Console.WriteLine () é usado para exibir os detalhes do funcionário usando ponteiros.
Resultado:
Ponteiros em C # - Exemplo # 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();
)
)
)
)
)
No código acima, a palavra-chave stackalloc é usada, na qual a memória é alocada na pilha. A memória executada no bloco de pilha é criada durante a execução do método. O stackalloc tem melhor desempenho e não é necessário fixar a matriz. É melhor que o array alocado por heap, pois não há necessidade de liberá-lo porque ele é liberado automaticamente quando o método retorna.
Resultado:
Nos ponteiros, as conversões são de um tipo implícito e explícito. Um tipo implícito de conversão é como qualquer tipo de ponteiro para anular * e nulo para qualquer tipo de ponteiro. No tipo explícito, as conversões são de byte, sbyte, ushort, short, uint, int, ulong, long para qualquer tipo de ponteiro ou vice-versa e um ponteiro para outro ponteiro.
Conclusão - Ponteiros em C #
Portanto, ponteiros são usados para apontar os endereços de memória e executá-los com um código de instruções não seguro. É usado apenas em um ambiente não gerenciado e não é rastreado pelo coletor de lixo. Ponteiros são usados em uma pilha, fila, etc.
Artigos recomendados
Este é um guia para ponteiros em C #. Aqui discutimos Introdução e como o ponteiro funciona em C # junto com vários exemplos. Você também pode consultar os seguintes artigos para saber mais:
- Usos de c #
- Ponteiros em C ++
- C # vs desempenho Java
- O que é C?