Category: programação (C plus plus)

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 :

POO, conceitos (Cap-05, Memoria dinâmica)

#arrays de objetos
os arrays de objetos

#include "pch.h"
#include <iostream>
#include <string>

using namespace std;

class Ponto {
	int x, y;
public:
	Ponto(int x0 = 0, int y0 = 0);
	~Ponto();
};

int main()
{
	//ou indicamos o construtor que queremos usar
	Ponto a[] = { Ponto(1,3), Ponto(2,4), Ponto(5,7) }; 
	Ponto b[] = { {1,3}, {2,4},{5,7} };

	//ou usamos o construtor por omissão
	Ponto c[3];
	Ponto d[3] = { Ponto(1,3) };

	system("pause");
}
//main
#include "Relogio.h"

int main()
{
	{
	Relogio a[10]; //criar um array de 10 objetos
	}
	system("pause");
}
//Relogio.cpp
#include "Relogio.h"

Relogio::Relogio(int hora, int minuto, int segundo)
{
	cout << "Relogio criado" << endl;
}
Relogio::~Relogio()
{
	cout << "Relogio destruido" << endl;
}
//Relogio.h
#pragma once
#include "pch.h"
#include <iostream>
#include <string>

using namespace std;

class Relogio
{
public:
	Relogio(int hora = 0, int minuto = 0, int segundo = 0);
	~Relogio();
};

#variaveis em memoria dinâmica
o uso do operador new permite criar um objecto até ser explicitamente destruido com o operador delete
pVar = new tipo; //ponteiro para um endereço
delete pVar;

ou podemos usar da seguinte forma
int *v1 = new int(4); //valor inicial a 4
delete v1;

#objectos em memoria dinâmica
ou aplicar a uma classe

#include "pch.h"
#include <iostream>
#include <string>

using namespace std;

class Ponto {
	int x, y;
public:
	Ponto() {
		x = 0; y = 0;
		cout << "construindo" << endl;
	};
	~Ponto() { cout << "destruindo" << endl; };

	void imprimir() { cout << "valor x=" << x << " valor de y=" << y << endl; }
};

int main()
{
	{
		//usar memoria dinamica
		Ponto *p = new Ponto;
		p->imprimir();
		delete p;
	}

	system("pause");
}

#arrays dinamicos de objetos
para criar um é necessário fazer:
pVar = new tipo[dim];
para libertar a memoria:
delete [] pVar;

#include "pch.h"
#include <iostream>
#include <string>

using namespace std;

class Ponto {
	int x, y;
public:
	Ponto() {
		x = 0; y = 0;
		cout << "construindo" << endl;
	};
	~Ponto() { cout << "destruindo" << endl; };

	void imprimir() { cout << "valor x=" << x << " valor de y=" << y << endl; }
};

int main()
{
	{
	//usar arrays dinamico de objectos, com construtor e destrutir para cada elemento
	Ponto *p = new Ponto[4];
	for (int i = 0; i < 4; i++) {
		p[i].imprimir();
	}
	delete [] p;
	}
	system("pause");
}
Tags : , , ,

POO, conceitos (cap 4)

as Classes:

#estruturas com funções membros
as funções que são declaradas como membros de uma estrutura são as funções membro
uma função membro sabe sempre para que objecto foi invocada
os membros privados só podem ser “trancados” se estes forem declarados como private, e desta forma apenas as funções membro conseguem aceder a eles
por omissão os membros de uma classe são privados, já se fosse os membros de uma estrutura são públicos.
qualquer função membro (nao estática) consegue aceder aos membros da classe sem referência explicita do objecto

acessibilidade:
se as funções membros forem as únicas a ter acesso directo à informação, então essas informações são membros privados
mantendo as funções membros como publicas, dentro da estrutura ou classe
as funções membros podem aceder a membros públicos ou privados, dentro da estrutura ou classe

para a aceder a um método de uma classe faz-se uso do operador ::

#construtores
serve para inicializar os objectos de uma classe
um construtor de uma classe pode ter parâmetros que podem representar os valores iniciais

