Embed Size (px)
Citation preview
Técnicas 1
Paradigmas e Ferramentas de Engenharia de Software
Parte ITécnicas de Programação em C++
Técnicas 2
INPE
Objetivo
Discutir técnicas de programação em C++ Rever as principais características da linguagem Discutir aspectos conceituais de projeto de classes
Temas apresentados Classes x objetos Forma canônica normal de uma classe Templates e Ponteiros “inteligentes” Técnicas de projeto de conjunto de classes
Técnicas 3
INPE
Referências
Livros básicos “Effective C++”, S.Meyers “More Effective C++”, S.Meyers “Advanced C++ Programming Styles and Idioms”, J. Coplien
Referências adicionais “C++ FAQs”, M. Cline and G.Lomow “C++ Strategies and Techniques”, R. Murray “C++ Programming Style”, T. Cargill
Introdução 4
INPE
Motivação
O que é C++ ? Uma melhoria da linguagem C com maior controle de tipos ? Uma linguagem para programação orientada-a-objetos ? Uma linguagem que incorpora avanços de engenharia de
software nos anos recentes ? Uma linguagem que suporta múltiplos estilos de
programação ? Uma linguagem que está em vistas de extinção e logo sera
totalmente substituída por JAVA ?
Técnicas 5
INPE
Projeto de Classes
Classe abstração - conceito fundamental em programação classe - expressão de abstração em C++ descreve as propriedades comuns dos objetos instanciados
Características “classes são tipos reais, são como “int” e “float” (Meyers)”. “projetar uma classe envolve descreve todas as situações
possíveis de seu uso.” “a interface de cada classe deve ser completa e mínima”.
Técnicas 6
INPE
Projeto de Classes: Componentes
construtores e destrutores construtor de cópia operador = (atribuição)
funções da classe membros da classe funções “amigas” (“friends”) funções globais que utilizam a classe
parâmetros das funções referências x ponteiros
Técnicas 7
INPE
Forma Canônica “Normal”
class Exemp {
public:
Exemp(); // construtor
virtual ~Exemp(); // virtual se classe base
protected:
// Dados que meus filhos precisam
private:
// Meus dados pessoais
Exemp (const Exemp& rhs) {} // construtor de copia
Exemp& operator= (const Exempl& rhs) {}// atribuicao
}
Técnicas 8
INPE
Projeto de Classes
class String {
private:
char *data_;
public:
String ( const char* value )
{ if (value) {
data_ = new char[strlen(value) + 1];
strcpy ( data_, value) }
else data_ = new char[1]; *data_ = ‘\0’; }
~String() { delete [] data_;}
} quais os problemas desta classe ?
Técnicas 9
INPE
Operadores Implícitos em C++
C++: implementação “default” do construtor de cópia e do operador= ( cópia membro-a-membro)
Exemplo:String a (“Adeus”);
String b (“Mundo Cruel”);
String c;
c = b = a; // E agora ???
a
data
Adeus MundoCruel
data
ba
data
Adeus MundoCruel
data
b
ANTESDEPOIS
Técnicas 10
INPE
Operadores Implícitos em C++
Regra: Implemente o construtor de cópia e o operador= para todas
as classes com alocação dinâmicaString::String ( const String& rhs )
{ if ( rhs.data_ )
data_ = new char [ strlen (rhs) + 1 ];
strcpy ( data_, rhs.data_ );
else
data_ = 0;
}
Técnicas 11
INPE
Operadores Implícitos em C++
Operador= Lembre de checar sobre auto-referência Retorne uma referência ao objeto
String&
String::operator= (const String& rhs)
{
if ( this == &rhs )
return *this;
if ( rhs.data_ )
delete [] data_;
data_ = new char [ strlen (rhs) + 1 ];
strcpy ( data_, rhs.data_ );
else data_ = 0;
return *this;
}
Técnicas 12
INPE
Operadores Implícitos em C++
Operador = Exemplo:
string a (“Adeus Mundo Cruel”);
// Auto-referencia ( requer teste do operador = )
a = a ;
string b,c,d;
// Cadeias ( requerem retorno de referencia)
b = c = d = a;
// Compilador implementa
// b.operator= (c.operator= (d.operator = (a))));
Técnicas 13
INPE
Funções de classe: Alternativas
membros da classe
funções amigas funções globais funções estáticas
Técnicas 14
INPE
Referências x ponteiros
Referências em C++ nome “alternativo” para um objeto
string collor = “Fernando Collor”;
string& cassado = collor; // aponta para o mesmo endereco
Usos de referências passagem de parâmetros em métodos : evita instanciacao
void Exemp::Metodo (const C1& obj1, const C2& obj2 );
retorno de valores (e.g. dados de classe)class Aluno {
private:
string nome_;
public:
string& Nome() const
{ return nome_; }
Técnicas 15
INPE
Referências x Ponteiros
Diferências semânticas em passagem de parâmetros Passagem por referência
mantém a “propriedade” do objeto Passagem por ponteiro
transmite o direito de “propriedade” do objeto ex:
class Aluno {
private:
string nome_;
public:
string& Nome() const { return nome_; }
char* Nome() { return nome_; }
Técnicas 16
INPE
Referências x Ponteiros
Regras passe e retorne parâmetros por referência constante sempre que
possível retorne valores (e não referências) quando criar objetos
ex:class Complex {
private:
double real_, im_;
public:
Complex& operator + ( const Compl& lhs,
const Compl& rhs )
{ Complex result ( lhs.real_ + rhs.real_ ,
lhs.im_ + rhs.im_ );
return result;
}
Técnicas 17
INPE
Tipos parametrizados (“templates”)
Implementam estruturas de dados e algoritmos genéricos (independentes dos tipos de objetos)
Código gerado em tempo de compilação Ferramentas extremamente poderosas de programação Definição
template <class T>
class Stack {
private:
// detalhes omitidos…
public:
Stack();
bool IsEmpty();
void Push ( const T& obj);
T Pop();
}
Técnicas 18
INPE
Tipos parametrizados (“templates”)
Implementaçãotemplate <class T>
void
Stack::Push ( const T& obj )
{ myList_.push_front ( obj ); }
template < class T>
T
Stack::Pop ()
{ return myList_.top ( obj );
UsoStack <int> pilhaDeInteiros;
Stack <string> pilhaDeNomes;
Técnicas 19
INPE
Tipos Parametrizados (“templates”)
STL - Standard Template Library parte do padrão C++ (aprovado em 1997) elementos da STL: componentes, iteradores e algoritmos
Componentes organizações de coleções de objetos
list, set, stack, map, multiset, multimap
Iteradores ponteiros que percorrem os componentes
Algoritmos funções que são aplicáveis aos componentes
find, erase, sort, merge, push, pop
Técnicas 20
INPE
Tipos Parametrizados (“templates”)
“Ponteiros Inteligentes” - auto_ptr objetos projetados para funcionar como ponteiros maior funcionalidade
Controle sobre comportamento de ponteiros construção e destruição - elimina vazamento de recursos cópia e atribuição dereferenciamento - decisão sobre o acesso ao ponteiro
verdadeiro Uso:
tradicional Canvas* c = new Canvas;
inteligenteauto_ptr<Canvas> canvObj = new Canvas;
Técnicas 21
INPE
Projeto de Classes: Alternativas
Como construir um conjunto de classes ? Alternativas de projeto de classes
Usar diferentes parâmetros nos construtores Estabelecer hierarquia de classes (“herança” ou “IS_A”) Fazer composição de classes (“HAS_A”) Parametrizar tipos (uso de “templates”)
Quando usar cada uma destas técnicas ?
Técnicas 22
INPE
Projeto de Classes: Recomendações
Programe para uma interface, nunca para uma implementação (GoF)
Derive, sempre que possível, de classes abstratas (Myers, Struostrup)
Prefira agregação de objetos à herança (GoF)
Parametrize algoritmos e estruturas genéricas com “templates” (Stepanov)
Técnicas 23
INPE
Classes: Herança x Composição
Herança expressar interfaces comuns e comportamento diferente classes base definem parte do comportamento das classes
derivadas definida em tempo de compilação herança quebra o princípio da modularidade solução: herdar de classes base abstratas e procurar não
estender a interface Composição
definida em tempo de execução requer o respeito a modularidade permite o uso de delegação
Técnicas 24
INPEClasses: Herança x Tipos Parametrizados
Templates expressam nomes e estruturas de implementação comuns definidos em tempo de execuçãotemplate <class T>
class Image {
public:
Image ( int nlin, int ncols, const string& fileName );
~Image ();
T& operator() (int lin, int col){
return ptrMemory_ [ lin*nLines_ + col ]; }
private:
T* ptrMemory_;
int nLines_, nCols_;
string fileName_;
}
