Desenvolvimento Código Aberto

Inheritance (herança)

Programação orientada a objetos permite que classes possam herdar estados e comportamentos comuns usados de outras classes. Neste exemplo, bicicleta torna-se agora a superclasse de MountainBike. Na linguagem de programação, cada classe é permitido ter uma superclasse direta, e cada superclasse tem o potencial para um número ilimitado de subclasses.

Na herança, a classe derivada contém os membros da classe base acrescido de quaisquer novos membros adicionados. Como resultado, uma classe derivada pode se referir a membros da classe base (a não ser se os membros forem redefinidos na classe derivada). O operador de escopo resolução (::) pode ser usado para se referir a membros de classes base, diretos ou indiretos, quando os membros foram redefinidos na classe derivada.

Tipos de Heranças

A linguagem de programação C++ possui dois tipos de herança.

Simples:

Em “herança simples” uma forma comum de herança, as classes têm apenas uma classe base.

Múltiplas:

A nova versão do C + + introduziu um modelo de “herança múltipla”. Num gráfico de múltiplas heranças, as classes de derivados podem ter multiplos números de classes de bases diretas ou seja a classe AB deriva da classa A e de uma outra classe B.

Override

Métodos Override (substituição), em programação orientada a objeto, é um recurso de linguagem que permite que uma subclasse ou classe filha possa fornecer uma implementação específica de um método que já é fornecido por uma de suas superclasses ou classes pai.

A implementação Override das subclasses substitui a implementação na superclasse, fornecendo um método que tem o mesmo nome, mesmos parâmetros ou assinatura, e mesmo tipo de retorno como o método na classe pai.

Exemplo:

Neste exemplo damos a classe MountainBike todos os mesmos campos e métodos da classe bicicleta, e ainda permite que seu código se concentre exclusivamente sobre as características que a tornam única. Isso faz do código de suas subclasses fáceis de ler. Usamos metodos Override neste exemplo de duas maneiras, para substituir um método da subclasse e adicionar mais um construtor com parametros.

No entanto, você deve tomar cuidado para documentar corretamente o estado e o comportamento que cada superclasse define, uma vez que o código não irá aparecer no arquivo de origem de cada subclasse.

C++

Classe #1 – Principal.cpp

#include "stdafx.h"
#include <iostream>
#include <string>
#include "bicicleta.h"
using namespace std;

int _tmain(int argc, _TCHAR* argv[])
 {

// Metodo com Construtor Default
  Bicicleta bike1;
  bike1.modelo = "ZR069";
  bike1.quadro = "Ferro";
  bike1.rodas = "Ferro";
  bike1.freios = "Pastilhas";
  bike1.bicicleta();

  cout << endl;

  // Construtor Override

  Bicicleta bike2("XA 200", "Aluminio", "Pastilhas", "Aluminio");
  bike2.bicicleta();

  cout << endl;

// Herança - Montain Bike
  BicicletaMontanha  bike3;
  bike3.modelo = "Attack 500";
  bike3.quadro = "Fibra de Carbono";
  bike3.rodas = "Aluminio";
  bike3.freios = "Disco";
  bike3.amortecedores = "R3000";
  bike3.garrafa = "Aluminio 500ml";
  bike3.marchas = "18 Velocidades";
  bike3.gps = "Discovery 2.5";

// Metodo Override

  bike3.bicicleta();
  system("pause");
  return 0;

}

Classe #2 – Bicicleta.h

#include "stdafx.h"
#include <iostream>
#include <string>
using namespace std;

class Bicicleta
 {
 public:
   string modelo;
   string quadro;
   string freios;
   string rodas;

// Construtor Default
   Bicicleta()   {}

// Construtor Override

  Bicicleta(string bmodelo, string bquadro, string bfreios, string brodas)
  {
   modelo = bmodelo;
   quadro = bquadro;
   rodas  = brodas;
   freios = bfreios;
  }

void bicicleta()
  {
   cout << " Bicicleta:" + modelo << endl;
   cout << " Quadro:" + quadro << endl;
   cout << " Rodas:" + rodas << endl;
   cout << " Freios:" + freios << endl;
  }

};