#construtores overloaded
podemos ter vários construtores para especificar várias maneiras de inicializar objetos.
a escolha do construtor depende do dos argumentos que forem especificados
pode existir o construtor por omissão, será aquele que não tem especificado qualquer argumento

#construtores com parâmetros com valores por omissão
este tipo de construtor é também um construtor por omissão , pois pode ser chamado sem a especificação de argumentos

#destrutor
quando o objeto deixa de existir, os recursos devem ser libertados, usando destrutores, que são automaticamente invocados
a destruição dos objectos é feita da seguinte forma:
_objectos locais não estáticos são destruídos quando a execução do programa sai do bloco onde foram declarados
_objectos globais, são destruídos quando o programa termina
_objectos dinâmicos são destruídos recorrendo ao operador delete

#funções inline
são todas as funções que são funções membro de uma classe e que estejam definidas na classe
normalmente são funções pequenas e que são muitas vezes utilizadas

#membros variáveis estáticos (static)
é partilhado para todos os objectos de uma classe
existe apenas uma única existência de um e um só membro estático pelos objectos da classe
os não estáticos existe apenas uma existência por objectos
são definidos fora da classe, e pode ser inicializado

#funções estáticas (static)
têm acesso apenas aos membros estáticos (variáveis ou funções)
funções não estáticas tem acesso a todos os membros (estáticos ou não estáticos)
o acesso a um membro estático publico:
a.membro ou a.funçãoMembro()

o acesso a um membro estático publico sem referencia de objeto:
Disciplina::membro
Disciplina::funçãoMembro()

#funções membros constantes
o uso de const no fim do prototipo das funções indica que estas nao alteram os membros
se uma função membro tem const no final do prototipo também tem que aparecer const
as funções membros constantes podem ser invocadas para objectos constantes e nao constantes
as funções membros não constantes só podem ser invocadas para objectos não constantes

#funções friend
uma função friend relacionada com uma classe tem acesso aos seus membros privados não sendo mesmo membro dessa classe
a palavra friend surge antes do prototipo

#construtores com lista de inicialização
Disciplina():x(i), y(i){…
..
}

existem situações em que não é possivel inicializar membros variáveis dentro do construtor, tendo que se usar uma lista de inicialização
se forem membros constantes, têm que ser inicializados na lista de inicialização
se forem membros referencia, têm que ser inicializados na lista de inicialização

#Membros variáveis inicializados na declaração
é possivel inicializar os membros variáveis da classe aquando da declaração

#Membros default e delete
o uso da especificação default serve para indicar qual o construtor a ser utilizado (por omissão)
o uso da especificação delete serve para tornar indisponível a sua implementação


Tags : ,

POO, conceitos (cap 3)

#funções overloaded, são funções com o mesmo nome se:
tiverem diferentes tipos de argumentos
tiverem diferentes números de argumentos
tiverem diferentes tipos e números de argumentos

#funções com argumentos por omissão:
deve ser feito na declaração da função usando o =

Tags : ,

POO, conceitos (cap 2)

Operadores de saída e entrada:
Operador de saída: << Operador de entrada: >>

podemos usar o namespace para organizar ou evitar conflitos, inclusive podemos criar o nosso próprio exemplo:
namespace exemplo {
// definições de funções, variáveis,
// classes, etc.
}

e para evitar o uso dos operadores :: aquando da biblitoeca iostream
std::cout
faz-se:
using namespace std;

Bibliotecas a usar:
#include <iostream>
#include <string>

Cast: conversão explícita de tipo:
static_cast, de ponteiros do tipo void* para ponteiros de outros tipos
exemplo:
double d = 0.0;
int x = d;
x = static_cast(d);

const_cast,
reinterpret_cast,
dynamic_cast, Converte um ponteiro para um uma classe, num ponteiro para uma classe derivada, derivada da derivada
auto, o compilador determina automaticamente o tipo de uma variável
exemplo:
double val1 = 1;
double val2 = 2;
auto x = val1 + val2;

Ciclo for range-based, para quando todos os elementos de uma colecção (array, vector, …) devem ser processados
for(auto & elemento: tabela)
exemplo:
int a[10];
for(auto & elemento: a){
elemento = 4;
}

