Desenvolvimento Código Aberto

Iterator

Em português iterador, é um objeto que permite a um programador examinar uma coleção ou container. Vários tipos de iteradores são frequentemente fornecidos através de uma interface de container. Apesar da interface e semântica de um determinado iterador serem fixas, iteradores são frequentemente implementados em termos de estruturas subjacentes a uma implementação de container e são muitas vezes ligados intimamente ao container para permitir a semântica operacional do iterador.

Observe que um iterador percorre e também dá acesso aos elementos de dados em um container, mas não realiza iteração (isto é, não sem alguma liberdade significativa tomada com este conceito ou com uso trivial da terminologia). Um iterador é tem um comportamento semelhante a um cursor de banco de dados. Iteradores datam da linguagem de programação CLU de 1974.

Collection

É uma coleção, às vezes chamada de um recipiente(container), é simplesmente um objeto que agrupa vários elementos em uma única unidade. Coleções são usadas ​​para armazenar, recuperar, manipular e comunicar dados agregados, ou seja uma coleção é um objeto que contém outros objetos, existem outras coleções com diferentes capacidades.

Historicamente, o quadro de coleções têm sido bastante complexo, o que lhes deu uma reputação de ter uma grande curva de aprendizagem. Os exemplos mais conhecidos de frameworks de coleções são o C ++ Standard Template Library (STL). A nomenclatura das APIs e suas sintaxes podem mudar de uma linguagem de programação para outra.

O framework de coleção e as suas APIs:

Collection é a raiz da hierarquia do conjunto. A coleção representa um grupo de objetos conhecidos como seus elementos.

A interface Collection é o mínimo denominador comum que todos os conjuntos implementam e é usado para passar coleções para manipular objetos quando generalidade máxima é desejada. Alguns tipos de coleções permitem elementos duplicados, e outros não.

• SET – Está diretamente relacionada com a ideia de conjuntos. Assim como um conjunto, as classes que implementam esta interface não podem conter elementos repetidos.
• List –  É uma coleção ordenada, pode conter valores duplicados, o controle da posição de cada elemento é acessado pelo seu índice.
• Queue: é uma lista tipo FIFO (First-In-First-Out), também conhecida como fila.
• Map: é uma lista de relação de chave-valor entre os elementos. Cada chave pode conter apenas um único valor associado.(um mapa não é uma coleção verdadeira).

Exemplos:

Neste exemplo criamos uma collection do tipo List e a alimentamos com nomes de musicas dos Beatles, usamos o iterator para navegar no dentro dos objetos da coleção como cursores de banco de dados, registro a registro, e os alteramos manualmente, fator que as coleções não permitem por default.

Java

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;

public class Iterador
 {

 public static void main(String[] args)
 {
      List<String> colecao = new ArrayList<String>();

   // musicas dos Beatles
   colecao.add("Let it be");
   colecao.add("Dont let me down");
   colecao.add("Come togheter");
   colecao.add("Hey Jude");
   colecao.add("Twist and shout");

   // Usa iterator como um cursor de banco de dados
   Iterator<String>  iterador =  colecao.iterator();

   System.out.println("Cinco musicas dos Beatles:\n");

   while (iterador.hasNext())
   {
     Object item = iterador.next();
     System.out.println(item);
   }

   // Usa iterador como o result de um banco de dados.
   ListIterator<String>  iteradorLista = colecao.listIterator();

   // Update - altera lista
   while (iteradorLista.hasNext())
   {
     Object item = iteradorLista.next();
     iteradorLista.set("Beatles: " + item);
   }

   //Lista a coleção

   System.out.println("\nIverte a ordem da coleção:\n");
   while (iteradorLista.hasPrevious())
   {
     Object item = iteradorLista.previous();
     System.out.println(item);
   }
 }
}

C++

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

int _tmain(int argc, _TCHAR* argv[])
 {
  list<string> colecao;

  colecao.push_back("Let it be");
  colec}ao.push_back("Dont let me down");
  colecao.push_back("Come togheter");
  colecao.push_back("Hey Jude");
  colecao.push_back("Twist and shout");

  // Usa iterator como um cursor de banco de dados
  list<string>::const_iterator
  inicio(colecao.begin()),
  fim(colecao.end());

  list<string>::iterator altera;

  cout << "Cinco musicas dos Beatles:\n" << endl;
  for (; inicio != fim; ++inicio)
  {
   cout << *inicio << endl;
  }