class BicicletaMontanha : public Bicicleta
 {
 public:
   string marchas;
   string amortecedores;
   string garrafa;
   string gps;

//Metodo Override

void bicicleta()
  {
   cout << " Bicicleta:" + modelo << endl;
   cout << " Quadro:" + quadro << endl;
   cout << " Rodas:" + rodas << endl;
   cout << " Freios:" + freios << endl;
   cout << " Marchas:" + marchas << endl;
   cout << " Amortecedores:" + freios << endl;
   cout << " Garrafa:" + garrafa << endl;
   cout << " Gps:" + gps << endl;
  }
   BicicletaMontanha()
  {
  }

};

A palavra-chave namespace é usada para declarar um escopo que contém um conjunto de objetos relacionados.  Você pode usar um namespace para organizar elementos de código e para criar globalmente tipos exclusivos.

namespaces, ao contrário de classes, não requerem instanciação, você não precisa de um objeto para usar um namespace específico. Você só precisa prefixar a função que você deseja chamar com namespace_name ::  semelhante à forma como você chamaria uma função de um membro estático de uma classe.

Outra conveniência de namespaces é que eles permitem que você use o mesmo nome da função, quando faz sentido fazê-lo, para executar várias ações diferentes

Namespaces podem ser usados ​​para estruturar um programa em “unidades lógicas”. Os namespaces funcionam da mesma forma que setores de uma empresa, dentro de um namespace você pode incluir todas as funções necessárias para cumprir um determinado objetivo. Por exemplo, se você tiver um programa que se conecte à Internet, você pode ter um namespace para lidar com todas as funções de conexão.

Mais informações sobre namespaces C++ você encontra aqui.

Exemplos:

C++

Cpp #1 – Principal

#include "stdafx.h"
#include <iostream>
#include <string>
#include "menssagem.h"

using namespace std;
using namespace Menssagem;

int _tmain(int argc, _TCHAR* argv[])
 {
  menssagem("Estou usando o namespace menssagem");
  menssagem("namespaces em C++ não necessitam instancias");
  menssagem("Desenvolvimento Aberto - C++");
system("pause");
return 0;
 }

.h #1 – Menssagem

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

using namespace std;

namespace Menssagem
 {
  void menssagem(string msg)
  {
   cout << msg << endl;
  }

}

Encapsulamento que em programação orientada a objetos significa separar o programa em partes, o mais isoladas possível. A idéia é tornar o software mais flexível, fácil de modificar e de criar novas implementações. Objetos restringem a visibilidade de seus recursos (atributos e métodos) aos outros usuários. Todo objeto tem uma interface, que determina como os outros objetos podem interagir com ele. A implementação do objeto é encapsulada, isso é, invisível ou visível  fora do próprio objeto.

Public – Quando precede uma lista de membros de classe, o  públic  palavra-chave especifica que esses membros são acessíveis a partir de qualquer função. Isso se aplica a todos os membros declarados até o próximo especificador de acesso ou o fim da classe. Ou seja visível a todos.

Private – Quando precede uma lista de membros de classe, o private palavra-chave especifica que esses membros são acessíveis somente dentro de funções de membro e amigos da classe.  Isso se aplica a todos os membros declarados até o próximo especificador de acesso ou o fim da classe. Ou seja visível somente para membros dentro da classe.

Protected – O protected palavra-chave especifica o acesso a membros de classe no lista de membros até o próximo especificador de acesso (pública ou private) ou no final da definição de classe.  O Protected é mistura entre Public e Private ou seja é visível somente para membros da classe e visível para subclasses.

Publico VS Private

• Publico todas as classes podem usar os métodos e campos.
• Privado apenas a classe  podem usar os métodos e campos.

Por que Controlar o Acesso?

• Proteger informação privada.
• Esclarecer como outros programadores devem usar sua classe.
• Manter a implementação separado da interface.

