Category: programação (C plus plus)

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

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

estudar02 – controlo de estruturas

#include <cstdlib>
#include <iostream>


using namespace std;

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

    //if
    int idade=15;
    if(idade >18){
        cout << "bem vindo ao clube\n";
    }else{
        cout << "nao podes entrar no clube \n";
    }
    
    return 0;
}

Tags : ,

estudar01 – introdução ao c++

#include <cstdlib>
#include <iostream>

using namespace std;

int main(int argc, char** argv) {
   cout << "ola mundo\n";
    
   int number;
   number=10;
    
   cout << number << "\n";
    
   int n1, n2, total, media;
    
   cout << "introduz um numero1" << "\n";
   cin >> n1;
   cout << "introduz um numero2" << "\n";
   cin >> n2;
   
   cout << "os numeros introduzidos foram " << n1 << " e " << n2 << "\n";
   total=n1+n2;
   media=total/2;
   
   cout << "o total vem: "<< total << "e a media vem: "<< media << "\n";
   
   //os arrays
   int a[5]={1,2,3,4,5};
   cout << a[0] << "\n";
   cout << a[1] << "\n";
   cout << a[2] << "\n";
   cout << a[3] << "\n";
   cout << a[4] << "\n";
   
return 0;
}
Tags : , , ,