A constante nullptr em C++11, A constante nullptr pode ser usada para inicializar ponteiros nulos.

Referências,pode:
ser passada a uma função
ser retornada por uma função
ser criada de forma independente.

Ponteiro como parâmetro de uma função
exemplo:
void f(int *n);

int main() {
int i = 0;
f(&i);
cout << “\nNovo valor de i:” << i << endl;
return 0;
}

void f(int *n) {
*n = 100;
}

Referência como parâmetro de uma função
exemplo:
void f(int & n);

int main() {
int i = 0;
f(i);
cout << “\nNovo valor de i:” << i << endl;
return 0;
}
void f(int & n) {
n = 100;
}

Referência como retorno de uma função
exemplo:
int & f( );
int x = 0; //tem que ser global
int main( ){
f( ) = 100;
cout << x << endl;
return 0;
}
int & f( ){
return x;
}

Constantes, uma constante deve ser inicializada, já que não é possível fazer-lhe atribuições.
A palavra const antes do * impede qualquer alteração ao objecto apontado através do ponteiro em causa
A palavra const depois do * torna constante o ponteiro.
A palavra const antes e depois do * torna impossivel alterar o objeto apontado

Quando usar: quando uma função nao deve alterar uma variavel

Parâmetros do tipo referência para constante
_ganhar eficiencia de passar a referência ao invés do valor

exemplo conclusão

#include <iostream>

void t(int*) {}

void u(const int* cip) {
//*cip = 2; // ERRO: modifica valor
int i = *cip; // OK: copia valor
//int* ip2 = cip; // ERRO: ip2 nao é pont. para const
}

const char* v() {
// Retorna o endereço de uma string: 
return "result of function v()";
}


void main()
{
int x = 0;
int* ip = &x;
const int* cip = &x;
t(ip);
//t(cip);//Erro:t() nao pode receber ponteiro para constante
u(ip);  // OK u() pode receber ponteiro sem restricoes
u(cip); // OK u() pode receber ponteiro para constante 
//char* cp = v(); // Erro: nao deve ser possivel alterar 
// a string retornada por v() 
const char* ccp = v(); // OK 
system("pause");
}

faltou:
referências a lvalue e rvalue

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

POO, conceitos

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

A programação orientada a objectos utiliza os mecanismos de:
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
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
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. O mesmo interface (molde) pode usar-se para especificar diversas acções com significado análogo

Tags :

estudar11 – classes e a herança híbrida e múltipla

#include <cstdlib>
#include <iostream>

using namespace std;

class Avo{

public:
    
    void mostraMsg(){
        cout << "eu sou milionario\n";
    };
};

class Mae{

public:
        void verifica(){
        cout << "eu sou inteligente\n";
    };
};


class Pai : public Avo{

public:
};

class Filho : public Pai, public Mae{

public:
};

int main(int argc, char** argv) {
    Filho f;
    
    f.verifica();
    f.mostraMsg();
    
    return 0;
}

Tags : , , ,

estudar10 – classes e a herança múltipla

#include <cstdlib>
#include <iostream>

using namespace std;

class Avo{

public:
    
    void mostraMsg(){
        cout << "eu sou milionario\n";
    };
};

class Pai : public Avo{

public:
};

class Filho : public Pai{

public: 
};

int main(int argc, char** argv) {
    Filho f;
    
    f.mostraMsg();
    
    return 0;
}
Tags : , ,

estudar09 – classes e a herança ()

#include
#include

using namespace std;

class pai{

public:

void dinheiro(){
cout << "eu sou um milionario";
}

};

class filho : public pai{
//a classe filho herdou a função do pai através do principio da herança;

public:

};

int main(int argc, char** argv) {
filho s;

s.dinheiro();

return 0;
}
Tags : , , ,

estudar08 – classes e construtores

#include <cstdlib>
#include <iostream>

using namespace std;

class Estudante{

    int notas;
    
public:
    
    Estudante(int p=50){ 
    //construtor: evitar que a classe tenha lixo qd começa
    //que a classe comece com valores vladios qd começa
    //consrutor parameterizado (int p)
    //ou podemos iniciar o construtor logo com o valor (int p=50)    
        
        notas=p;
    }
    
