Constantes Locais

Constantes Locais (Local Constants)

Constantes locais são muito parecidas com variáveis locais, com uma diferença importante: após ser inicializada, o valor de uma constante não pode ser alterado.

Assim como variáveis locais, constantes devem ser declaradas dentro de um bloco de código.

As constantes possuem duas características principais:

1. É obrigatório definir um valor na declaração;
2. Depois de declarada, o valor não pode ser modificado.

Sintaxe básica de constantes

const Tipo NomeDaConstante = ValorInicial;

// const: palavra-chave, deve ficar imediatamente antes do tipo
// = ValorInicial: não pode ser omitido, é obrigatório
Code language: JavaScript (javascript)

Explicação das regras de sintaxe

Se compararmos com declarações comuns de campos ou variáveis, existem duas diferenças:

1. Adicione a palavra reservada const antes do tipo de dado;
2. É necessário informar um valor inicial, e esse valor precisa ser conhecido em tempo de compilação:
   • Geralmente literais de tipos primitivos ou expressões formadas por tipos básicos;
   • É permitido atribuir null;
   • Não é possível atribuir referências de instâncias de objetos (referências de objetos só são definidas em tempo de execução e não atendem ao requisito de constante de compilação).

class Program
{
    static void Main()
    {
        int a = 10; // esta é uma variável

        const int b = 20; // esta é uma constante, visualmente similar a uma variável
                          // a palavra const indica que se trata de uma constante

        a = 100; // variáveis aceitam reatribuição
        a = 200; // pode ser alterada quantas vezes quiser

        // Erro
        b = 300; // constantes não podem ser modificadas, o compilador retornará um erro

        // O uso de constantes melhora a legibilidade e manutenção do código

        
        int c; // declaração
        c = 12; // variáveis permitem separar declaração e atribuição

        // Constantes não aceitam separar declaração e inicialização
        // Erro
        const double d; // apenas declaração
        d = 3.14; // válido para variáveis, inválido para constantes
    }
}Code language: C# (cs)

Esses dois erros têm causas distintas: o primeiro tenta alterar o valor de uma constante, o segundo separa declaração e inicialização. Para constantes, os dois passos devem ocorrer juntos.

Um objeto de classe pode ser usado como constante?

A expressão atribuída à constante phone precisa ser uma constante de tempo de compilação.

new Phone() aloca memória heap e cria um objeto durante a execução do programa; trata-se de um valor em tempo de execução.

O C# não permite atribuir referências de objetos geradas em tempo de execução a constantes locais const, causando o erro de compilação CS0133.

class Program
{
    static void Main()
    {
        const Phone phone = new Phone();
    }
}

class Phone
{

}Code language: C# (cs)

Observação complementar sobre a palavra-chave

const não é um modificador. Ela é uma parte essencial da sintaxe de declaração e deve ser escrita diretamente antes do tipo de dado.

Palavras como private, public e protected são os modificadores propriamente ditos.

Regras de escopo e exemplo

As regras de escopo para constantes locais são idênticas às das variáveis locais. Se declarada dentro de um método ou bloco de código, ela deixa de existir após o término da execução do bloco.

void ShowArea()
{
    const double PI = 3.1416; // declara a constante local PI
    for (int radius = 1; radius <= 5; radius++) // exibe a área de círculos com raio de 1 a 5
    {
        double area = radius * radius * PI; // lê o valor da constante PI
        Console.WriteLine($"Raio: {radius}, Área: {area}");
    }
}
Code language: C# (cs)

A constante PI só pode ser acessada dentro do método ShowArea e é removida quando o método finaliza.

class Program
{
    static void Main()
    {
        ShowArea();
    }

    static void ShowArea()
    {
        const double PI = 3.1416; 
        for (int radius = 1; radius <= 5; radius++) 
        {
            double area = radius * radius * PI;
            Console.WriteLine($"Radius: {radius}, Area: {area}");
        }
    }

}
Code language: C# (cs)

Constantes Locais