// Usa iterador como o result de um banco de dados.
  // Update - altera lista
  for (altera = colecao.begin(); altera != colecao.end(); ++altera)
  {
    *altera =  "Beatles: " + *altera;
  }

  //Lista a coleção
  colecao.reverse();

  cout << "\nIverte a ordem da coleção:\n" << endl;

  for (altera = colecao.begin(); altera != colecao.end(); ++altera)
  {
   cout << *altera << endl;
  }
  system("pause");
  return 0;
 }

C#

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace DesenvolvimentoAberto
 {
     class Program
     {
         static void Main(string[] args)
         {
             List<String> colecao = new List<String>();

        // musicas dos Beatles
       colecao.Add("Let it be");
       colecao.Add("Dont let me down");
       colecao.Add("Come togheter");
       colecao.Add("Hey Jude");
       colecao.Add("Twist and shout");

       // Usa iterator como um cursor de banco de dados
       Console.WriteLine("Cinco musicas dos Beatles:\n");
       foreach( string item in colecao)
       {
          Console.WriteLine(item);
       }

       // Usa iterador como o result de um banco de dados.
       // Update - altera lista
       int i = 0;
       while (i <= colecao.Count() -1)
       {
          colecao[i] = "Beatles: " + colecao.ElementAt(i);
          i = i + 1;
       }

       //Lista a coleção
       colecao.Reverse();
       Console.WriteLine("\nIverte a ordem da coleção:\n");
       foreach( string item in colecao)
       {
          Console.WriteLine(item);
       }
       Console.ReadKey();
}
    }
 }

Sim, está é a famosa palavra que traduzida para a língua inglesa da nome ao famoso filme Matrix onde as maquinas tomam conta do planeta terra escravizando a raça humana e a usando como fonte de energia. Mas ficção cientifica a parte, fica a pergunta,  o que é matriz?

Sinônimos de útero e mãe, na ciência da computação as matrizes são estruturas matemáticas organizadas na forma de tabela com linhas e colunas, utilizadas na organização de dados e informações. Nos assuntos ligados à álgebra, as matrizes são responsáveis pela solução de sistemas lineares.

Em C++ para utilizar matrizes dentro de classes é necessário alguns detalhes extras, o compilador Microsoft não permite inicializar arrays ou matrizes em uma classe fora do construtor, também possui regras sobre a ordem da declaração da matriz dentro da classe e requer a adição do parâmetro /c na hora da compilação. Para saber mais sobre o assunto use o link abaixo:

Compiler Error C2536: http://msdn.microsoft.com/en-us/library/9f53ks1w.aspx

Como C++ é uma linguagem hibrida e de paradigmas não é necessário utilizar objetos de classe e um código menor consegue obter um programa com o mesmo resultado que em Java e C#.

Exemplos:

Neste exemplo criaremos uma classe que contém uma matriz com as cartas do baralho. Em C++ teremos dois exemplos diferentes, o primeiro sem objetos de classe e o segundo com objetos de classe, mas não utilizando os requisitos da Microsoft.

Java

Classe #1 – Jogo

public class Jogo
 {

public static void main(String[] args)
{
  Cartas jogador1 =  new Cartas();

  // Cartas Disponiveis
  System.out.println("Naipes da Matriz");

  for (int naipes = 0; naipes <= jogador1.tNaipe()-1; naipes++ )
  {
    jogador1.jogaCartas(0, naipes);
  }

  System.out.println();
  System.out.println();
  System.out.println("Componentes da Matriz");

  for (int componentes = 0; componentes <= jogador1.tComponentes()-1; componentes++ )
  {
     jogador1.jogaCartas(1, componentes);
  }

  }
}

Classe #2 -Cartas

