Neste guia, veremos o operador de dois pontos duplos (::) em C++ e como funciona em diferentes cenários.
O que :: Faz em C++?
Em C++, o resolução de escopo operadora (::) é usado para recuperar os nomes das variáveis presentes em vários níveis de escopo. O escopo na programação refere-se ao contexto onde as variáveis e funções podem ser acessadas.
Usos de :: em diferentes casos em C++
Em C++, o operador de resolução de escopo (::) tem vários usos, dependendo do contexto em que é usado. A seguir estão alguns usos notáveis deste operador:
1: Acesse uma Variável ou Função em um Namespace Diferente
A namespace é usado em C++ para agrupar funções, classes e variáveis relacionadas para evitar conflitos de nomenclatura. Quando você define uma variável ou função dentro de um namespace , o nome da variável ou função só é visível dentro desse namespace .
Em C++, você pode usar o operador de resolução de escopo (::) juntamente com o namespace name e o nome da variável ou função para acessar uma variável ou função definida em um namespace diferente. Isso permite que você acesse a variável ou função de um namespace diferente daquele em que foi criado.
Para entender o caso acima, considere o seguinte código como exemplo:
#includeusando namespace std ;
matemática de espaço de nomes {
const dobro PI = 3.14159 ;
dobro quadrado ( dobro x ) {
retornar x * x ;
}
}
int principal ( ) {
cout << 'O valor de PI é: ' << matemática :: PI << fim ;
cout << 'O quadrado de 5 é: ' << matemática :: quadrado ( 5 ) << fim ;
retornar 0 ;
}
O código acima usa o espaço de nomes de matemática para acessar o 'PI' constante e 'quadrado' função usando o operador de resolução de escopo “::” . Em seguida, imprime os valores no console.
Saída
2: Acesse a Variável Global no Programa
Quando o mesmo nome de variáveis locais e globais está presente no programa, a variável local pode ocultar a global. Em tais situações, você pode usar o operador de resolução de escopo (::) para acessar a variável global. Este operador nos permite referir explicitamente à variável global com base em seu escopo.
Por exemplo, no código fornecido abaixo, nos referimos à variável global 'a 'através do operador de resolução de escopo (::) , de dentro de uma função onde foi definida uma variável local com o mesmo nome:
#includeusando namespace std ;
int a = quinze ;
int principal ( )
{
int a = 35 ;
cout << 'O valor da variável global a é ' << :: a << fim ;
cout << 'O valor da variável local a é ' << a << fim ;
retornar 0 ;
}
No código acima, a variável a presente fora da função principal é a variável global e a variável a dentro da função principal é o variável local com o mesmo nome da variável global. Na instrução cout, usamos o operador de resolução de escopo para imprimir a variável global a .
Saída
3: Defina uma função fora da classe
Em C++, você pode definir uma função de classe fora da definição de classe e isso pode ser feito usando o operador de resolução de escopo (::) para especificar a qual classe a função pertence. Isso é necessário porque a função é definida fora do escopo da classe.
Aqui está um código de exemplo que demonstra esse uso do operador de resolução de escopo :
#includeusando namespace std ;
classe minhaclasse {
público :
vazio minha função ( ) ;
} ;
vazio minha classe :: minha função ( ) {
cout << 'minhafunção() Chamada!' ;
}
int principal ( )
{
myClass classObj ;
classObj. minha função ( ) ;
retornar 0 ;
}
No código acima, a função de membro minhafunção() é definido fora da classe usando o operador de resolução de escopo :: para especificar que minhafunção() pertence à classe myClass.
Saída
4: Acessar membros estáticos da classe
Em C++, quando há um membro estático e uma variável local com o mesmo nome está presente na classe, o operador de resolução de escopo (::) pode ser usado para acessar membros estáticos de uma classe. Isso permite que o programa diferencie entre a variável local e o membro estático.
Aqui está um código de exemplo que relaciona o uso de operador de resolução de escopo para tal caso:
#includeusando namespace std ;
classe minhaclasse {
público :
estático int myStatVar ;
} ;
int minha classe :: myStatVar = 5 ;
int principal ( ) {
int myStatVar = 10 ;
cout << 'Variável local myStatVar: ' << myStatVar << fim ;
cout << 'Variável de classe myStatVar: ' << minha classe :: myStatVar << fim ;
retornar 0 ;
}
O programa acima primeiro define uma classe minha classe com uma variável de membro estático myStatVar . Em seguida, define uma variável local com o mesmo nome dentro da função principal do programa. Para acessar a variável de classe, o operador de resolução de escopo (::) é usado com o nome da classe minha classe . O programa gera o valor de ambas as variáveis para o console.
Saída
5: Use com Múltiplas Heranças
O operador de resolução de escopo (::) também é usado para indicar qual versão de um membro usar quando uma classe C++ é derivada de várias classes pai que possuem variáveis de membro ou funções com o mesmo nome. Podemos distinguir entre várias versões do mesmo membro usando o operador de resolução de escopo seguido pelo nome da classe pai e o nome do membro.
#includeusando namespace std ;
classe Parent1 {
público :
vazio imprimir ( ) {
cout << 'Esta é a função de impressão da classe Parent1.' << fim ;
}
} ;
classe Parent2 {
público :
vazio imprimir ( ) {
cout << 'Esta é a função de impressão da classe Parent2.' << fim ;
}
} ;
classe minhaclasse : Public Parent1 , public Parent2 {
privado :
int num ;
público :
minha classe ( int n ) {
num = n ;
}
vazio imprimir ( ) {
Pai1 :: imprimir ( ) ; // chama a função de impressão de Parent1
Pai2 :: imprimir ( ) ; // chama a função de impressão de Parent2
cout << 'O valor de num é: ' << num << fim ; // imprime o valor de num
}
} ;
int principal ( ) {
myClass obj ( 42 ) ; // cria um objeto de MyClass com num inicializado em 42
obj. imprimir ( ) ; // chama a função print() do objeto
retornar 0 ;
}
O programa acima demonstra o uso do operador de resolução de escopo (::) para distinguir entre as funções de impressão de Pai1 e Pai2 quando ambas as classes são herdadas por minha classe. Chamando as funções com o classe pai nome precedendo o nome da função, podemos especificar qual versão da função usar.
Saída
Conclusão
O operador de resolução de escopo (::) é um componente vital em C++ usado para acessar nomes de variáveis em diferentes níveis de escopo. O operador tem vários usos, incluindo acessar uma variável ou função em um namespace diferente, acessar uma variável global, definir uma função fora da classe, acessar membros estáticos de uma classe e usar várias heranças. Embora possa ser confuso para novos desenvolvedores, entender o operador de resolução de escopo (::) é essencial para uma boa prática de programação.