    void getDados(){
        cout << notas;
    }
    
    void setDados(){
        cout << "\n Qual a nota ";
        cin >> notas;
    }
    

};

int main(int argc, char** argv) {
    Estudante s;
    
    s.getDados();
    return 0;
}
Tags : , ,

estudar07 – classes II

#include <cstdlib>
#include <iostream>

using namespace std;

class estudante{

    int id;
    char name[20];
    int s1;
    int s2;
    int s3;
    
public:
    void getDados(){
        cout << "\nqual o id? ";
        cin >> id;
        cout << "\nqual o nome? ";
        cin >> name;
        cout << "\nQual a nota da UC1 ?";
        cin >> s1;
        cout << "\nQual a nota da UC2 ?";
        cin >> s2;
        cout << "\nQual a nota da UC1 4";
        cin >> s3;
    }

    void mostraDados(){
        cout << "\n" << id << "\t" << name << "\t" << s1 << "\t" << s2 << "\t" << s3;
    }

};

int main(int argc, char** argv) {
    estudante s[10]; //array de objectos
    int n;
    
    cout << "\nQuantos estudantes? ";
    cin >> n;
    
    for(int i=0; i< n ; i++){
        s[i].getDados();
    }
    for(int i=0; i< n ; i++){
        s[i].mostraDados();
    }
        
    return 0;
}
Tags : , ,

estudar06 – classes

#include <cstdlib>
#include <iostream>

using namespace std;
//classes: classificação de alguma coisa

class estudante{
    
    //os atributos e propriedades, as variaveis
    int id;
    int notas;
    
    //membros da classe estudante, as funcoes dentro da classe
    
public:
    void getDados(){
        cout << "\n qual o seu id?";
        cin >> id;
        cout <<"\n qual a sua nota?";
        cin >> notas;
    }
    void mostraDados(){
        cout << "\n" << id << "\t" << notas << "\n";
    }
};


int main(int argc, char** argv) {
    estudante novo; //novo: instancia da classe estudante
    novo.getDados();
    novo.mostraDados();
    
    
    return 0;
}
Tags : ,

estudar05 – funções matemáticas

#include <cstdlib>
#include <iostream>

using namespace std;
//classes: classificação de alguma coisa

class estudante{
    
    //os atributos e propriedades, as variaveis
    int id;
    int notas;
    
    //membros da classe estudante, as funcoes dentro da classe
    
public:
    void getDados(){
        cout << "\n qual o seu id?";
        cin >> id;
        cout <<"\n qual a sua nota?";
        cin >> notas;
    }
    void mostraDados(){
        cout << "\n" << id << "\t" << notas << "\n";
    }
};


int main(int argc, char** argv) {
    estudante novo; //novo: instancia da classe estudante
    novo.getDados();
    novo.mostraDados();
    
    
    return 0;
}
Tags : ,

estudar04 – funções recursivas

#include <cstdlib>
#include <iostream>

using namespace std;

int contas(int n); //recursão: uma função que se chama a si propria

int main(int argc, char** argv) {
    
    cout <<"funcao contas - recursao\n";
    contas(10);
    return 0;
}

int contas(int n){
    
    if(n==0){
        return 1;
    }else{
        cout << "\n" << n;
     return (contas(n-1));
    }
}

Tags : ,

estudar03 – funções

#include <cstdlib>
#include <iostream>


using namespace std;

int mensagens(); //prototipo da função
int mostranumero(int n1, int n2);
int contas(int n1, int n2);
int contas2(int n1, int n2);


int main(int argc, char** argv) {

    mensagens();
    mostranumero(1,2);
    cout << contas(10,23) << "\n";
     cout << contas2(40,23) << "\n";
    
    
    return 0;
}


int mensagens(){
    cout << "conteudo de uma funcao\n";
        return 0;
}

int mostranumero(int n1, int n2){
    
    cout << n1 << " " << n2 << "\n";
    
    return 0;
}

int contas(int n1, int n2){
    int total=0;
    total=n1+n2;
    
    return total;
}

int contas2(int n1, int n2){
    
    return (n1+n2);
}
Tags : ,