Month: September 2020

Brackeys, the end.

O canal de youtube e comunidade do Brackeys vai terminar. Foi dos primeiros canais que segui já que tem vídeos muito interessantes para explicar o uso do Unity e assuntos correlacionados como é o caso da linguagem de programação c# ou de modelação de objectos.

Os vídeos e os outros canais de suporte vão ficar activos, apesar do projeto terminar.

+infos(listas no youtube): LINK

+infos(página oficial): https://brackeys.com/

Tags : , , ,

Generative Board Games

Existe um site online onde é possivel gerar jogos de tabuleiro de forma aleatória. Com recurso à inteligência artificial e numa questão de segundos é possível ter um layout de um jogo com as respectivas regras, bastando para isso atribuir um titulo ao jogo. O que existe é uma base de dados com inúmeras entradas que tenta combinar/construir algo interessante, mas no final cabe ao utilizador a vontade de concordar ou não com o que foi “criado”.

É um trabalho ainda numa fase de construção e de exploração, mas que pode vir a ser interessante, nem que seja para termos cenários diferentes de jogos que gostamos :)

+infos(oficial): https://www.generativeboard.games/

Tags : , ,

Um workshop/concurso interessante


Vai decorrer em Vila Real um concurso de design de jogo de cartas. Este concurso para além de ser efectivamente um concurso conta com a possibilidade de participar num workshop acerca do assunto. O workshop vai decorrer em Vila Real com a possibilidade de quem estiver longe de participar via Zoom :)

O evento é dinamizado pela empresa Art and Games. :)

+infos(o concurso): http://www.artandgames.pt/codec/

+infos(rede social): https://www.facebook.com/artandgames/

 

Tags : , , ,

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

estudar1920 – as heranças simples, em c++

As heranças “simples”, herança única, tem como precipícios que a classe que for derivada herda:
se o acesso for private: herda os membros públicos e protegidos como privados;
se o acesso for protected: herda os membros públicos e protegidos como protegidos;
se o acesso for public: herda exatamente os mesmos níveis de proteção dos membros da classe-base;

exemplo:

#include <iostream>

using namespace std;

class Veiculo
{
private:
	int passageiros, velocidade;
public:
	Veiculo();
	~Veiculo();

	int getPassageiros();
	void setPassageiros(int p);
	int getVelocidade();
	void setVelocidade(int v);

	void Imprime();
};
Veiculo::Veiculo()
{
	
}

Veiculo::~Veiculo()
{
	cout << "\ndestrutor do veiculo com velocidade " << getVelocidade() << endl;
	passageiros = NULL;
	velocidade = NULL;
}

void Veiculo::setPassageiros(int p)
{
	passageiros = p;
}

int Veiculo::getPassageiros()
{
	return passageiros;
}

void Veiculo::setVelocidade(int v)
{
	velocidade = v;
}

int Veiculo::getVelocidade()
{
	return velocidade;
}

void Veiculo::Imprime()
{
	cout << "\nImprime do Veiculo com velocidade " << getVelocidade() << endl;
}

//as heranças
class Automovel : public Veiculo
{
private:
	string tipo;
public:
	Automovel();
	~Automovel();
	void setTipo(string s);
	string getTipo();

	void Imprime();
};

Automovel::Automovel()
{
	
}

Automovel::~Automovel()
{
	cout << "\ndestrutor do automovel com velocidade: " << getVelocidade() <<endl;
	tipo = "";
}

void Automovel::setTipo(string s)
{
	tipo = s;
}

string Automovel::getTipo()
{
	return tipo;
}

void Automovel::Imprime()
{
	cout << "\nImprime do Automovel com velocidade: " << getVelocidade() << endl;
}


class Comboio : public Veiculo
{
private:
	int carruagens;
public:
	Comboio();
	~Comboio();
	void setCarruagens(int c);
	int getCarruagens();
	void Imprime();
};

Comboio::Comboio()
{
	
}

void Comboio::setCarruagens(int c)
{
	carruagens = c;
}

int Comboio::getCarruagens()
{
	return carruagens;
}

Comboio::~Comboio()
{
	cout << "\ndestrutor do comboio com velocidade " << getVelocidade() << endl;
}

void Comboio::Imprime()
{
	cout << "\nImprime do Comboio com velocidade " << getVelocidade() << endl;
}

