Day: September 15, 2020
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
Tags : c++11, Learn C plus plus, POO, t1920r
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() { }
Tags : agregação, c++11, Composição, Learn C plus plus, POO, t1920n, virtual
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() {} };
Tags : agregação, c++11, Composição, concreta, const, Learn C plus plus, POO, t1718r, virtual