Função de membro estático em C++ (Exemplos)

O que é uma função estática em C++?

In C++ classes, um membro estático é um membro da classe que pertence à classe e não aos seus objetos. Você terá apenas uma cópia da assinatura. Este é o caso independentemente do número de objetos que você cria.

Quando uma função de classe é definida como estática, todos os objetos de classe compartilham um membro de classe estático. A função estática pode, portanto, ser acessada sem criar nenhum objeto de classe e torna-se independente de objetos de classe. Um membro de dados estáticos em C++ pode acessar outras funções estáticas, somente fora da classe.

Por que usar funções estáticas?

Diferentemente dos C++ funções globais, funções estáticas só são acessíveis a partir do arquivo de declaração. Se houver necessidade de restringir o acesso a uma função, torne-a estática.

Use uma função estática para restringir a reutilização do mesmo nome de função em outro arquivo.

Com a justificativa para funções estáticas clara, o próximo passo é ver como elas são definidas em C++ código.

Definindo funções estáticas em C++

Sintaxe:

static int myfunc(void)
{
    cout("Example of C++ static function ");
}

No exemplo acima, estamos definindo uma função estática chamada myfunc. Observe o uso da palavra-chave estática na definição. A palavra-chave vem antes do nome da função.

Função de membro estático em C++

Quando um membro de função é declarado estático, ele se torna independente de outros objetos da classe. Você pode chamar uma função de membro estático mesmo que não existam outros objetos de classe.

Para acessar nomes de classes, você deve usar o nome da classe e o operador de resolução de escopo (::). Uma função estática só pode acessar outras funções estáticas, membros de dados estáticos e outras funções fora da classe. O escopo das funções-membro estáticas está dentro da classe e elas não podem acessar esse ponteiro de classe.

Exemplo 1

#include<iostream>
using namespace std;
class BoxClass {
public:
	static int count;
	BoxClass(double l = 2.0, double b = 2.0, double h = 2.0) {
		cout << "Class constructor called." << endl;
		length = l;
		breadth = b;
		height = h;
		count++;
	}
	double getVolume() {
		return length * breadth * height;
	}
	static int getCount() {
		return count;
	}
private:
	double length;     
	double breadth;    
	double height;     
};
int BoxClass::count = 0;
int main(void) {
	cout << "Inital value of count is : " << BoxClass::getCount() << endl;
	BoxClass Box1(3.2, 1.4, 1.8);    
	BoxClass Box2(7.5, 4.0, 4.0);   
	cout << "Final value of count is : " << BoxClass::getCount() << endl;
	return 0;
}

Saída:

Aqui está uma captura de tela do código:

Code Explicação:

1. Incluindo o arquivo de cabeçalho iostream em nosso C++ programa para usar seu funções.
2. Inclua o namespace std no código para usar suas classes sem chamá-lo.
3. Crie uma classe chamada BoxClasse.
4. Use o modificador de acesso público para marcar um membro da classe que é acessível publicamente.
5. A declaração de um membro da classe estática chamada contagem.
6. Use um construtor de classe para inicializar três variáveis ​​de tipo duplo.
7. Imprima algum texto no console. A função endl (linha final) move o cursor do mouse para a próxima linha.
8. Inicialize o valor de l com comprimento variável.
9. Inicialize o valor de b para amplitude variável.
10. Inicialize o valor de h para altura variável.
11. Em seguida, aumente o valor da variável count em 1 cada vez que um novo objeto for criado.
12. Fim do corpo do construtor.
13. Crie uma função chamada doublevolume().
14. Defina o que a função doubleVolume() retornará. Deve retornar a multiplicação das variáveis ​​de comprimento, largura e altura.
15. Fim do corpo da função doubleVolume().
16. Declare uma função estática chamada getCount().
17. A função getCount() deve retornar o valor da variável de contagem.
18. Fim do corpo da função getCount().
19. Use o modificador de acesso privado para marcar um membro da classe como acessível publicamente.
20. Declarando um membro da classe chamado length de um tipo de dados duplo. Será acessível de forma privada.
21. Declare outro membro da classe denominado largura de um tipo de dados duplo. Será acessível de forma privada.
22. Declarando um membro da classe chamado height do tipo de dados double. Será acessível de forma privada.
23. Fim do corpo do BoxClasse de classe.
24. Em seguida, inicialize um membro estático do BoxClasse de classe.
25. Chamando a função main(). O C++ a lógica do programa deve ser adicionada ao corpo dessa função.
26. Imprima algum texto no console informando o número atual de objetos antes que novos objetos sejam criados.
27. Declare um objeto chamado Box1, que é uma das instâncias da classe BoxAula. Os valores de largura, comprimento e altura devem ser especificados entre parênteses.
28. Declare um objeto chamado Box2, que é uma instância da classe BoxAula. Os valores de largura, comprimento e altura foram especificados entre parênteses.
29. Imprima algum texto no console informando o número atual de objetos após a criação de novos objetos.
30. O C++ programa deve retornar o valor após a conclusão bem-sucedida.
31. Fim do corpo da função main().

Acessando funções estáticas

Você não precisa criar um objeto de classe para acessar uma função estática. Em vez disso, você pode usar o nome da classe e o operador de resolução de escopo (::).

Sintaxe:

className::funcName

Acima, className é o nome da classe onde a função estática foi definida. O funcName é o nome atribuído à função estática.

Exemplo 2

