Renato Dourado Maia
Universidade Estadual de Montes Claros Engenharia de Sistemas
Classes e Objetos
Programação Orientada a
Objetos
Da Unidade III – Classes e Objetos, já foram tra- balhados os seguintes tópicos:
Implementando classes e objetos em C++.
Atributos e métodos: controle de acesso e encapsula- mento.
Inicialização e destruição.
Sobrecarga de funções e argumentos default.
Constantes e funções inline.
Controle de visibilidade: começamos na aula passada, e continuaremos na aula de hoje...
Em que Parte do Conteúdo
Estamos?
C++ fornece um mecanismo – o Namespace – para agrupar logicamente nomes:
Isso significa que se variáveis, funções, classes, enfim, quaisquer declarações, forem relacionadas entre si, elas poderão ser colocadas em um mesmo espaço de nomes para expressar esse fato.
Existe um outro mecanismo de agrupamento físi- co que é a utilização de arquivos, e os Namespa- ces vêm adicionar a esse mecanismo o agrupa- mento lógico.
Namespaces
A sintaxe de criação de um namespace parece com a da classe:
namespace MyLib { // Declarations }
int main() {} ///:~
Isso produz um novo namespace contendo as de- clarações que forem feitas.
Namespaces
Existem algumas diferenças em relação às defini- ções de classes:
A definição de um namespace pode aparecer apenas no escopo global.
Não é necessário utilizar um “;” após a definição do na- mespace.
A definição de um namespace pode ser continuada em múltiplos arquivos de cabeçalho.
Namespaces
//: C10:Header1.h
#ifndef HEADER1_H
#define HEADER1_H namespace MyLib { void f();
// ...
}
#endif // HEADER1_H ///:~
//: C10:Header2.h
#ifndef HEADER2_H
#define HEADER2_H
#include "Header1.h"
// Add more names to MyLib
namespace MyLib { // NOT a redefinition!
void g();
// ...
}
#endif // HEADER2_H ///:~
//: C10:Continuation.cpp
#include "Header2.h"
int main() {
MyLib::f();
MyLib::g();
} ///:~
namespace X { class Y { public:
void f();
};
class Z;
void func();
}
class X::Z { int u, v, w;
public:
Z(int i);
int g();
};
X::Z::Z(int i) { u = v = w = i; }
int X::Z::g() { return u = v = w = 0; }
void X::func() { X::Z a(1);
a.g();
}
int main(){
X::Z z1(2), z2(4);
X::Y y1, y2;
y1.f();
z1.g();
X::func();
} ///:~
Objetos que estão num namespace podem ser utilizados!!!
Um namespace é um escopo com nome: quanto maior o programa, mais úteis são os namespa- ces, pois eles expressam a separação lógica de suas partes.
Idealmente, toda entidade em um programa deve estar em algum namespace, para indicar o seu papel lógico no programa. A exceção é main(), que deve ser global...
Namespaces
namespace Int {
enum sign { positive, negative };
class Integer { int i;
sign s;
public:
Integer(int ii = 0) : i(ii),
s(i >= 0 ? positive : negative) { }
sign getSign() const { return s; } void setSign(sign sgn) { s = sgn; } // ...
};
}
namespace Math {
using namespace Int;
Integer a, b;
Integer divide(Integer, Integer);
// ...
}
A diretiva using torna todos os nomes de um namespace disponíves
num determinado contexto...
A declaração using permite que se crie um sinônimo local para um nome, o que é util quando não se deseja tornar
disponíveis todos os nomes de um namespace...
namespace U {
inline void f() {}
inline void g() {}
}
namespace V {
inline void f() {}
inline void g() {}
}
void h() {
using namespace U; // Using directive using V::f; // Using declaration
g(); // Calls U::g();
f(); // Calls V::f();
U::f(); // Must fully qualify to call }
O objetivo dos namespaces é expressar uma es- trutura lógica, sendo que a forma mais simples de estrutura para a qual eles podem ser utiliza- dos é a distinção entre o código escrito por uma pessoa e o escrito por outra.
Quando se utiliza um único espaço de nomes glo- bal, é desnecessariamente difícil compor um pro- grama composto de partes separadas.
O problema é que cada parte pode definir os mesmos nomes, o que pode causar colisões ...
Namespaces
Colisão de nomes:
Namespaces
// meu.h
char f(char);
int f(int);
class String { /* ... */ };
// seu.h
char f(char);
double f(double);
class String { /* ... */ };
Fica impossível utilizar simultaneamente meu.h e seu.h sem modificações... O que fazer?
A solução para a colisão é separar os espaços de nomes:
Namespaces
namespace Meu { char f(char);
int f(int);
class String { /* ... */ };
}
namespace Seu { char f(char);
double f(double);
class String { /* ... */ };
}
Utiliza-se Meu e Seu por qualificação explícita, declarações using ou diretivas using.
Namespaces
char a, c;
using Seu::String; // declaração using String d;
Meu::f(c);
Seu::f(a); // qualificação explícita
namespace String_dele { class String{ /* ... */};
} namespace Vetor_dela { class Vector {/* ... */};
} namespace Minha_lib {
using namespace String_dele; // diretiva using using namespace Vetor_dela; // diretiva using
void minha funcao(Vector&); // declaração de função } void f() {
Minha_lib::String s = "Pixinguinha";
} using namespace Minha_lib; // diretiva using void g(Vector &vs) {
// ...
minha_funcao(vs);
}
Namespaces podem ser compostos, para gerar novos Namespaces:
Regras importantes:
Não utilize diretivas using em arquivos .h: utilize apenas nos .cpp, pois o seu alcance fica mais limitado.
Se houver problemas de nomes duplicados quando utili- zando mais de uma diretiva using nos .cpp, comece a e- fetuar a seleção por declarações using.
Nos .h, ou utilize as qualificações explícitas, para aces- sar determinados nomes encapsulados em namespaces, ou utilize declarações using, para introduzir apenas os nomes selecionados no escopo.
Namespaces
That`s All Folks!
Esta apresentação é uma adaptação do material originalmente desenvolvido pelo professor Renato Cardoso Mesquita, do Departamento de Engenha- ria Elétrica da Universidade Federal de Minas Ge- rais.
Importante
http://www.cpdee.ufmg.br/~renato/
