Classes de coleção ATL

ATL fornece muitas classes para armazenar e acessar dados. A classe que você decide usar depende de vários fatores, incluindo:

• A quantidade de dados a serem armazenados

• Eficiência versus desempenho no acesso aos dados

• A capacidade de acessar os dados por índice ou por chave

• Como os dados são ordenados

• Preferência pessoal

Classes de pequenas coleções

ATL fornece as seguintes classes de matriz para lidar com um pequeno número de objetos. No entanto, essas classes são limitadas e projetadas para uso interno pela ATL. Não é recomendado que você usá-los em seus programas.

Classes de coleção de uso geral

As classes a seguir implementam matrizes, listas e mapas e são fornecidas como classes de coleção de uso geral:

Essas classes intercetarão muitos erros de programação quando usadas em compilações de depuração, mas, por uma questão de desempenho, essas verificações não serão executadas em compilações de varejo.

Classes de coleção especializadas

Classes de coleção mais especializadas também são fornecidas para gerenciar ponteiros de memória e ponteiros de interface:

Escolhendo uma classe de coleção

Cada uma das classes de coleção disponíveis oferece características de desempenho diferentes, conforme mostrado na tabela abaixo.

• As colunas 2 e 3 descrevem as características de ordenação e acesso de cada classe. Na tabela, o termo "ordenado" significa que a ordem em que os itens são inseridos e excluídos determina sua ordem na coleção; isso não significa que os itens são classificados em seu conteúdo. O termo "indexado" significa que os itens da coleção podem ser recuperados por um índice inteiro, muito parecido com os itens em uma matriz típica.

• As colunas 4 e 5 descrevem o desempenho de cada classe. Em aplicações que requerem muitas inserções na coleção, a velocidade de inserção pode ser especialmente importante; Para outras aplicações, a velocidade de pesquisa pode ser mais importante.

• A coluna 6 descreve se cada forma permite elementos duplicados.

• O desempenho de uma determinada operação de classe de coleta é expresso em termos da relação entre o tempo necessário para concluir a operação e o número de elementos na coleção. Uma operação que leva um período de tempo que aumenta linearmente à medida que o número de elementos aumenta é descrita como um algoritmo O(n). Por outro lado, uma operação que leva um período de tempo que aumenta cada vez menos à medida que o número de elementos aumenta é descrita como um algoritmo O(log n). Portanto, em termos de desempenho, os algoritmos O(log n) superam os algoritmos O(n) cada vez mais à medida que o número de elementos aumenta.

Características de Forma da Coleção

Usando objetos CTraits

Como as classes de coleção ATL podem ser usadas para armazenar uma ampla gama de tipos de dados definidos pelo usuário, pode ser útil substituir funções importantes, como comparações. Isto é conseguido usando as classes CTraits.

As classes CTraits são semelhantes, mas mais flexíveis do que as funções auxiliares da classe de coleção MFC; consulte Auxiliares de classe de coleção para obter mais informações.

Ao construir sua classe de coleção, você tem a opção de especificar uma classe CTraits. Essa classe conterá o código que executará operações como comparações quando chamado pelos outros métodos que compõem a classe de coleção. Por exemplo, se seu objeto de lista contiver suas próprias estruturas definidas pelo usuário, convém redefinir o teste de igualdade para comparar apenas determinadas variáveis de membro. Dessa forma, o método Find do objeto list operará de uma maneira mais útil.

Exemplo

Código

// Collection class / traits class example.
// This program demonstrates using a CTraits class
// to create a new comparison operator.

#define MAX_STRING 80

// Define our own data type to store in the list.

struct MyData 
{
   int ID;
   TCHAR name[MAX_STRING];
   TCHAR address[MAX_STRING];
};

// Define our own traits class, making use of the
// existing traits and overriding only the comparison
// we need.

class MyTraits : public CElementTraits< MyData >
{
public:
    // Override the comparison to only compare
    // the ID value.

   static bool CompareElements(const MyData& element1, const MyData& element2)
   {
      if (element1.ID == element2.ID)
         return true;
      else
         return false;
   }
};

void DoAtlCustomTraitsList()
{
   // Declare the array, with our data type and traits class 

   CAtlList < MyData, MyTraits > MyList;

   // Create some variables of our data type

   MyData add_item, search_item;

   // Add some elements to the list.

   add_item.ID = 1;
   _stprintf_s(add_item.name, _T("Rumpelstiltskin"));
   _stprintf_s(add_item.address, _T("One Grimm Way"));

   MyList.AddHead(add_item);

   add_item.ID = 2;
   _stprintf_s(add_item.name, _T("Rapunzel"));
   _stprintf_s(add_item.address, _T("One Grimm Way"));

   MyList.AddHead(add_item);

   add_item.ID = 3;
   _stprintf_s(add_item.name, _T("Cinderella"));
   _stprintf_s(add_item.address, _T("Two Grimm Way"));

   MyList.AddHead(add_item);

   // Create an element which will be used
   // to search the list for a match.

   search_item.ID = 2;
   _stprintf_s(search_item.name, _T("Don't care"));
   _stprintf_s(search_item.address, _T("Don't care"));

   // Perform a comparison by searching for a match
   // between any element in the list, and our
   // search item. This operation will use the
   // (overridden) comparison operator and will
   // find a match when the IDs are the same.

   POSITION i;

   i = MyList.Find(search_item);

   if (i != NULL)
      _tprintf_s(_T("Item found!\n"));
   else
      _tprintf_s(_T("Item not found.\n"));
}

Observações

Para obter uma lista das classes CTraits, consulte Classes de coleção.

O diagrama a seguir mostra a hierarquia das classes CTraits.

Amostras de classes de coleta

Os exemplos a seguir demonstram as classes de coleção:

• Amostra MMXSwarm

• DynamicConsumer Amostra

• Exemplo UpdatePV

• Amostra de letreiro

Ver também

Conceitos
Classes de coleção