int main()
{
	Veiculo vei1;
	vei1.Imprime();

	Automovel auto1, auto2;
	auto1.setTipo("renault");
	auto1.setVelocidade(120);
	auto1.setPassageiros(4);
	auto1.Imprime();

	Comboio comb1;
	comb1.setCarruagens(4);
	comb1.setVelocidade(220);
	comb1.Imprime();

	return 0;
}
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 : , , , ,

estudar1920 – as heranças múltipla e a superclasse, em c++

Uma classe pode herdar múltiplos membros de várias classes e uma classe derivada por também ser uma superclasse, havendo uma árvore de derivação

exemplo de superclasse (veiculo<-autocarro<-minicoisa):

#include <iostream>

using namespace std;

class Veiculo
{
private:
	int passageiros;
public:
	Veiculo();
	~Veiculo();

	void setPassageiros(int p);
	int getPassageiros();
	
	void imprime();
};

Veiculo::Veiculo()
{
	cout << "\nconstrutor de veiculo " << getPassageiros() << endl;
}

Veiculo::~Veiculo()
{
	cout << "\ndestrutor de veiculo " << getPassageiros() << endl;
	passageiros = NULL;
}

void Veiculo::setPassageiros(int p)
{
	passageiros = p;
}

int Veiculo::getPassageiros()
{
	return passageiros;
}

void Veiculo::imprime()
{
	cout << "\nsou o veiculo " << getPassageiros() << endl;
}

class Autocarro : public Veiculo
{
private:
	int portas;
public:
	Autocarro();
	~Autocarro();
	void setPortas(int p);
	int getPortas();

	void imprime();
};

Autocarro::Autocarro()
{
	cout << "\nconstrutor de autocarro " << getPortas() << endl;
}

Autocarro::~Autocarro()
{
	cout << "\ndestrutor de autocarro " << getPortas() << endl;
	portas = NULL;
}

void Autocarro::setPortas(int p)
{
	portas = p;
}

int Autocarro::getPortas()
{
	return portas;
}

void Autocarro::imprime()
{
	cout << "\sou o autocarro " << getPortas() << endl;
}

class MiniCoisa: public Autocarro
{
private:
	int rodinhas;
public:
	MiniCoisa();
	~MiniCoisa();
	void setRodinhas(int r);
	int getRodinhas();

	void imprimir();
};

MiniCoisa::MiniCoisa()
{
	cout << "\nconstrutor de minicoisa " << getRodinhas() << endl;
}

MiniCoisa::~MiniCoisa()
{
	cout << "\ndestrutor de rodinhas " << getRodinhas() << endl;
	rodinhas = NULL;
}

void MiniCoisa::setRodinhas(int r)
{
	rodinhas = r;
}

int MiniCoisa::getRodinhas()
{
	return rodinhas;
}

void MiniCoisa::imprimir()
{
	cout << "\nsou o rodinhas " << getRodinhas() << endl;
}

int main()
{
	Veiculo vei1;
	vei1.imprime();

	Autocarro auto1;
	auto1.setPortas(3);
	auto1.imprime();

	MiniCoisa min1;
	min1.setRodinhas(5);
	min1.imprimir();

	return 0;
}

exemplo de herdar de multiplas classes (minicoisa de veiculo E minicoisa de autocarro):

#include <iostream>

using namespace std;

class Veiculo
{
private:
	int passageiros;
public:
	Veiculo();
	~Veiculo();

	void setPassageiros(int p);
	int getPassageiros();

	void imprime();
};

Veiculo::Veiculo()
{
	cout << "\nconstrutor de veiculo " << getPassageiros() << endl;
}

Veiculo::~Veiculo()
{
	cout << "\ndestrutor de veiculo " << getPassageiros() << endl;
	passageiros = NULL;
}

void Veiculo::setPassageiros(int p)
{
	passageiros = p;
}

int Veiculo::getPassageiros()
{
	return passageiros;
}

void Veiculo::imprime()
{
	cout << "\nsou o veiculo " << getPassageiros() << endl;
}

class Autocarro
{
private:
	int portas;
public:
	Autocarro();
	~Autocarro();
	void setPortas(int p);
	int getPortas();

	void imprime();
};

Autocarro::Autocarro()
{
	cout << "\nconstrutor de autocarro " << getPortas() << endl;
}

