Aula c++ estruturas de dados

297 visualizações

Publicada em

Aula c++ estruturas de dados

Publicada em: Educação
0 comentários
0 gostaram
Estatísticas
Notas
  • Seja o primeiro a comentar

  • Seja a primeira pessoa a gostar disto

Sem downloads
Visualizações
Visualizações totais
297
No SlideShare
0
A partir de incorporações
0
Número de incorporações
3
Ações
Compartilhamentos
0
Downloads
8
Comentários
0
Gostaram
0
Incorporações 0
Nenhuma incorporação

Nenhuma nota no slide

Aula c++ estruturas de dados

  1. 1. Introdução ao C++ Estruturas de Dados
  2. 2. Visão Geral ● Histórico da Linguagem ● Programa C++: header, source – função main() ● GCC/G++ ● Arquivos objeto, bibliotecas dinâmicas e estáticas ● #include, #define, namespaces, typedefs ● Ponteiros, Referências, arrays, primitivas, estruturas de controle.
  3. 3. Características do C++ ● Linguagem multi-paradigma ● Programação Procedural ● Orientação a objetos ● Meta Programação ● Desalocação memória – Decisão cabe ao programador
  4. 4. Histórico ● Criada por Bjarne Stroustrup em 1979 no Bell Labs da AT&T e inicialmente chamada de “C with classes”. ● Em 1983 passou a ser chamada C++. ● Ao longo do tempo incorporou novas funcionalidades como: – herança múltipla, – sobreescrita de operadores, – templates – entre outras coisas que veremos ao longo do curso.
  5. 5. Histórico ● Possui compatibilidade com C – um compilador C++ deve compilar um programa escrito em C. ● Em 1998 foi definido um padrão ISO para a linguagem, revisado em 2003 e novamente revisado em 2011.
  6. 6. GCC/G++ ● GNU Compiler Collection ● Compilador originalmente desenvolvido focando a linguagem C, chamava-se GNU C Compiler. ● Ao longo do anos passou a contemplar outras linguagens, como C++.
  7. 7. Programa C++ - Arquivos ● Header – Definições / Visível a outros headers ● Sources – Corpo de métodos e funções ● Função Main – Função inicial evocada pelo executável
  8. 8. Programa C++ - Hello World //file – hello_world.cc #include <iostream> int main(){ std::cout<<”Hello World!”<<std::endl; return 0; }
  9. 9. Programa C++ - Compilando o Hello World $ g++ hello_world.cc -o hello_world $ ./hello_world #executando $ Hello World! #resultado
  10. 10. Bibliotecas Estáticas e Dinâmicas ● Estática: – o código executável copia os trechos com instruções que utiliza. O executável pode ficar grande. ● Dinâmica: – A linkagem ocorre em tempo de execução. O executável acessa a biblioteca durante as chamadas de funções.
  11. 11. Diretivas ● Informações sobre arquivos, símbolos e tipos interpretadas no pré-processamento da compilação. ● #include – Avisa ao compilador quais headers ele precisa carregar para pré-processar as instruções do arquivo em questão, mais ou menos como o import do Java – Pode ser utilizado tanto no header quanto no source. Evite incluir includes desnecessário no header, torna a etapa de análise mais custosa.
  12. 12. Diretivas - Include #include “structs/my_struct.h” int main(){ myStruct ms; } $ g++ include.cc #include “my_struct.h” int main(){ myStruct ms; } $ g++ include.cc -I structs
  13. 13. Diretivas - Include ● #include <list> – Procura o header nos diretórios do sistema e aqueles passados como parâmetro ao compilador. ● #include “my_struct.h” – Procura o header primeiro no diretório que contém o arquivo sendo compilado, e depois nos diretórios do sistema e aqueles passados como parâmetro ao compilador.
  14. 14. Diretivas: #define ● Atribui um valor a um símbolo. ● Cada vez que o pré-processador encontra este símbolo no código ele substitui o símbolo por esse valor. #define max_iterations 1000
  15. 15. Diretivas: #define ● Também pode ser usado para definir “macros”, pequenos trechos de código que são colados cada vez que o pré-processador identifica o símbolo associado. #define getmax(a,b) ((a)>(b)?(a):(b)) int main(){ int x = 10; int y = getmax(x,5); //y vale 10 }
  16. 16. Diretivas: #define #define getmax(a,b) ((a)>(b)?(a):(b)) /*int main(){ int x = 10; int y = getmax(x,5); //y vale 10 }*/ int main(){ int x = 10; int y = ((x)>(5)?(x):(5)); //y vale 10 }
  17. 17. Diretivas: #define ● Quando e por que usar Macros? – Quando o código é pequeno e existe um real conhecimento do fluxo das instruções. – Desgraças podem acontecer e o código colado pelo pré-processador pode tomar um rumo inesperado. – Como o código é “colado”, não existe ônus de ter que colocar o endereço da instrução na pilha como em uma chamada de função. Em uma próxima aula discutiremos isso ao ver funções inline.
  18. 18. namespace ● Estabelecem o domínio ao qual declarações (classes, structs, metaclasses) fazem parte. ● É utilizado para organizar o código em diferentes domínios, que dependendo da estrutura de diretórios do código fonte, podem apresentar uma semelhança com a organização em pacotes do java. ● Também serve para eliminar ambigüidades.
  19. 19. namespace #include <list> #include “my_list.h” int main(){ std::list<int> list1; list<int> list2; }
  20. 20. using ● Usada para suprimir a declaração de namespaces no código #include <list> #include <iostream> #include “my_list.h” using namespace std; int main(){ cout<<”hello world”<<endl; //ok! list<int> list1; //ambigüidade list<int> list2; //ambigüidade }
  21. 21. Diretivas: namespace #include <list> #include “data_structure/my_list.h” #include <iostream> using namespace std; int main(){ cout<<”hello world”<<endl; //ok! std::list<int> list1; //ok data_structure::list<int> list2; //ok }
  22. 22. typedef ● Define um tipo a partir de outro existente. #include <list> #include “data_structure/my_list.h” #include <iostream> using namespace std; typedef data_structure::list<int> mylist; int main(){ cout<<”hello world”<<endl; //ok! list<int> list1; //ok - std::list mylist list2; //ok - data_structure::list }
  23. 23. Tipos Primitivos ● Inteiros com e sem sinal e bits de representação: – char, unsigned char: 8 bits – short, unsigned short: 16 bits (mínimo) – int, unsigned int: 32 bits (mínimo) – long, unsigned long: 32 bits (mínimo) – long long, unsigned long long: 64 bits (mínimo)
  24. 24. Tipos Primitivos ● Ponto flutuante e bits de representação: – float: 32 bits – double: 64 bits
  25. 25. Ponteiros e referências ● int a = 10; //aloca espaço para a variável a ● int * b = &a; ● /*cria um ponteiro b para números inteiros. Um ponteiro aloca espaço para e o reserva para armazenar um endereço. */ ● Memória: 10 6
  26. 26. Variáveis, Ponteiros e Referências #include <iostream> int main(){ int a = 5; int * b = &a; std::cout<<”O valor de a é”<<a<<” o endereço de a é“<<&a<<std::endl; std::cout<<”b contém o endereço”<<b<<” o conteúdo do endereço de b é:”<<*b<<std::end; }
  27. 27. Variáveis, Ponteiros e Referências *b += a; a *= (*b); std::cout<<a<<std::endl; //O que foi impresso??
  28. 28. Variáveis, Ponteiros e Referências ● Uma referência é como um “apelido” a uma outra variável. ● Tal qual um ponteiro, a referência apenas “referencia” algum endereço de memória. ● Uma vez criada, não há como distinguir entre uma referência e o dado por ela referenciado. ● Adicionalmente, uma referência só pode “apontar para” um único dado durante sua existência.
  29. 29. Variáveis, Ponteiros e Referências ● int main(){ int a = 3; int b = 4; int * p = &b; int & r = b; r += 2; // b agora vale 6 p = &a; // p aponta para “a” r = a; // b agora vale 3; r ainda referencia b. }
  30. 30. Arrays – Alocação Estática int main(){ int a[5]; a[0] = 0; a[4] = -3; }
  31. 31. Arrays – Alocação dinâmica ● int main(){ int a =5; int * b = new int[a]; }
  32. 32. Arrays - Iterando int main(){ int a = 5; int * b = new int[a]; int * it = &b[0]; (*it++) = 8; //Quais operações são executadas nessa linha? }
  33. 33. Arrays - Iterando int * it = &b[0]; //faz o iterador apontar para o endereço da posição 0 de b; //int * it = b; (*it++) = 8; //(*it) = 8 atribui o valor 8 a posição 0 do array b incrementa o iterador, fazendo-o apontar para a posição 1 de b
  34. 34. Arrays - Iterando int * it = &b[0]; //faz o iterador apontar para o endereço 9; (*it) = 8; //atribui o valor 8 ao dado contido no endereço 9 it++;//incrementa o iterador, fazendo-o apontar para o endereço 10 it
  35. 35. Statements if( expressão booleana ){ //se a expressão é verdadeira executa este bloco } else{ //se a expressão é falsa executa este bloco }
  36. 36. Statements while( expressão booleana ){ //enquanto a expressão for verdadeira executa este bloco } do{ //enquanto a expressão for verdadeira executa este bloco }while( expressão booleana );
  37. 37. Statements for( inicialização de variáveis ; expressão ; operação executada a cada loop ){ //Para cada vez que a expressão for verdadeira, executa esse bloco. Se a expressão for falsa, sai do bloco. }
  38. 38. enumerations ● Coleção de constantes definidas pelo usuário enum Paises{ Argentina, Brasil, China, Estados Unidos, Inglaterra }
  39. 39. enumerations ● Coleção de constantes definidas pelo usuário enum Paises{ Argentina=9, Brasil=6, China=5, Estados Unidos=13, Inglaterra=10 }
  40. 40. switch case int a; switch (a){ case:1 //se a vale 1, executa este bloco break; case:2 //se a vale 2, executa este bloco break; default: //se a vale qualquer outro inteiro, executa este bloco }

×