2. Membros estáticos 2.1. Dados estáticos 2.2. Funções estáticas 2.3. Objectos estáticos

1. 2. Membros estáticos 2.1. Dados estáticos 2.2. Funções estáticas 2.3. Objectos estáticos Quando um dado de uma classe é declarado como static, significa que vai existir apenas uma cópia desse dado. No caso de membros não estáticos, a cada objecto é atribuído uma cópia desse dado.

2. 2.1. Dados estáticos. Ao declarar um dado de uma classe como estático, vai existir apenas uma cópia em memória desse dado. Desde modo, todos os objectos terão exactamente a mesma informação no que toca a essa variável. As questões de permissão de acesso são exactamente as mesmas que no caso de variáveis não estáticas. Os dados estáticos são acedidos da mesma forma que os dados não estáticos ou usando o seu nome completo, ou seja com o operador :: e o nome da classe, por exemplo: obj.static_var pobj->static_var my_class::static_var

3. o tipo do objecto deve ser repetido no ficheiro cpp! Em memória, existe apenas uma instância de um membro estático de uma classe independentemente do número de objectos desta classe. Esta instância deve ser obrigatoriamente definida (não basta apenas declará-la). A definição deve ocorrer fora da classe e só pode existir uma única definição. Esta definição normalmente faz-se no ficheiro cpp: class my_class { static int s_n; //… }; int my_class::s_n = 10;

4. int CStatic::s_nInstances = 0; const int CStatic::s_nMax = 5; const char CStatic::s_Nome [] = "CStatic"; CStatic::CStatic() { cout << s_Nome << ": " << ++s_nInstances << endl; if (s_nInstances >= s_nMax) cout << "criados " << s_nMax << "objectos" << endl; } CStatic::~CStatic() { cout << "~" <<s_Nome << ": " << --s_nInstances << endl; } class CStatic { static int s_nInstances; static const int s_nMax; public: CStatic(); virtual ~CStatic(); const static char s_Nome []; }; int main(int argc, char* argv[]) { cout << CStatic::s_Nome << endl; CStatic s1, s2, s3, s4, s5, s6, s7; return 0; }

5. CStatic CStatic: 1 CStatic: 2 CStatic: 3 CStatic: 4 CStatic: 5 criados 5 objectos CStatic: 6 CStatic: 7 ~CStatic: 6 ~CStatic: 5 ~CStatic: 4 ~CStatic: 3 ~CStatic: 2 ~CStatic: 1 ~CStatic: 0 int main(int argc, char* argv[]) { cout << CStatic::s_Nome << endl; CStatic s1, s2, s3, s4, s5, s6, s7; return 0; }

6. Funções-membro estáticas class CStatic { static int s_nInstances; static const int s_nMax; int m_nTeste; public: CStatic(); virtual ~CStatic(); static int GetMax(); int GetMax2(); const static char s_Nome []; }; int CStatic::GetMax() { int a = m_nTeste; // erro GetMax2(); // erro return s_nMax; } int CStatic::GetMax2() { m_nTeste = GetMax(); return s_nMax; } cout << CStatic::GetMax() << endl; CStatic s1, s2, s3, s4, s5, s6, s7; cout << s1.GetMax() << endl; Uma função estática só tem acesso aos membros estáticos da classe! Uma função estática não tem ponteiro this! Funções não estáticas têm acesso a todos os dados estáticos.

7. Os membros estáticos, sejam de dados ou funções, tem obrigatoriamente de ser definidos antes da sua primeira utilização. A definição deve ser feita antes da função main. class my_class { public: static ff() { return a; }; static f(my_class* p) { return p->b; } my_class::my_class(int B) : b(B) {} virtual ~my_class() {} private: int b; static a; }; int my_class::a=10; int main(int argc, char* argv[]) { cout << my_class::ff() << endl; // O resultado: 10 my_class M1(100); cout << M1.f(&M1) << endl; // O resultado: 100 return 0; }

8. Mesmo no caso da variável ser privada é necessário defini-la antes de ser usada. int main(int argc, char* argv[]) { cout << my_class::ff() << endl; // O resultado: 10 my_class M1(100); my_class M2(200); cout << M2.ff() << endl; // O resultado: 10 cout << M1.ff() << endl; // O resultado: 10 cout << M1.f(&M1) << endl; // O resultado: 100 return 0; }

9. 2.1. Funções estáticas. Naturalmente, as funções membro estáticas também vão ter apenas uma cópia em memória, partilhada por todos os objectos da classe, por isso, os membros dizem-se, por vezes, propriedades da classe. A acessibilidade a uma função estática é igual à de uma não estática. Acresce que também nos podemos referir a uma função estática usando o seu nome completo: nome_da_classe::nome_da_função_estática(...) As funções membros estáticas e não-estáticas numa mesma classe não podem ter o mesmo nome. A declaração de uma função membro ordinária supõe 3 coisas: 1. A função pode aceder a partes privadas da classe. 2. A função está confinada ao alcance (scope) da classe. 3. A função deve ser invocada sobre um objecto (tem um ponteiro this).

10. Se a função membro for declarada como estática então, apenas terá as primeiras duas propriedades. Uma função membro estática só pode aceder directamente a dados estáticos ou a outras funções membro estáticas, porque estas não têm o ponteiro this, fundamental para determinar a que objecto corresponde a chamada. As funções membro estáticas não podem ser virtuais.

11. As vantagens de declarar uma função como estática em lugar de a declarar como função global, reside no seguinte: 1. Não polui o espaço dos nomes. De notar que o nome da função estática inclui o nome da respectiva classe. 2. Torna possível controlar o seu acesso, declarando-o como público ou como privado ou como protegido na sua classe. class X {public: static int get_count() { return counter; } X() { ++counter; } virtual ~X() {} private: static counter; }; int X::counter = 0; int main(int argc, char* argv[]) { X array[9]; cout << X::get_count() << endl; // O resultado: 9 X new_array[6]; cout << X::get_count() << endl; // O resultado: 15 return 0; } 9+6=15

12. Singleton class CPresidente { static CPresidente single; char* m_sNome; CPresidente(char* n) { m_sNome = new char [strlen(n) + 1]; strcpy (m_sNome, n); }; CPresidente (const CPresidente& ); public: ~CPresidente() { delete [] m_sNome; } ; static CPresidente& GetInstance () { return single; } char* GetName() { return m_sNome; } }; vai existir apenas um objecto da classe CPresidente CPresidente::single ("Santos"); int main() { //CPresidente presidente = CPresidente::GetInstance(); cout << CPresidente::GetInstance().GetName() << endl; ...

13. Memória reservada dinamicamente para objectos-membros estáticos class CStatic { static A* m_aTeste; public: CStatic(); ~CStatic(); static void DeleteStatic(); }; class A { int m_nInt; public: A(int n = 4) : m_nInt(n) {}; ~A() {}; }; int main(int argc, char* argv[]) { atexit (CStatic::DeleteStatic); return 0; } A* CStatic::m_aTeste = new A(44); void CStatic::DeleteStatic() { delete CStatic::m_aTeste; }

14. 2.3. Objectos estáticos. Além dos membros de uma classe, também é possível utilizarmos os próprios objectos como estáticos. Se os objectos são globais, então os construtores destes objectos são chamados pela ordem com que aparecem as declarações dos objectos. Naturalmente os destrutores são chamados em ordem inversa. No caso dos objectos estáticos locais, os construtores são chamados apenas na primeira vez em que ocorre a definição do objecto e o objecto é destruído quando o programa termina, tal como qualquer outra variável estática.

15. Sumário da palavra chave static 1. Os membros de uma classe ao serem declarados como estáticos são considerados propriedades dessa classe e são partilhados entre todos os objectos da classe. 2. Só existe uma cópia dos membros estáticos, em memória. 3. A utilização de membros estáticos passa sempre pelos 2 passos: declaração e definição. 4. A definição de um membro estático é única e obrigatória mesmo para objectos privados. 5. Todos os membros estáticos (dados ou funções) têm de ser definidos antes da função main. 6. As variáveis membros estáticas não podem ser inicializadas na sua declaração. 7. Ao ser reservada memória para um membro de dados estático só quando o programa terminar é que vai ser de novo libertada. 8. Os membros estáticos são reconhecidos pelo seu nome completo, usando: nome_da_classe::variável_estática.

16. 9. Também se pode aceder a um objecto estático do mesmo modo que os objectos não estáticos: objecto_da_classe.variável_estática ponteiro_para_ objecto->variável_estática 10. Dentro da própria classe ou em classes derivadas pode-se simplificar o nome do membro omitindo o nome_da_classe:: 11. Não é possível ter membros estáticos e não estáticos com o mesmo nome dentro da mesma classe. 12. As funções membro estáticas não podem aceder implicitamente a membros não estáticos, porque não têm o ponteiro this. 13. Para aceder a membros não estáticos a partir de uma função membro estática, é preciso fazê-lo de forma explicita, obrigando o programador a indicar, caso a caso, a que objecto se quer referir. 14. As funções membro estáticos não podem ser virtuais, principalmente por causa de não terem o ponteiro this. 15. Os construtores de objectos estáticos globais são sempre chamados na ordem em que aparecem as declarações desses objectos.

17. 16. Os destrutores de objectos estáticos globais, são chamados na ordem inversa da anterior. 17. Os construtores dos objectos estáticos locais, são chamados uma única vez. 18. Os construtores dos objectos estáticos locais são chamados na primeira vez em que esses objectos são definidos. 19. Qualquer objecto estático é construído apenas uma vez, e é sempre destruído ao terminar o programa.

18. Porquê utilizar membros estáticos? As razões que nos podem levar a optar por usar membros estáticos em classes são, entre outras: 1. Reduzir o número de variáveis globais. 2. Tornar evidente quais os objectos estáticos que pertencem, do ponto de vista lógico, a uma determinada classe. As variáveis globais não permitem esse discernimento por exemplo. 3. Possibilidade de controlar a acessibilidade a partes da classe.

19. O que é importante: 1. Perceber o que são dados estáticos. 2. Perceber o que são funções estáticas. 3. Perceber o que são objectos estáticos. 4. Perceber qual é a diferença entre as duas seguintes notações: “reservação de memória estática” e “com visibilidade restrita”. 5. Perceber as respectivas regras da linguagem C++. 6. Estar apto a construir programas que utilizem dados estáticos, funções estáticas e objectos estáticos.