Autocarro::~Autocarro()
{
	cout << "\ndestrutor de autocarro " << getPortas() << endl;
	portas = NULL;
}

void Autocarro::setPortas(int p)
{
	portas = p;
}

int Autocarro::getPortas()
{
	return portas;
}

void Autocarro::imprime()
{
	cout << "\sou o autocarro " << getPortas() << endl;
}

class MiniCoisa : public Autocarro, public Veiculo
{
private:
	int rodinhas;
public:
	MiniCoisa();
	~MiniCoisa();
	void setRodinhas(int r);
	int getRodinhas();

	void imprimir();
};

MiniCoisa::MiniCoisa()
{
	cout << "\nconstrutor de minicoisa " << getRodinhas() << endl;
}

MiniCoisa::~MiniCoisa()
{
	cout << "\ndestrutor de rodinhas " << getRodinhas() << endl;
	rodinhas = NULL;
}

void MiniCoisa::setRodinhas(int r)
{
	rodinhas = r;
}

int MiniCoisa::getRodinhas()
{
	return rodinhas;
}

void MiniCoisa::imprimir()
{
	cout << "\nsou o rodinhas " << getRodinhas() << endl;
}

int main()
{
	MiniCoisa min1;
	min1.setRodinhas(10);
	min1.setPassageiros(4);
	min1.setPortas(2);
	min1.imprimir();

	return 0;
}
Tags : , ,

estudar1920 – o polimorfismo, em c++

O polimorfismo, permite que objectos tenham a capacidade de ter variados comportamentos em função das suas particularidades e ambientes onde estão inseridos. Para isso é necessário usar métodos virtuais e classes abstractas.
Os ponteiros ou apontadores são endereços de memória que permitem armazenar endereços de memória de outras variáveis ou de objectos
Um ponteiro quando declarado faz uso do operador unário de indirecção (*), exemplo: int * curso; // int é o tipo de dados, e curso é o nome do ponteiro para a variável
Para se aceder ao endereço de memória tem que se faz usando o operador de leitura de endereços (&), por exemplo: curso = &casa; // em que curso é o ponteiro que foi previamente declarado, e &casa é o nome do endereço que vai ser assumido de memória variável;

exemplo:

#include <iostream>

using namespace std;

int main()
{
	int comida = 20;
	int * aponta;
	aponta = &comida;
	cout << "vou mostrar: " << *aponta << endl;

	return 0;
}

os ponteiros também podem ser usados para objectos, e neste caso a sua declaração tem que ser feita por exemplo: Corrida *apontar; //Corrida é o nome da classe, e apontar é o nome do ponteiro.
Não esquecer que para se aceder a essa zona da memória é necessário primeiro indicar que o ponteiro está a olhar para a respectiva classe: apontar = &casa; //apontar, é o nome do ponteiro, e casa é a instância da classe
para se aceder aos membros apontados deve fazer-se uso do operador de referência (->) e não o operador (.)
exemplo de ponteiros para objectos:

#include <iostream>

using namespace std;

class Carro
{
private:
	int velocidade;
public:
	Carro();
	~Carro();
	void setVelocidade(int v);
	int getVelocidade();
	void imprimir();
};

Carro::Carro()
{
	cout << "\nconstrutor do carro" << getVelocidade() << endl;
}

Carro::~Carro()
{
	cout << "\ndestrutor do carro " << getVelocidade() << endl;
}

void Carro::setVelocidade(int v)
{
	velocidade = v;
}

int Carro::getVelocidade()
{
	return velocidade;
}

void Carro::imprimir()
{
	cout << "\nacerca do carro " << getVelocidade() << endl; } int main() { Carro car1; car1.setVelocidade(100); Carro * aponta; aponta = &car1; aponta->imprimir();

	aponta->setVelocidade(10);
	car1.imprimir();
	
	return 0;
}

Existe também uma palavra chave que é o this
O this é um atalho que permite apontar para a classe actual, e é útil para se referir a membros dessa classe.
exemplo:

#include <iostream>

using namespace std;

class Carro
{
private:
	int velocidade;
public:
	Carro();
	~Carro();
	void setVelocidade(int v);
	int getVelocidade();
	bool compararVelocidade(Carro car);
	void imprimir();
};

Carro::Carro()
{
	cout << "\nconstrutor do carro" << getVelocidade() << endl;
}