public class Cartas
{
private int naipe;
private int componetes;

private String cartas[][] =
{
{ "Paus",  "Ouros",  "Copas",  "Espadas", },
{ "Curinga", "As", "2", "3", "4", "5", "6", "7", "8", "9", "10", "Valete", "Dama", "Rei" }

};

Cartas ()
{ }

Cartas (int naipe, int componentes)
{
this.naipe = naipe;
this.componetes = componentes;
}

public void jogaCartas(int naipe, int componentes)
{
System.out.print(cartas[naipe][componentes] + ", ");
}

public int tNaipe()
{
return this.cartas[0].length;
}

public int tComponentes ()
{
return this.cartas[1].length;
}
}

C#

Classe #1 – Jogo

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace DesenvolvimentoAberto
 {
     class Program
     {
       static void Main(string[] args)
      {
       Cartas jogador1 =  new Cartas();

      // Cartas Disponiveis
      Console.WriteLine("Naipes da Matriz");

      for (int naipes = 0; naipes <= jogador1.tNaipe()-1; naipes++ )
      {
          jogador1.jogaCartas(0, naipes);
      }

      Console.WriteLine();

      Console.WriteLine();
      Console.WriteLine("Componentes da Matriz");

     for (int componentes = 0; componentes <= jogador1.tComponentes()-1; componentes++ )
      {
          jogador1.jogaCartas(1, componentes);
      }

      Console.ReadKey();
      }
    }
 }

Classe #2 -Cartas

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace DesenvolvimentoAberto
 {
     public class Cartas
     {
      private int naipe;
      private int componetes;

         private string[][] cartas =
         {
             new string[]
             { "Paus",  "Ouros",  "Copas",  "Espadas", },

             new string[]

             { "Curinga", "As", "2", "3", "4", "5", "6", "7", "8", "9", "10", "Valete", "Dama", "Rei" }
                                           };
      public Cartas ()
      { }

      public Cartas (int naipe, int componentes)
      {
       this.naipe = naipe;
       this.componetes = componentes;
      }

      public void jogaCartas(int naipe, int componentes)
      {
         Console.Write(cartas[naipe][componentes] + ", ");
      }

      public int tNaipe()
      {
         return this.cartas[0].Length;
      }

      public int tComponentes ()
      {
       return this.cartas[1].Length;
      }
   }
 }

C++

Arquivo #1:

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

using namespace std;

 const int tnaipe = 4;
 const int tcompo = 14;

const string cartas[tnaipe][tcompo] =
 {
  { "Paus", "Ouros", "Copas", "Espadas", },

  { "Curinga", "As", "2", "3", "4", "5", "6", "7", "8", "9", "10", "Valete", "Dama", "Rei" }
 };

 void jogaCartas(int naipe, int componentes)
 {
  cout << cartas[naipe][componentes] << ", ";
 }

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

// Cartas Disponíveis

  cout << "Naipes da Matriz" << endl;

  for (int naipes = 0; naipes <= tnaipe - 1; naipes++)
  {
   jogaCartas(0, naipes);
  }

  cout << endl;  cout << endl;
  cout << "Componentes da Matriz" << endl;

  for (int componentes = 0; componentes <= tcompo - 1; componentes++)
  {
   jogaCartas(1, componentes);
  }

  cout << endl;  system("pause");
  return 0;
 }

C++ – exemplo 2

Arquivo #1 – Jogo

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

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

  cout << "Naipes da Matriz" << endl;

  for (int naipes = 0; naipes <= jogador1.tNaipe() - 1; naipes++)
  {
   jogador1.jogaCartas(0, naipes);
  }

  cout << endl;  cout << endl;
  cout << "Componentes da Matriz" << endl;

  for (int componentes = 0; componentes <= jogador1.tComponentes() - 1; componentes++)
  {
   jogador1.jogaCartas(1, componentes);
  }

  cout << endl;
  system("pause");

  return 0;
 }

Arquivo #2 – Classe Cartas (.h)

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

class Cartas
 {
 public:

  void jogaCartas(int naipe, int componentes)
  {
   cout << cartas[naipe][componentes] << ", " ;
  }

  int tNaipe()
  {
   return tnaipe;
  }

  int tComponentes()
  {
   return tcompo ;
  }

};

Arquivo #3 – da matriz  (.h)

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

const int tnaipe = 4;
const int tcompo = 14;

const string cartas[tnaipe][tcompo] =
 {
  { "Paus", "Ouros", "Copas", "Espadas", },

  { "Curinga", "As", "2", "3", "4", "5", "6", "7", "8", "9", "10", "Valete", "Dama", "Rei" }
 };

