2. Membros estáticos2.1. Dados estáticos2.2. Funções estáticas2.3. Objectos estáticos

Quando um dado de uma classe é declarado como static, significaque 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.1. Dados estáticos.Ao declarar um dado de uma classe como estático, vai existirapenas uma cópia em memória desse dado. Desde modo, todosos objectos terão exactamente a mesma informação no que tocaa essa variável.

As questões de permissão de acesso são exactamente as mesmasque no caso de variáveis não estáticas.

Os dados estáticos são acedidos da mesma forma que os dadosnão estáticos ou usando o seu nome completo, ou seja com o

operador :: e o nome da classe, por exemplo:

obj.static_varpobj->static_varmy_class::static_var

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;

o tipo do objecto deve ser repetido no ficheiro cpp!

class CStatic { static int s_nInstances; static const int s_nMax;public: CStatic(); virtual ~CStatic();

const static char s_Nome [];};

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;}

int main(int argc, char* argv[]){ cout << CStatic::s_Nome << endl; CStatic s1, s2, s3, s4, s5, s6, s7; return 0;}

CStaticCStatic: 1CStatic: 2CStatic: 3CStatic: 4CStatic: 5criados 5 objectosCStatic: 6CStatic: 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;}

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;

}

Funções-membro estáticas

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.

Os membros estáticos, sejam de dados ou funções, temobrigatoriamente de ser definidos antes da sua primeira

utilização. A definição deve ser feita antes da função main.

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: 100return 0;

}

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;

Mesmo no caso da variável ser privada é necessário defini-la antesde 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: 10cout << M1.f(&M1) << endl; // O resultado: 100return 0;

}

2.1. Funções estáticas.Naturalmente, as funções membro estáticas também vão ter apenasuma 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áticausando 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 classenã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).

Se a função membro for declarada como estática então, apenasterá as primeiras duas propriedades.

Uma função membro estática só pode aceder directamente a dadosestáticos ou a outras funções membro estáticas, porque estas nãotêm o ponteiro this, fundamental para determinar a que objecto

corresponde a chamada.

As funções membro estáticas não podem ser virtuais.

As vantagens de declarar uma função como estática em lugar de adeclarar como função global, reside no seguinte:

1. Não polui o espaço dos nomes. De notar que o nome dafunção estática inclui o nome da respectiva classe.

2. Torna possível controlar o seu acesso, declarando-o comopú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: 15return 0;}

9+6=15

Singletonclass 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; }};

CPresidente CPresidente::single ("Santos");

int main(){

//CPresidente presidente = CPresidente::GetInstance();cout << CPresidente::GetInstance().GetName() << endl;...

vai existir apenas um objecto da classe

class A {

int m_nInt;public:

A(int n = 4) : m_nInt(n) {};~A() {};

};

class CStatic {

static A* m_aTeste;public:

CStatic();~CStatic();static void DeleteStatic();

};

A* CStatic::m_aTeste = new A(44);

void CStatic::DeleteStatic(){

delete CStatic::m_aTeste;}

int main(int argc, char* argv[]){

atexit (CStatic::DeleteStatic);

return 0;}

Memória reservada dinamicamente para objectos-membros estáticos

2.3. Objectos estáticos.

Além dos membros de uma classe, também é possível utilizarmosos próprios objectos como estáticos. Se os objectos são globais, entãoos construtores destes objectos são chamados pela ordem com que

aparecem as declarações dos objectos. Naturalmente os destrutoressão chamados em ordem inversa. No caso dos objectos estáticoslocais, os construtores são chamados apenas na primeira vez em

que ocorre a definição do objecto e o objecto é destruído quando oprograma termina, tal como qualquer outra variável estática.

Sumário da palavra chave static

1. Os membros de uma classe ao serem declarados como estáticossão considerados propriedades dessa classe e são partilhados entretodos 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 mesmopara objectos privados.5. Todos os membros estáticos (dados ou funções) têm de serdefinidos antes da função main.6. As variáveis membros estáticas não podem ser inicializadas nasua declaração.7. Ao ser reservada memória para um membro de dados estáticosó 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.

9. Também se pode aceder a um objecto estático do mesmo modoque os objectos não estáticos:

objecto_da_classe.variável_estáticaponteiro_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 implicitamentea 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, obrigandoo 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 semprechamados na ordem em que aparecem as declarações desses objectos.

16. Os destrutores de objectos estáticos globais, são chamados naordem inversa da anterior.17. Os construtores dos objectos estáticos locais, são chamadosuma única vez.18. Os construtores dos objectos estáticos locais são chamados naprimeira 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.

Porquê utilizar membros estáticos?

As razões que nos podem levar a optar por usar membrosestá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 partesda classe.

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.