Exemplo:

imagine o seguinte cenário,  temos uma classe que é responsável por transações de cartões de credito geralmente este tipo de classe pertence a companhia de cartões de credito e foi desenvolvida por um outro programador e esta dentro de uma DLL ou OS, acontece que o desenvolvedor terceirizado cometeu um deslize deixando visível a propriedade numero do cartão. Um desenvolvedor malicioso pode facilmente capturar o numero do cartão referenciando o objeto.

Neste exemplo você deve brincar com o código fonte a fim de resolver o problema de controle de acesso , use CTRL+espaço após a classe para ver a visibilidade de acesso dos métodos e campos.

C++

Classe #1 – Principal

#include "stdafx.h"
#include <iostream>
#include <string>
#include "cartaocredito.h"

using namespace std;

void metodoMalicioso(CartaoCredito& cartao)
 {
    cartao.gastos = 0;
    cout << "Seu numero de cartão: " << cartao.numeroCartao;
 }

int _tmain(int argc, _TCHAR* argv[])
 {
   // Uma transação hipotetica
   CartaoCredito transacao;
   transacao.cobranca("3453 3636 0001 1267", 350.00);

   // Metodo malicioso Injeta um gasto valor de 0 e imprime o numero do cartão
   metodoMalicioso(transacao);

   cout << endl;

   system("pause");

   return 0;
 }

Classe #2 – Cartão de Credito

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

using namespace std;

class CartaoCredito
 {
  // Esta declaração esta errada
  // Deste modo é possive capturar o numero do cartão
  // A classe expos o numero para que seja acessivel de outra classe
  // para não expor os numero use private

// private:
 public:

string numeroCartao;
   double gastos;

//public:
  void cobranca(string nCartao, double valor)
  {
    numeroCartao = nCartao;
    gastos = gastos + valor;
  }

  CartaoCredito()
  {
  }
};

Construtores

Construtores são métodos especiais chamados pelo sistema no momento da criação de um objeto. Eles não possuem valor de retorno, porque você não pode chamar um construtor para um objeto, você só usa o construtor no momento da inicialização do objeto. Construtores representam uma oportunidade de inicializar seus dados de forma organizada. Construtores são obrigatórios em uma classe, mas não é preciso declara-los, caso não declare um construtor por default a declaração é: Classe().

Static

Enquanto a maioria das variáveis ​​declaradas dentro de uma classe ocorre em uma base de instância a instância (o que quer dizer que, para cada instância de uma classe, a variável pode ter um valor diferente), uma variável de membro estático tem o mesmo valor em qualquer instância a classe e nem sequer exige uma instância da classe para existir.

Lembrando que C++ não é preciso declarar uma nova instancia da classe como em Java, um vez a classe declarada basta chama-la sem usar o clássico comando java new:

// Instanciando uma classe JAVA

Bebe Marcia = new Bebe();

// Instanciando uma classe C++

Bebe Marcia;

Exemplo:

Neste cenário queremos saber quantos objetos de uma determinada classe foram instanciados, para isto criamos um contador no construtor do objeto e a cada objeto criado o contador aumenta nos mostrando no final a quantidade exata de novos objetos de uma classe. Visto que nosso contador pertence a classe e não a cada instancia de cada classe, neste caso para usar o contador não precisamos instanciar a classe graças a declaração static.

C++

Classe #1  – Principal

#include "stdafx.h"
#include <iostream>
#include <string>
#include "bebe.h"

using namespace std;

int _tmain(int argc, _TCHAR* argv[])
 {
  Bebe bebe1;
  Bebe bebe2;
  Bebe bebe3;

  cout << "Bebe 1 Construtor: " << bebe1.numeroBebeStatico << " Publico estatico: " << bebe1.numeroPublico() << endl;
  cout << "Bebe 2 Construtor: " << bebe2.numeroBebeStatico << " Publico estatico: " << bebe2.numeroPublico() << endl;
  cout << "Bebe 3 Construtor: " << bebe3.numeroBebeStatico << " Publico estatico: " << bebe3.numeroPublico() << endl;

  system("pause");
  return 0;
 }

