Classes de coleção da ATL

A ATL fornece muitas classes para armazenar e acessar dados. Sua decisão de qual classe 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 coleção pequenas

A 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 é recomendável usá-las 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 coleta de uso geral:

Essas classes interceptarão muitos erros de programação quando usadas em builds de depuração, mas, por causa do 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:

Escolher uma classe de coleção

Cada uma das classes de coleção disponíveis oferece diferentes características de desempenho, 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 na qual os itens são inseridos e excluídos determina a ordem deles na coleção, mas isso não significa que os itens sejam classificados em seu conteúdo. O termo "indexado" significa que os itens na coleção podem ser recuperados por um índice inteiro, assim como itens em uma matriz típica.

• As colunas 4 e 5 descrevem o desempenho de cada classe. Em aplicativos que exigem muitas inserções na coleção, a velocidade de inserção pode ser especialmente importante, embora para outros aplicativos, a velocidade de pesquisa talvez seja mais importante.

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

• O desempenho de uma determinada operação de classe de coleção é 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 com duração que aumenta linearmente à medida que o número de elementos aumenta é descrita como um algoritmo O(n). Por outro lado, uma operação com duração 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.

Recursos de forma da coleção

Usar objetos CTraits

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

As classes CTraits são semelhantes, embora mais flexíveis do que as funções auxiliares da classe de coleção MFC. Confira Auxiliares de Classe de Coleção para saber mais.

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 chamadas pelos outros métodos que compõem a classe de coleção. Por exemplo, se o objeto de lista contiver suas próprias estruturas definidas pelo usuário, você talvez queira redefinir o teste de igualdade para comparar apenas determinadas variáveis de membro. Dessa forma, o método Find do objeto de lista funcionará de 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"));
}

Comentários

Para ver uma lista das classes CTraits, confira Classes de Coleção.

O diagrama a seguir mostra a hierarquia de classes para as classes CTraits.

Exemplos de classes de coleção

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

• MMXSwarm Sample

• Exemplo de DynamicConsumer

• Amostra de UpdatePV

• Amostra de letreiro

Confira também

Conceitos
Classes de coleção