Pure Function

Usa os objetos como argumentos, mas não os modifica. o valor de retorno é ou um primitivo ou um novo objeto criado dentro do método.

Um método é considerado uma função pura se o resultado depender apenas dos argumentos, e não ter efeitos colaterais, como modificar um argumento ou imprimir algo. O único resultado de chamar uma função pura é o seu valor de retorno.

Na transformação funcional pura, um conjunto de funções, chamadas funções puras, definem a forma de como transformar um conjunto de dados estruturados a partir de sua forma original para outra forma. A palavra “pura” indica que as funções são combináveis​​, que exige que elas sejam:

Auto-suficiente, de modo que elas podem ser livremente ordenada e rearranjada sem emaranhamento ou interdependências com o resto do programa. Transformações puras não têm conhecimento ou efeito sobre o meio ambiente. Ou seja, as funções utilizadas para a transformação não tem efeitos colaterais.

Sem mudança de estado, de modo que a execução da mesma função ou conjunto específico de funções na mesma entrada sempre resultará na mesma saída. Transformações puras não têm memória do seu uso anterior. Funções puras ajudar a gerenciar a complexidade dos grandes projetos.

Modifiers

Usa objetos como argumentos e modifica alguns elementos ou todos eles. Muitas vezes, retorna uma void. Um método modificador muda a forma como os objetos funcionam.

Fill-in

Um dos argumentos é um objeto vazio que é preenchido pelo método. Tecnicamente, este método também é um tipo de Modifier.

Melhores Praticas

É recomendado que você escreva funções puras sempre que for razoável, e recorra aos Modifiers e Fill-ins apenas se houver uma grande vantagem.

Métodos Modifiers e Fill-in  são eficientes porque eles não têm que criar novos objetos. Mas se torna mais difícil de isolar partes de um programa, e em grandes projetos podem causar erros que são difíceis de encontrar.

Em síntese estes conceitos passam a substituir a nomenclatura das funções e procedimentos das linguagens de programação procedural, por serem métodos integrantes de objetos e não mais procedimentos ou funções auto suficientes, porem ainda são estruturalmente iguais.

Exemplo:

Neste exemplo escrevemos três métodos diferentes: Pure function, Modifier e um fill-in, e manipulamos objetos utilizando estes métodos.

Java

Classe #1 – Principal

public class Metodos
 {

  // Método - Pure Function
  static boolean maxRet(Retangulo ret, int altura, int largura)
  {
     if ((ret.altura <= altura) && (ret.largura <= largura))
     {
         return true;
     }
   else
     {
        return false;
     }
  }

  // Método - Modifiers
  static void posicao(Retangulo ret, int x, int y)
  {
     ret.x = ret.x + x;
     ret.y = ret.y + y;
  }

  // Método - Fill-in
  static void modRet(Retangulo r1, Retangulo r2, Retangulo r3)
  {
     r1.x       =  r2.x      + r3.x;
     r1.y       =  r2.y      + r3.y;
     r1.altura  = r2.altura  + r3.altura;
     r1.largura = r2.largura + r3.largura;
  }

 public static void main(String[] args)
 {

   Retangulo ret1 = new Retangulo(50,50,200,300);
   Retangulo ret2 = new Retangulo(15,15,120,150);
   Retangulo ret3 = new Retangulo();
   ret1.imprimeRet();

   System.out.println("Retangulo está dentro do limite maximo:" + maxRet(ret1, 500, 600));
   System.out.println();
   System.out.println("Modifica posição do retangulo:");
   posicao(ret1, 20, 20);
   ret1.imprimeRet();

   System.out.println();
   System.out.println("Modifica tamanho do retangulo:");
   modRet(ret3, ret1, ret2);
   ret3.imprimeRet();
  }
}

Classe #2 – Retangulo

public class Retangulo
{
public int x;
public int y;
public int altura;
public int largura;

public Retangulo ()
{

}

public Retangulo (int x, int y, int altura, int largura)
{
  this.x       = x;
  this.y       = y;
  this.altura  = altura;
  this.largura = largura;
}