Classe # 2 – Construtor

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

 using namespace std;

class Bebe {
 private:
  int id;
  static int numeroBebePublico;

public:

static int numeroBebeStatico;

int numeroPublico()
  {
   numeroBebePublico++;
   return numeroBebePublico;
  }

// Construtor da classe
   Bebe()
  {
   id = Bebe::numeroBebeStatico++;
  }
};
 int Bebe::numeroBebeStatico = 0;
 int Bebe::numeroBebePublico = 0;

Tipos Primitivos

Um tipo primitivo (também conhecido por nativo ou básico) é fornecido por uma linguagem de programação como um bloco de construção básico. Dependendo da implementação da linguagem, os tipos primitivos podem ou não possuir correspondência direta com objetos na memória.

Ex: int, long, double, boolean, char, short, byte, float.

Referência

Referência na ciência da computação é registro que aponta o local em que se encontram armazenados os dados que identificam outro dado.

Tipos são arrays e objetos, – String, int[], Classes, …

Variáveis são como canecas fixas e os primitivos são pequenos o suficiente para caber dentro da caneca. Os objetos são grandes para caber dentro de variáveis. Variáveis guardam números que localizam um objeto e a localização do objeto é chamada de referencia.

Importante: Em C++ o objeto é instanciado a partir de sua criação e é usado o símbolo & ( e comercial)  para referenciar objetos.

Bebe Patricia;

Exemplo:

Neste cenário temos um bebê recém nascido que precisa ser registrado no cartório, para isto vamos criar um objeto bebê e através de um método vamos cadastrar os dados do bebê referenciando o objeto ao nosso bebê.

C++

1 – Classe Referencia – Arquivo referencia.cpp

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

// Inclui Classe Bebê
#include "bebe.h"
using namespace std;

// O objeto Bebe& é responsável pela referencia
// Bebe sem o & não é referenciado, deixando o objeto vazio.
void cartorio(int codigo, string cadastro[] , Bebe& objeto)
  {
      objeto.codigo    = codigo;
      objeto.nome      = cadastro[0];
      objeto.sobreNome = cadastro[1];
      objeto.nomeMae   = cadastro[2];
      objeto.nomePai   = cadastro[3];
      objeto.sexo      = cadastro[4];
  }
int _tmain(int argc, _TCHAR* argv[])
  {
 // Vamos instanciar um novo bebe
 Bebe Samanta;

// Vamos solicitar a ficha de registro para o novo bebê
int codigoCartorio = 1438275;
string fichaRegistro[] = { "Samanta", "Amaral", "Roberto Amaral", "Marcia Amaral", "Feminino" };

// Vamos preerncher a ficha do novo bebê
 cartorio(codigoCartorio, fichaRegistro, Samanta);

 // Imprime registro do bebê
 cout << "Registro de Nascimento:\n"; cout << "\n";
 cout << "Código: " << Samanta.codigo << "\n";
 cout << "Nome: " << Samanta.nome << " " << Samanta.sobreNome << "\n";
 cout << "Nome do Pai: " << Samanta.nomePai << "\n" ;
 cout << "Nome da Mãe: " + Samanta.nomeMae << "\n"; cout << "\n";
 cout << "Registro efetuado com sucesso\n";
 system("pause");
      return 0;
  }

C++ 2- Classe Bebe – Arquivo Bebe.h

#include "stdafx.h"
#include <iostream>
#include <string>
 using namespace std;
class Bebe
  {
   public:  Bebe()
  {
      codigo;
      nome;
      sobreNome;
      nomePai;
      nomeMae;
      sexo;
  }
public:
   int codigo;
   string nome;
   string sobreNome;
   string nomePai;
   string nomeMae;
   string sexo;

  };
 

Programação Orientada a objeto