Carro::~Carro()
{
	cout << "\ndestrutor do carro " << getVelocidade() << endl; } void Carro::setVelocidade(int v) { velocidade = v; } int Carro::getVelocidade() { return velocidade; } bool Carro::compararVelocidade(Carro car) { return this->getVelocidade() > car.getVelocidade();
}

void Carro::imprimir()
{
	cout << "\nacerca do carro " << getVelocidade() << endl;
}

int main()
{
	Carro car1, car2;
	car1.setVelocidade(10);
	car2.setVelocidade(20);
	if(car1.compararVelocidade(car2))
	{
		cout << "\ncar1 > car2" << endl;
	}else
	{
		cout << "\ncar1 < car2" << endl;
	}
	
	return 0;
}

Existem também os métodos virtuais. Um método virtual é declarado numa classe base, mas é implementado nas classes que derivam. Esta virtualização vai permitir que as classes derivadas façam uso desse método mas variando o seu comportamento.
Os métodos virtuais têm que ser declarados na secção pública de uma classe base

 

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

estudar1920 – classes em c++

Exemplo de uma classe, construtor, destrutor, método, protótipo e declaração no main de instâncias da classe

#include <iostream>

using namespace std;
class Rectangulo
{
private:
	//atributos
	int base, altura;

public:
	//construtor
	Rectangulo(int b, int a)
	{
		base = b;
		altura = a;
	}
	//destrutor
	~Rectangulo()
	{
		cout << "\ndestrutor " << endl;
		base = NULL;
		altura = NULL;
	}
	//método
	int area(); //prótotipo 
};

int Rectangulo::area()
{
	return base * altura;
}


int main()
{
	Rectangulo r1(10,10), r2(4,4); //instâncias
	cout << "\narea do r1: " << r1.area() << endl;
	cout << "\narea do r2: " << r2.area() << endl;
	return 0;
}
Tags :

Humble Unity games and game dev assets bundle (uma campanha)

Está a decorrer uma campanha no Humble com algumas coisas interessantes para o Unity, nomeadamente alguns assets que ficam no final a um preço interessante. É pena não terem mais elementos similares aos Low Poly Ultimate Pack, e com um espírito mais de RTS :). Da lista consta:
All In 1 Sprite Shader
THOR Thunderstorm
Sensor Toolkit
POLYGON – Western Pack
POLYGON – Prototype Pack
White mage spells
Monster Sounds & Atmospheres SFX Pack
Wet Stuff
Easy Character Movement
Human Vocal Sounds
Skybolt Zack
FPS Builder
Peek
Clayxels
Nature Renderer
One Deck Dungeon
Aeronautica Imperialis: Flight Command
Databox – Data editor & save solution
Horse Animset Pro (Riding System)
Relief Terrain Pack v3.3
Easy Mobile Pro
Mesh Combine Studio 2
MCS Caves & Overhangs
Forest Environment – Dynamic Nature
OverCloud
Winter Forest Environment
The First Tree
DRONE The Game
MarZ: Tactical Base Defense
UModeler: 3D Modeling in Unity
Low Poly Ultimate Pack

+infos(a campanha): LINK

Tags : , , , , , ,

One Up: Creativity, Competition, and the Global Business of Video Games

saiu ou está quase a sair um livro de nome “One Up: Creativity, Competition, and the Global Business of Video Games“, que não tratando do tema que mais me agrada (o Game Desgin) parece apontar para o lado do negócio e dos valores na industria do desenvolvimento dos videojogos.
acho sempre interessante esta análise, nem que seja para chamar a atenção que esta industria vende mais do que tudo o resto.

o autor, Joost van Dreunen, também tem um blog onde vai partilhando alguns comentários sobre o que se passa no mundo e fazendo algumas análises ao mercado, e que merecem ser lidas :) encontrei este tópico acerca das receitas de comissões e vendas que a diferentes lojas digitais estão a implementar (LINK)

+infos(autor): https://www.superjoost.net/book

+infos(loja): LINK

Tags : , ,

Catarina Macedo – Xbox R&D,

O canal Mau Perder, tem um conjunto de videos de nome “Podcast Super Papo-Seco”, a última convidada tem de nome Catarina Macedo, é uma tuga, que trabalha na Microsoft e mais concretamente na Xbox departamento de R&D.

+infos(Catarina Macedo): LINK

+infos(canal Mau perder): LINK

Tags :