 public void imprimeRet()
 {
  System.out.println("X =" +  x +  " Y= " + y + " Altura="+ altura + " Largura=" + largura );
 }

}

C++

Classe #1 – Principal

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

static bool maxRet(Retangulo& ret, int altura, int largura)
{
  if ((ret.altura <= altura) && (ret.largura <= largura))
  {
     return true;
  }
  else
  {
     return false;
  }
}

 // Método - Modifiers
 static void posicao(Retangulo& ret, int x, int y)
 {
    ret.x = ret.x + x;  ret.y = ret.y + y;
 }

 // Método - Fill-in

 static void modRet(Retangulo& r1, Retangulo& r2, Retangulo& r3)
 {
    r1.x = r2.x + r3.x;
    r1.y = r2.y + r3.y;
    r1.altura = r2.altura + r3.altura;
    r1.largura = r2.largura + r3.largura;
 }

 int _tmain(int argc, _TCHAR* argv[])
 {
    Retangulo ret1 (50, 50, 200, 300);
    Retangulo ret2 (15, 15, 120, 150);
    Retangulo ret3 (0,0,0,0);
    ret1.imprimeRet();

    cout << "Retangulo está dentro do limite maximo:" << maxRet(ret1, 500, 600) << endl;

    cout << endl;
    cout << "Modifica posição do retangulo:" << endl;  posicao(ret1, 20, 20);
    ret1.imprimeRet();

    cout << endl;
    cout << "Modifica tamanho do retangulo:" << endl;  modRet(ret3, ret1, ret2);
    ret3.imprimeRet();

   system("pause");
   return 0;
 }

Classe #2 – Retangulo

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

using namespace std;

class Retangulo
{
 public:

  int x;
  int y;
  int altura;
  int largura;

  Retangulo()
  {  }

  Retangulo(int x, int y, int altura, int largura)
  {
     this->x = x;
     this->y = y;
     this->altura = altura;
     this->largura = largura;
  }

  void imprimeRet()
  {
     cout << "X =" << x << " Y= " << y << " Altura=" << altura << " Largura=" << largura << endl;
  }

};

C#

Classe #1 – Principal

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace DesenvolvimentoAberto
 {
     class Program
     {
         // Método - Pure Function

         static Boolean maxRet(Retangulo ret, int altura, int largura)
         {
             if ((ret.altura <= altura) && (ret.largura <= largura))
             {
                 return true;
             }
             else
             {
                 return false;
             }
         }

         // Método - Modifiers
         static void posicao(Retangulo ret, int x, int y)
         {
             ret.x = ret.x + x;
             ret.y = ret.y + y;
         }

         // Método - Fill-in

         static void modRet(Retangulo r1, Retangulo r2, Retangulo r3)
         {
             r1.x = r2.x + r3.x;
             r1.y = r2.y + r3.y;
             r1.altura = r2.altura + r3.altura;
             r1.largura = r2.largura + r3.largura;
         }

         static void Main(string[] args)
         {
             Retangulo ret1 = new Retangulo(50,50,200,300);
             Retangulo ret2 = new Retangulo(15,15,120,150);
             Retangulo ret3 = new Retangulo();

             ret1.imprimeRet();
             Console.WriteLine("Retangulo está dentro do limite maximo:" + maxRet(ret1, 500, 600));
             Console.WriteLine();

            Console.WriteLine("Modifica posição do retangulo:");
            posicao(ret1, 20, 20);
            ret1.imprimeRet();

           Console.WriteLine();
           Console.WriteLine("Modifica tamanho do retangulo:");
           modRet(ret3, ret1, ret2);
           ret3.imprimeRet();

           Console.ReadKey();
       }
     }
 }

Classe #2 – Retangulo

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace DesenvolvimentoAberto
 {
     class Retangulo
     {
             public int x;
             public int y;
             public int altura;
             public int largura;

             public Retangulo()
             {
             }

             public Retangulo(int x, int y, int altura, int largura)
             {
                 this.x = x;
                 this.y = y;
                 this.altura = altura;
                 this.largura = largura;
             }

             public void imprimeRet()
             {
                 Console.WriteLine("X =" +  x +  " Y= " + y + " Altura="+ altura + " Largura=" + largura );
             }
     }
 }