Tag: c++11
Questões de C++ (parte3)
#include <iostream> #include <string> #include <vector> using namespace std; //----------------------------------pergunta 1 //construir o construtor por cópia class Funcionario{ /* ... */ }; class Reuniao { //só faz uso das fichas funcionarios, convocados vector <Funcionario*> convocados; //é da posse exclusiva da Reuniao, ordemDeTrabalhos vector <string*> ordemDeTrabalhos; public: //.. ~Reuniao() { for(string * s: ordemDeTrabalhos) { delete s; } } //do construtor por cópia Reuniao(const Reuniao & ob) { convocados = ob.convocados; //copiar vector Funcionario //porque é posse exclusiva, podes querer modificar for(string * o : ordemDeTrabalhos) //copiar as strings { ordemDeTrabalhos.push_back(new string(*o)); } } }; int main() { } //regra dos três: //destrutor //construtor por cópia //operador de cópia //https://pt.wikipedia.org/wiki/Regra_dos_tr%C3%AAs_(C%2B%2B)#Regra_dos_Tr%C3%AAs
#include <iostream> #include <string> #include <vector> using namespace std; //----------------------------------pergunta 2 class Num { int n; public: Num() { n = 0; } void setN(int nn) { n = nn; } int getN()const { return n; } }; void f(const Num * p) { p->setN(5); //<- erro //é const o Num //logo não são do mesmo tipo p = new Num(); } void g(Num * const p) { p->setN(5); p = new Num(); //<- erro //é const o p //logo não pode ser modificado } int main() { Num ob; ob.setN(4); f(&ob); g(&ob); }
#include <iostream> #include <string> #include <vector> using namespace std; //----------------------------------pergunta 3 class Erro { string msg; public: Erro(const string & s = "") :msg(s) { } string what() { return msg; } }; void calculaArea(int lado) { try { if(lado < 0) { throw Erro("lado negativo"); }else if(lado >10) { throw new string("lado superior ao limite"); } }catch(Erro & e) { lado = 0; }catch(string & e) { lado = 10; } cout << "area = " << lado * lado << ";"; } int main() { try { calculaArea(-2); cout << "depois; "; }catch (Erro & e) { cout << "catch main; \n"; }catch(string & e) { cout << "catch main; \n"; } cout << "fim main;\n"; } ouput: area = 0 depois; fim main
#include <iostream> #include <string> #include <vector> using namespace std; //----------------------------------pergunta 4 class Canideo { int peso; string dieta; public: Canideo(int a, string b = "Carne"): peso(a), dieta(b) { } Canideo() = default; virtual ~Canideo() { }; virtual double dose() const { return peso * 0.1; }; int getPeso() const { return peso; } string getDieta() const { return dieta; } }; class Cao: public Canideo { string nome; public: Cao(int a, string b = "Racao", string c = "Bobi") : Canideo(a,b), nome(c) { } virtual double dose() const override { return getPeso() * 0.05; } }; class Lobo: public Canideo { string habitat; public: Lobo(int a, string b = "galinha", string c = "floresta") : Canideo(a), habitat(c) { } }; int main() { Lobo a(120); Canideo* c = new Cao(20); cout << a.getDieta() << " " << c->getDieta() << " "; cout << a.dose() << c->dose() << endl; } output carne racao 12 1 //A especificação = default após a declaração do construtor por omissão, //indica ao compilador para disponibilizar o construtor por omissão, trivial //O construtor por omissão, trivial faz as seguintes ações: //É aplicada a inicialização dos membros variáveis, feita na declaração //Relativamente aos restantes membros variáveis: //Os membros variáveis de tipo primitivo não são inicializados //Os membros que são objetos de classes são inicializados pelos seus //construtores por omissão //Se a classe for derivada de uma classe base, o subobjeto da classe base //é inicializado pelo construtor por omissão desta classe base
#include <iostream> #include <string> #include <vector> using namespace std; //----------------------------------pergunta 5 //acrescentar um novo tipo de cao, o Galgo //que tem um determinada velocidade, indicada na criação deste objecto //a velocidade tem impacto na sua dose diaria //qual a solução? //a) criar uma classe derivada de Canideo com atributo velocidade. esta classe deve //ter um construtor e tem que redefinir o método virtual dose() //b) criar uma classe derivada de Cao com atributo velocidade. esta classe //deve ter um construtor e tem que redefinir o método virtual dose(); //c) criar uma classe derivada de Cao com atributo velocidade. esta classe //deve ter um construtor, mas pode utilizar o método virtual dose() da classe //base //d) acrescentar um atributo booleano tipo à classe Cão, indicando se os //objectos são Galgos. adpatar o método dose() desta classe, para calcular //a dose diária correta se os cães em questão forem galgos. class Canideo { int peso; string dieta; public: Canideo(int a, string b = "Carne"): peso(a), dieta(b) { } Canideo() = default; virtual ~Canideo() { }; virtual double dose() const { return peso * 0.1; }; int getPeso() const { return peso; } string getDieta() const { return dieta; } }; class Cao: public Canideo { string nome; public: Cao(int a, string b = "Racao", string c = "Bobi") : Canideo(a,b), nome(c) { } virtual double dose() const override { return getPeso() * 0.05; } }; class Galgo : public Cao { int velocidade; public: Galgo(int a, int v, string b = "Racao") : Cao(a,b), velocidade(v) { } virtual double dose() const override { return getPeso() * 0.05 / velocidade; } }; resposta: b) criar uma classe derivada de Cao com atributo velocidade.esta classe deve ter um construtor e tem que redefinir o método virtual dose(); //porque é um tipo Cao, e a velocidade afecta paenas o tipo Galgo
Questões de C++ (parte2)
#include <iostream> #include <string> #include <vector> using namespace std; //----------------------------------pergunta 1 class Jogador { public: void treinar() { cout << "\n treinar"; } virtual void jogar() { cout << "\n jogar"; } }; class Defesa: public Jogador { public: void treinar(){ cout << "\n treinar defesa"; } void jogar() override { cout << "\n jogar defesa"; } //override: redefinição de uma função virtual da classe base }; class Atacante : public Jogador { public: void treinar() { cout << "\n treinar ataque"; } void jogar() override { cout << "\n jogar ataque"; } }; class PontaDeLanca : public Atacante { }; int main() { vector<Jogador*> jogadores; jogadores.push_back(new Defesa); jogadores.push_back(new Atacante); jogadores.push_back(new PontaDeLanca); for(Jogador * j: jogadores) { j->treinar(); j->jogar(); } } output: treinar jogar defesa treinar jogar ataque treinar jogar ataque
#include <iostream> #include <string> #include <vector> using namespace std; //----------------------------------pergunta 2 class Ponto { int x, y; public: Ponto(int x0 = 0, int y0 = 0) { x = x0; y = y0; } }; class Figura { string nome; public: Figura(const string & n) { nome = n; } void setNome(const string &n ) { nome = n; } }; class Circulo : public Figura { Ponto centro; const int raio; public: //qual sera o construtor.. //resposta1: Circulo(int x0, int y0, int r) : centro(x0, y0), raio(r), Figura("circulo") { }; //resposta2 Circulo(int r) : raio(r), Figura("circulo") { }; }; int main() { }
#include <iostream> #include <string> #include <vector> using namespace std; //----------------------------------pergunta 3 class SerVivo { public: virtual void f() = 0; virtual void g() = 0; }; class Animal : public SerVivo { public: virtual void h() = 0; void f() override { /* ... */} }; class Ave : public Animal { public: //a classe Ave tem que ser concreta //... //sabe-se que: //Uma classe abstrata é uma classe para a qual um ou mais //métodos são declarados, mas não definidos //O polimorfismo permite que classes abstratas consigam //receber comportamentos através de classes concretas //As classes derivadas das classes abstratas são conhecidas //como classes concretas //f e g são funções virtuais puras logo têm de ser definidas //em Ave para que esta classe seja concreta virtual void g(){} virtual void h() {} }; int main() { }
#include <iostream> #include <string> #include <vector> using namespace std; //----------------------------------pergunta 4 class Erro { string msg; public: Erro(const string& s): msg(s){} string what() { return "(1) erro " + msg; } }; void funcao() { try { cout << "(2) antes; "; throw Erro("(3) em funcao ..."); cout << "(4) depois; "; }catch (Erro & e) { cout << e.what() << "(5) ;"; }catch(string & e) { cout << "(6) catch string;"; } cout << "(7) fim funcao; "; } int main() { try { funcao(); } catch (Erro & e) { cout << "(8) catch erro main;"; } cout << "(9) fim main; \n"; } output: (2) antes; (1) erro (3) em funcao ... (5); (7) fim funcao; (9) fim main;
#include <iostream> #include <string> #include <vector> using namespace std; //----------------------------------pergunta 5 //inicio extra enunciado class FichaAnimal { FichaAnimal(){} }; //fim extra enunciado class Gaiola { private: vector <FichaAnimal*> animais; //um vector string* ocorrencias; int nOcorrencias; public: //... //inicio extra enunciado Gaiola(const vector<FichaAnimal*>& ficha_animals, string* ocorrencias, int ocorrencias1) : animais(ficha_animals), ocorrencias(ocorrencias), nOcorrencias(ocorrencias1) { } //fim extra enunciado //resposta: ~Gaiola() { delete[] ocorrencias; } }; int main() { }
Questões de C++ (parte 1)
#include <iostream> #include <string> using namespace std; //----------------------------------pergunta 1 class Ser { public: void respirar() { cout << "\n respirar?"; } virtual void alimentar() { cout << "\n alimentar?"; } }; class SerVivo : public Ser { public: void respirar() { cout << "\n ser vivo respira"; } virtual void alimentar() { cout << "\n ser vivo alimenta-se "; } }; class Planta : public SerVivo { public: void respirar() { cout << "\n pelas folhas"; } virtual void alimentar() { cout << "\n pelas raizes "; } }; void alimentarPorObjecto(Ser obj) { obj.alimentar(); } void alimentarPorReferencia(Ser & ob) { ob.alimentar(); } int main() { Ser* s1 = new Planta; cout << "\n---1---"; //como respirar não é virtual, //vai executar a função do ponteiro ou referência (Ser) s1->respirar(); //como alimentar é virtual, //vai executar a funlãi da classe deste objeto (Planta) s1->alimentar(); cout << "\n---2---"; SerVivo* s2 = new Planta; //como respirar não é virtual, //vai executar a função do ponteiro ou referência (SerVivo) s2->respirar(); //como alimentar é virtual, //vai executar a funlãi da classe deste objeto (Planta) s2->alimentar(); cout << "\n---3---"; Planta arvore; //executa as funções deste objecto (Planta) arvore.respirar(); //executa as funções deste objecto (Planta) arvore.alimentar(); cout << "\n---4---"; //executa as funções da base (Ser) alimentarPorObjecto(arvore); //executa as funções deste objecto (Planta) alimentarPorReferencia(arvore); }
#include <iostream> #include <string> using namespace std; //----------------------------------pergunta 2 class Ser { string nome; string * local; public: Ser(string s):nome(s) { } string getNome() { return nome; } //const antes e depois do * //não é possivel qualquer alteração const string* getLocal()const { return local; } }; int main() { //const, o objeto é constante const Ser ob("abc"); //função getNome() tinha que ser depois const cout << ob.getNome(); //p1 não é const, devia ser const string string * p1 = ob.getLocal(); const string* p2 = ob.getLocal(); //p3 não é const, devia ser const string string * const p3 = ob.getLocal(); }
#include <iostream> #include <string> using namespace std; //----------------------------------pergunta 3 class A { int numA; string nome; public: A():numA(0), nome("default1") { } A(int v):numA(v), nome("default2") { } int getNumA() { return numA; } string getNome() { return nome; } }; class B1: public A { int numB; public: B1(int v):A(v+1), numB(v) { } B1(const B1 & orig):numB(orig.numB) { } void imprime() { cout << getNumA() << " " << getNome() << numB << endl; } }; class B2 : public A { int numB; public: B2(int v):A(v+1), numB(v) { } void imprime() { cout << getNumA() << " " << getNome() << numB << endl; } }; void f() { //executa o construtor da base (A) com parametros //e executa o seu construtor (B) que recebe um parametro B1 bx(3); //executa o construtor da base (A) sem parametros //e executa o seu construtor (B) que recebe objeto do tipo B B1 by(bx); cout << "\n--funcao f()" << endl; //saida-> 4 default2 3 bx.imprime(); //saida-> 0 default1 3 by.imprime(); } void g() { //executa o construtor da base (A) com parametros //e executa o seu construtor (B) que recebe um parametro B2 bw(3); //nao tem nada de especial para executar //o bz faz uma "copia" do que tem o bw B2 bz(bw); cout << "\n--funcao g()" << endl; //saida-> 4 default2 3 bw.imprime(); //saida-> 4 default2 3 bz.imprime(); } int main() { f(); g(); }
#include <iostream> #include <string> using namespace std; //----------------------------------pergunta 4 class Produto { string nome; int quantidade; public: Produto(string s, int q) { nome = s; quantidade = q; } // += operador membro: (a += b) += c Produto& operator += (const Produto a) { } }; // + operador global: c = a + b Produto operator+(Produto a, Produto b) { }; // << operador global: cout << a << b ostream & operator << (ostream& str, const Produto& k) { }; // << operador global: (a << 4) << 5; int operator<<(const Produto& a, const int& b) { }; Produto & operator++(const Produto & produto); int main() { Produto a("aaa", 10), b("bbb", 20), c("ccc", 30); c = a + b; //implementar Global: Produto operator+(Produto a, Produto b) cout << a << b;//implementar Global: ostream & operator<<(ostream& str, const Produto& k) (a += b) += c;//implementar membro: Produto& operator += (const Produto a) (a << 4) << 5;//implementar Global: int operator<<(const Produto& a, const int& b) ++a;//implementar Global: Produto & operator++(const Produto & produto); }
#include <iostream> #include <string> using namespace std; //----------------------------------pergunta 5 class Ponto { int x; int y; public: Ponto(int x0, int y0) { x = x0; y = y0; } }; class Figura { string nome; public: Figura(string s){ nome = s; } string getNome()const { return nome; } }; class Rectangulo: public Figura { Ponto cantoSupEsq; Ponto cantoInfDir; public: //implementar o que falta: Rectangulo(int a, int b, int c, int d): Figura("rectangulo"), cantoSupEsq(a, b), cantoInfDir(c, d) { } }; int main() { Rectangulo rect(1, 1, 4, 4); cout << rect.getNome(); //aparece rectangulo no ecrã }
#include <iostream> #include <string> using namespace std; //----------------------------------pergunta 6 class A { public: virtual void f() = 0; virtual void g() = 0; }; class B: public A { public: virtual void h() = 0; virtual void g(){} }; //definir uma class C, concreta, derivada de B //func f e a func h são virtuais puras logo têm de ser definidas //em C para que esta classe seja concreta class C : public B { virtual void f(); virtual void h(); virtual void g() {} }; int main() { }
#include <iostream> #include <string> #include <vector> using namespace std; //----------------------------------pergunta 7 class Animal { public: //completar aqui //não deve ser possivel criar objectos da classe Animal //função virtual pura virtual void Fala() = 0; }; //a relação entre Jaula e Animal é agregação //a relação entre Jaula e alimentos é composição class Jaula { vector <Animal * > animais; string ** alimentos; //array dinamico de ponteiros para string int nAlimentos; //numero de alimentos do array dinâmico public: Jaula() { alimentos = new string * [2]; nAlimentos = 2; alimentos[0] = new string("agua"); alimentos[1] = new string("cereais"); } ~Jaula() { //completar aqui, os destrutores desta classe for (Animal* a : animais) { delete a; } delete alimentos; } //.. //por ter uma virtual na base void Fala(){} }; //a relação entre Zoo e Animal é composição //a relação entre Zoo e Jaula é composição class Zoo { vector <Animal* > animais; vector<Jaula* > jaulas; public: ~Zoo() { //completar aqui, os destrutores desta classe for(Animal * a: animais) { delete a; } for (Jaula* j : jaulas) { delete j; } } //.. //por ter uma virtual na base void Fala() {} };
c++, introdução
introdução:
A programação é orientada não pela decomposição de tarefas mas pela identificação das entidades que constituem o problema e como são modelizadas e manipuladas;
Uma entidade é uma coisa do mundo real:
_É descrita por dados
_É manipulada por funções
Vai-se juntar esses dados e essas funções num novo tipo de dados que representa a entidade do mundo real
Uma classe representa a especificação do novo tipo de dados que representa a entidade.
Definida por:
_Dados
_Funções
Essas funções só possam ser aplicadas a esses dados
Esses dados só podem ser manipulados por essas funções
Um objecto é uma variável (instância) de uma classe
Os objectos (classes) assumem o papel principal do planeamento do programa: pensasse o problema em termos de diversos objectos e da forma como se relacionam entre si.
Que classes/objectos vão existir (quais as entidades que existem no problema a resolver ?)
Que dados descrevem esses objectos?
Quais as operações que esses objectos permitem e/ou oferecem?
Quais as relações existentes entre os vários objectos/classes?
A programação orientada a objectos utiliza os mecanismos de:
encapsulamento
herança
polimorfismo
#Encapsulamento
Dados e código que manipula esses dados são reunidos dentro da mesma entidade (classe), formando uma unidade íntegra e indivisível, autónoma em termos de dados e funcionalidade, que vai funcionar como um bloco de construção do programa.
Utilizam-se mecanismos de acesso que regulam quais os dados e funcionalidade que ficam visíveis (acessíveis) ao resto do programa) que protegem os dados de interferência exterior e de má utilização
Cada objecto vai então ser uma entidade autónoma, capaz de cuidar de si própria, com toda a funcionalidade necessária dentro de si e protegida do resto do programa
O resto do programa apenas sabe como se utiliza e não precisa de saber os pormenores internos de implementação
O programa fica mais simples e mais robusto.
Cada objecto age como uma caixa negra: “funciona e pronto” – é só usar.
#Herança
A herança é o processo pelo qual um tipo de dados pode herdar as propriedades de outro e ter ainda as suas propriedades específicas e sem ter que repetir código.
Torna possível uma classificação hierárquica.
#Polimorfismo
O polimorfismo um mecanismo/propriedade que permite manipular dados diferentes por aquilo que têm de comum, sem necessidade de repetir código nem estruturas de dados.
Age através do mecanismo de herança e, sintacticamente, utiliza o nome da classe base.
O mesmo interface (molde) pode usar-se para especificar diversas acções com significado análogo.
c++, Características Gerais de C++
Acerca de:
Operadores de saída e entrada
Um programa em C++
namespace std
Comentários
Funções sem parâmetros
Definição de variáveis locais
Tipos de dados
Enumerações unscoped vs. scoped (C++11)
Cast: conversão explícita de tipo
Dedução de tipo: auto (C++11)
Ciclo for range-based (C++11)
A constante nullptr (C++11)
Referências
Constantes
Ponteiros e constantes
Referências lvalue/rvalue (C++11)
#Namespace
namespace- define uma região declarativa para identificadores (tipos, funções, variáveis, …)
namespaces são usados para:
_Organizar o código em contextos lógicos
_Evitar o conflito de nomes
using namespace std; //disponibiliza os identificadores definidos no namespace std sem o prefixo std
#Tipos de dados
wchar_t:
É uma extensão do tipo básico char para caracteres que exigem uma representação mais ampla, como os caracteres unicode.
#Enumerações
poo – parte 1 (início)
POO
//—->classe
_uma classe representa a especificação do novo tipo de dados que representa a entidade.
_a classe é definida por: dados e funções
_essas funções são apenas para esses dados e só essas funções é que podem manipular os dados
_o objecto é uma instância (variavel) de uma classe
//—->mecanismos
_existem mecanismos de encapsulamento (o código que manipula os dados estão na mesma classe. existem mecanismos de acesso a esses dados ao exterior da classe)
_existem mecanismos de herança (os dados podem herdar as propriedades e ter as suas propriedades especificas)
_existem mecanismos de polimorfismo (manipular diferentes dados através de algo que têm em comum. faz uso da herança e do nome da classe base)
//—->várias coisas
_operador de saida (<<) e de entrada (>>)
_fazer uso do using namespace std; para evitar ,p.e., usar std::cout
_faz-se uso do “if” se ? “true” : “false”
_conversões de tipo (implicita fazer uso do static_cast) static_cast<int>i
_e ainda o const_cast (????)
_determinar o tipo de variavel: auto x
_ciclo for, para todos os elementos de uma coleção (array, vector,..) (for range-based)
for (auto & elemento: tabela) instrução
_funções: void imprime(int val);
_funções overloaded (são usadas/substituias dependendo dos dados)
//—->a referencia é uma variavel e que pode:
__ser passada a uma função
__ser retornada por uma função
__ser criada de forma independente
__mas se for uma variavel não pode ser alterada
//—->o uso de um ponteiro como parametro de uma função:
f(&i) >> void f(int *n); em que
void f(int *n){
*n=…;
}
//—->o uso de uma referencia como parametro de uma função:
f(i) >> void f(int & n); em que
void f(int & n){
n=…;
}
//—->o uso de uma referencia como retorno de uma função:
global >> int x
f() -> int & f(); em que
int & f(){
return x;
}
//—->constantes (variaveis, arrays)
na sua area de validade não pode ser alterado
const antes do * impede a alteração do apontado >> int const * p;
const depois * torna constante o ponteiro >> int * const p = &i;
const antes e depois do P (nao é possivel qualquer alteração) >> int const * const a = &i;
quando uma função nao deve alterar uma variavel >> ponteiro para constante
//—->referencias a lvalue e rvalue (????)
//—->funções inline
sao expandidas inline
inline void par(int x) return !(x%2);
int main(){
if(par(10)) cout << “\npar..”<< endl;
}
//—->funções overloaded
funções com o mesmo nome mas
__diferentes
#a_lista dos includes “normais/regulares”
#include <iostream>
#include <string>
#include <iostream>
using namespace std;