Programação orientada a objetos representa o mundo real. Na programação orientada a objetos, implementa-se um conjunto de classes que definem os objetos presentes no sistema de software.

Classes

Em orientação a objetos, uma classe é uma estrutura que abstrai um conjunto de objetos com características similares. Uma classe define o comportamento de seus objetos através de métodos e os estados possíveis destes objetos através de atributos. Classes, que podem conter dados e funções, apresentar tipos definidos pelo usuário em um programa. Tipos definidos pelo usuário em linguagens de programação tradicionais são coleções de dados que, em conjunto, descrevem atributos de um objeto e estado. Tipos de classe em C + + permitem que você para descrever os atributos e estado, e para definir o comportamento.

Polimorfismo

Na programação orientada a objetos, o polimorfismo permite que referências de tipos de classes mais abstratas representem o comportamento das classes concretas que referenciam. Assim, é possível tratar vários tipos de maneira homogênea (através da interface do tipo mais abstrato). O termo polimorfismo é originário do grego e significa “muitas formas” (poli = muitas, morphos = formas).

O polimorfismo é caracterizado quando duas ou mais classes distintas tem métodos de mesmo nome, de forma que uma função possa utilizar um objeto de qualquer uma das classes polimórficas, sem necessidade de tratar de forma diferenciada conforme a classe do objeto.

Instanciando Objetos

Instanciação de objetos é o processo de criar a estrutura lógica dos mesmos na memória. Isto ocorre quando declaramos os objetos, pois neste momento todo o processo de construção dos mesmos é efetivado. Assim, toda vez que declaramos um objeto estamos instanciando-o, ou seja, estamos criando uma instância da classe.

Exemplo:

Neste cenário temos  duas classes,  a classe cachorro e a classe espécie, na classe cachorro temos o que todos os cachorros tem em comum e na classe  espécie temos toda a herança da classe cachorro e mais algumas descrições da espécie. Usamos polimorfismo para escrever uma função virtual no qual as duas classes tem em comum:

// Exemplo da palavrea chave class
// Exibe polimorfismo/virtual functions.

#include "stdafx.h"
#include <iostream>
#include <string>
#define TRUE = 1

using namespace std;

// Classe Cachorro
class cachorro
{
public:  cachorro()
{
   _pernas = 4;
   _latido = true;
  }

int getPernas()
  {
   return _pernas;
  }

void setTamanhoCachorro(string tamanhoCachorro)
{
   _tamanhoCachorro = tamanhoCachorro;
}

// Função virtual
virtual void setOrelhas(string tipo)
{
   _tipoOrelhas = tipo;
  }

private:
  string _tamanhoCachorro, _tipoOrelhas;  int _pernas;  bool _latido;

};

// Classe especie
class especie : public cachorro
{
public:

especie(string cor, string tamanho)

{   _cor = cor;
_tamanho = tamanho;
setTamanhoCachorro(tamanho);
  }

string getCor()
  {
   return _cor;
  }

string getTamanhoCachorro()
  {
   return _tamanho;
  }

string getOrelhasComprimento()
  {
   return _orelhaComprimento;

}

string getOrelhaTipo()
  {
   return _orelhaTipo;
  }

// Função virtual redefinida (polimorfismo)
void setOrelhas(string comprimento, string tipo)
  {
   _orelhaComprimento = comprimento;
   _orelhaTipo = tipo;  }

protected:
  string _cor, _orelhaComprimento, _orelhaTipo, _tamanho;
};

// Executa o programa
int main()
 {
  cachorro mongrel;
  especie labrador("amarelo", "grande");

  // Polimorfismo da Classes
  mongrel.setOrelhas("pontuda");
  labrador.setOrelhas("longa", "caidas");

cout << "Bob um mongrel de " << mongrel.getPernas() << " patas " << endl;

cout << "Cody um labrador "  << labrador.getTamanhoCachorro() << " e "
     << labrador.getCor() << " com orelha "
     << labrador.getOrelhasComprimento() << " e "   << labrador.getOrelhaTipo() << endl;

system("pause"); }