#include<iostream> 
using namespace std;
class MyClass {
public:
	static void msgFunc() {
		cout << "Welcome to Guru99!";
	}
};
int main() {
	MyClass::msgFunc();
}

Saída:

Aqui está uma captura de tela do código:

Code Explicação:

1. Incluindo o arquivo de cabeçalho iostream em nosso programa para usar suas funções.
2. Inclua o namespace std em seu código para usar suas classes sem chamá-lo.
3. Crie uma classe chamada MinhaClasse.
4. Use o modificador de acesso público para marcar um membro da classe como acessível publicamente.
5. Declarando uma função estática chamada msgFunc(). A palavra-chave static torna a função estática.
6. Especifique o texto a ser impresso no console assim que a função acima for chamada/invocada.
7. Fim do corpo da função msgFunc().
8. Finalize o corpo da classe.
9. Chamando a função main().
10. Chame a função estática chamada msgFunc().
11. Fim do corpo da função main().

Acessando Variáveis ​​Estáticas

Variáveis ​​estáticas pertencem a uma classe e não a objetos de classe. Se uma variável estática for pública, ela poderá ser acessada usando o nome da classe e o operador de resolução de escopo. No entanto, isso não é possível se um membro estático for privado.

Normalmente, variáveis ​​privadas são acessadas através de funções públicas. No entanto, uma instância/objeto de classe deve ser criada. A solução é usar uma função estática.

Exemplo 3: variável estática em C++ classe

#include<iostream> 
using namespace std;
class AClass {
private:
	static int myvar;
public:
	static int getVar() { 
		return myvar; 
		} 
};
int AClass::myvar = 23; 
int main() {
	cout <<"The value of myvar is: "<< AClass::getVar() << '\n';
}

Saída:

Aqui está uma captura de tela do código:

Code Explicação:

1. Incluindo o arquivo de cabeçalho iostream em nosso programa.
2. Inclua o namespace std neste programa para usar suas classes sem chamar.
3. Crie uma classe chamada AClass.
4. Use o modificador de acesso privado para tornar a variável myvar acessível de forma privada.
5. Crie uma variável inteira estática chamada myvar.
6. Use o modificador de acesso público que marca a função getVar() como acessível publicamente.
7. Criando uma função estática chamada getVar().
8. A função getVar() deve ser capaz de retornar o valor da variável myvar.
9. Fim do corpo da função getVar().
10. Fim do corpo da classe AClass.
11. Atribua à variável myvar o valor 23. Usamos o nome da classe e o operador de resolução de escopo para isso.
12. Chamando a função main().
13. Imprima o valor da variável myVar no console junto com outro texto. Usamos o nome da classe, a função estática e o operador de resolução de escopo para acessar o valor desta variável.
14. O final do corpo da função main().

Uma limitação fundamental explica por que as funções estáticas se comportam de maneira diferente dos métodos comuns, ou seja, a ausência do ponteiro `this`.

este ponteiro em funções estáticas

Uma função estática não está anexada a um objeto. É por isso que funções estáticas não possuem esse ponteiro. O ponteiro de um objeto geralmente aponta para o objeto no qual ele está trabalhando no momento. Como as funções estáticas não funcionam com objetos, não há necessidade desse ponteiro.

Funções estáticas têm acesso direto a outros membros estáticos. No entanto, este não é o caso de membros não estáticos. A razão é que membros não estáticos precisam pertencer a um objeto, mas funções estáticas não possuem objetos com os quais trabalhar.

Exemplo 4

É possível definir uma função estática fora da declaração de classe. Vamos demonstrar isso:

#include<iostream> 
using namespace std;
class NumGenerator {
private:
	static int nextNum; 
public:
	static int getNextNum();
};
int NumGenerator::nextNum = 1;
int NumGenerator::getNextNum() {
	return nextNum++; 
}
int main() {
	for (int count = 0; count < 5; ++count)
		std::cout << "The next number is: " << NumGenerator::getNextNum() << '\n';
	return 0;
}

Saída:

Aqui está uma captura de tela do seu código:

Code Explicação:

1. Incluindo o arquivo de cabeçalho iostream em nosso código para usar suas funções.
2. Inclua o namespace std em nosso código para usar suas classes sem chamá-lo.
3. Crie uma classe chamada NumGenerator.
4. Usando o modificador de acesso privado para marcar a variável, estamos prestes a criar como acessível de forma privada.
5. Crie uma variável inteira estática chamada nextNum.
6. Usando o modificador de acesso público que ajuda você a marcar a variável que estamos prestes a criar como acessível publicamente.
7. Declarando uma função estática chamada getNextNum().
8. Fim do corpo da classe.
9. Atribua à variável nextNum o valor 1. Fizemos isso usando o nome da classe, o nome da variável e o operador de resolução de escopo.
10. Definindo a função estática getNextNum() fora da classe.
11. Especifique a ação a ser executada quando a função acima for chamada/invocada. Isso aumentará o valor da variável nextNum em 1.
12. Fim da definição da função getNextNum().
13. Chamando a função main(). O C++ a lógica do programa deve ser adicionada ao corpo desta função.
14. Usar um para laço para criar uma variável chamada contagem. O valor desta variável deve aumentar de 0 a 4. Após cada iteração, o valor da variável aumentará em 1.
15. Imprimindo o valor da variável nextNum junto com outro texto no console a cada iteração. O valor é acessado usando a função getNextNum().
16. Este C++ o programa deve retornar o valor após a conclusão bem-sucedida.
17. Fim da função main().

Perguntas Frequentes