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
Tags : , , ,

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 : , , , , , ,

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 : , , , , , , , ,

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.

Tags : , , , ,

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

Tags : , , ,

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;

Tags : , ,